Fork branch (#106)

Build support in Windows environment(test 1.6, not test 1.72/1.8)
Reference example of official website Partial implementation
Adding automatic test configuration file(AppVeyor/TravisCI)

252 files changed, 234976 insertions, 940 deletions

diff --git a/pcl/ProjectInliers.cpp b/pcl/ProjectInliers.cpp
new file mode 100644
index 0000000..ef84287
--- /dev/null
+++ b/pcl/ProjectInliers.cpp
@@ -0,0 +1,15 @@
+#include <pcl/point_types.h>
+
+#include "ProjectInliers.h"
+
+// set ksearch and radius to < 0 to disable 
+void mpcl_ProjectInliers_setModelCoefficients(pcl::ProjectInliers<pcl::PointXYZ> &inliers)
+{
+    pcl::ModelCoefficients::Ptr coefficients (new pcl::ModelCoefficients ());
+    coefficients->values.resize (4);
+    coefficients->values[0] = coefficients->values[1] = 0;
+    coefficients->values[2] = 1.0;
+    coefficients->values[3] = 0;
+
+    inliers.setModelCoefficients (coefficients);
+}
\ No newline at end of file
diff --git a/pcl/ProjectInliers.h b/pcl/ProjectInliers.h
new file mode 100644
index 0000000..7983c65
--- /dev/null
+++ b/pcl/ProjectInliers.h
@@ -0,0 +1,11 @@
+#ifndef _ProjectInliers_H_
+#define _ProjectInliers_H_
+
+#include <pcl/point_types.h>
+#include <pcl/ModelCoefficients.h>
+#include <pcl/filters/project_inliers.h>
+
+//
+void mpcl_ProjectInliers_setModelCoefficients(pcl::ProjectInliers<pcl::PointXYZ> &inliers);
+
+#endif
diff --git a/pcl/__init__.py b/pcl/__init__.py
index fa7d71d..de127f3 100644
--- a/pcl/__init__.py
+++ b/pcl/__init__.py
@@ -1,8 +1,11 @@
 # XXX do a more specific import!
 from ._pcl import *
+# vtkSmartPointer.h error (Linux)
+# from .pcl_visualization import *
+# from .pcl_grabber import *
 
-import sys
 
+import sys
 
 def load(path, format=None):
     """Load pointcloud from path.
@@ -23,6 +26,78 @@ def load(path, format=None):
     return p
 
 
+def load_XYZI(path, format=None):
+    """Load pointcloud from path.
+
+    Currently supports PCD and PLY files.
+
+    Format should be "pcd", "ply", or None to infer from the pathname.
+    """
+    format = _infer_format(path, format)
+    p = PointCloud_PointXYZI()
+    try:
+        loader = getattr(p, "_from_%s_file" % format)
+    except AttributeError:
+        raise ValueError("unknown file format %s" % format)
+    if loader(_encode(path)):
+        raise IOError("error while loading pointcloud from %r (format=%r)"
+                      % (path, format))
+    return p
+
+def load_XYZRGB(path, format=None):
+    """
+    Load pointcloud from path.
+    Currently supports PCD and PLY files.
+    Format should be "pcd", "ply", or None to infer from the pathname.
+    """
+    format = _infer_format(path, format)
+    p = PointCloud_PointXYZRGB()
+    try:
+        loader = getattr(p, "_from_%s_file" % format)
+    except AttributeError:
+        raise ValueError("unknown file format %s" % format)
+    if loader(_encode(path)):
+        raise IOError("error while loading pointcloud from %r (format=%r)"
+                      % (path, format))
+    return p
+
+
+def load_XYZRGBA(path, format=None):
+    """
+    Load pointcloud from path.
+    Currently supports PCD and PLY files.
+    Format should be "pcd", "ply", or None to infer from the pathname.
+    """
+    format = _infer_format(path, format)
+    p = PointCloud_PointXYZRGBA()
+    try:
+        loader = getattr(p, "_from_%s_file" % format)
+    except AttributeError:
+        raise ValueError("unknown file format %s" % format)
+    if loader(_encode(path)):
+        raise IOError("error while loading pointcloud from %r (format=%r)"
+                      % (path, format))
+    return p
+
+
+def load_PointWithViewpoint(path, format=None):
+    """
+    Load pointcloud from path.
+    Currently supports PCD and PLY files.
+    Format should be "pcd", "ply", or None to infer from the pathname.
+    """
+    format = _infer_format(path, format)
+    p = PointCloud_PointWithViewpoint()
+    try:
+        loader = getattr(p, "_from_%s_file" % format)
+    except AttributeError:
+        raise ValueError("unknown file format %s" % format)
+    if loader(_encode(path)):
+        raise IOError("error while loading pointcloud from %r (format=%r)"
+                      % (path, format))
+    return p
+
+
 def save(cloud, path, format=None, binary=False):
     """Save pointcloud to file.
 
@@ -37,6 +112,33 @@ def save(cloud, path, format=None, binary=False):
         raise IOError("error while saving pointcloud to %r (format=%r)"
                       % (path, format))
 
+def save_XYZRGBA(cloud, path, format=None, binary=False):
+    """Save pointcloud to file.
+
+    Format should be "pcd", "ply", or None to infer from the pathname.
+    """
+    format = _infer_format(path, format)
+    try:
+        dumper = getattr(cloud, "_to_%s_file" % format)
+    except AttributeError:
+        raise ValueError("unknown file format %s" % format)
+    if dumper(_encode(path), binary):
+        raise IOError("error while saving pointcloud to %r (format=%r)"
+                      % (path, format))
+
+def save_PointNormal(cloud, path, format=None, binary=False):
+    """
+    Save pointcloud to file.
+    Format should be "pcd", "ply", or None to infer from the pathname.
+    """
+    format = _infer_format(path, format)
+    try:
+        dumper = getattr(cloud, "_to_%s_file" % format)
+    except AttributeError:
+        raise ValueError("unknown file format %s" % format)
+    if dumper(_encode(path), binary):
+        raise IOError("error while saving pointcloud to %r (format=%r)"
+                      % (path, format))
 
 def _encode(path):
     # Encode path for use in C++.
diff --git a/pcl/_bind_defs.pxd b/pcl/_bind_defs.pxd
new file mode 100644
index 0000000..69a53a6
--- /dev/null
+++ b/pcl/_bind_defs.pxd
@@ -0,0 +1,21 @@
+# cimport pcl_defs as cpp
+
+cdef extern from "boost/function.hpp" namespace "boost":
+  cdef cppclass function[T]:
+    pass
+
+cdef extern from "boost/bind.hpp" namespace "boost":
+  cdef struct arg:
+    pass
+  cdef function[T] bind[T](T callback, arg _1)
+
+cdef extern from "boost/signals2.hpp" namespace "boost::signals2":
+  cdef cppclass connection:
+    pass
+
+# 
+ctypedef void callback_t(void*)
+# ctypedef void callback2_t(cpp.PointCloud_Ptr_t)
+
+cdef extern from "bind.h":
+  cdef connection register_callback(function[callback_t] callback)
diff --git a/pcl/_pcl.pxd b/pcl/_pcl.pxd
index 6f37d56..fab8238 100644
--- a/pcl/_pcl.pxd
+++ b/pcl/_pcl.pxd
@@ -1,16 +1,202 @@
-# Header for _pcl.pyx functionality that needs sharing with other
-# modules.
+# -*- coding: utf-8 -*-
+# Header for _pcl.pyx functionality that needs sharing with other modules.
 
 cimport pcl_defs as cpp
+# KdTree
+cimport pcl_kdtree as pclkdt
+# RangeImage
+cimport pcl_range_image as pcl_rngimg
+# Features
+cimport pcl_features as pcl_ftr
+# SampleConsensus
+cimport pcl_sample_consensus as pcl_sac
 
-
+# class override(PointCloud)
 cdef class PointCloud:
-    cdef cpp.PointCloudPtr_t thisptr_shared
-
+    cdef cpp.PointCloudPtr_t thisptr_shared     # XYZ
+    
     # Buffer protocol support.
     cdef Py_ssize_t _shape[2]
     cdef Py_ssize_t _view_count
-
+    
     cdef inline cpp.PointCloud[cpp.PointXYZ] *thisptr(self) nogil:
         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
         return self.thisptr_shared.get()
+
+
+# class override(PointCloud_PointXYZI)
+cdef class PointCloud_PointXYZI:
+    cdef cpp.PointCloud_PointXYZI_Ptr_t thisptr_shared     # XYZI
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[cpp.PointXYZI] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+        return self.thisptr_shared.get()
+
+
+# class override(PointCloud_PointXYZRGB)
+cdef class PointCloud_PointXYZRGB:
+    cdef cpp.PointCloud_PointXYZRGB_Ptr_t thisptr_shared
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[cpp.PointXYZRGB] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGB>.
+        return self.thisptr_shared.get()
+
+
+# class override(PointCloud_PointXYZRGBA)
+cdef class PointCloud_PointXYZRGBA:
+    cdef cpp.PointCloud_PointXYZRGBA_Ptr_t thisptr_shared   # XYZRGBA
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[cpp.PointXYZRGBA] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGBA>.
+        return self.thisptr_shared.get()
+
+# class override
+cdef class Vertices:
+    cdef cpp.VerticesPtr_t thisptr_shared     # Vertices
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.Vertices *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying Vertices
+        return self.thisptr_shared.get()
+
+# class override(PointCloud_PointWithViewpoint)
+cdef class PointCloud_PointWithViewpoint:
+    cdef cpp.PointCloud_PointWithViewpoint_Ptr_t thisptr_shared   # PointWithViewpoint
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[cpp.PointWithViewpoint] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PointWithViewpoint>.
+        return self.thisptr_shared.get()
+
+
+# class override(PointCloud_Normal)
+cdef class PointCloud_Normal:
+    cdef cpp.PointCloud_Normal_Ptr_t thisptr_shared   # Normal
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[cpp.Normal] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<Normal>.
+        return self.thisptr_shared.get()
+
+
+# class override(PointCloud_PointNormal)
+cdef class PointCloud_PointNormal:
+    cdef cpp.PointCloud_PointNormal_Ptr_t thisptr_shared   # PointNormal
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[cpp.PointNormal] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PointNormal>.
+        return self.thisptr_shared.get()
+
+
+## KdTree
+# class override
+cdef class KdTree:
+    cdef pclkdt.KdTreePtr_t thisptr_shared   # KdTree
+    
+    cdef inline pclkdt.KdTree[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying KdTree<PointXYZ>.
+        return self.thisptr_shared.get()
+
+# cdef class KdTreeFLANN:
+#     cdef pclkdt.KdTreeFLANNPtr_t thisptr_shared   # KdTreeFLANN
+#     
+#     cdef inline pclkdt.KdTreeFLANN[cpp.PointXYZ] *thisptr(self) nogil:
+#         # Shortcut to get raw pointer to underlying KdTreeFLANN<PointXYZ>.
+#         return self.thisptr_shared.get()
+
+
+## RangeImages
+# class override
+cdef class RangeImages:
+    cdef pcl_rngimg.RangeImagePtr_t thisptr_shared   # RangeImages
+    
+    cdef inline pcl_rngimg.RangeImage *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying RangeImage.
+        return self.thisptr_shared.get()
+
+
+### Features
+# class override
+cdef class IntegralImageNormalEstimation:
+    cdef pcl_ftr.IntegralImageNormalEstimationPtr_t thisptr_shared     # IntegralImageNormalEstimation
+    
+    cdef inline pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>.
+        return self.thisptr_shared.get()
+
+
+## SampleConsensus
+# class override
+cdef class SampleConsensusModel:
+    cdef pcl_sac.SampleConsensusModelPtr_t thisptr_shared     # SampleConsensusModel
+    
+    cdef inline pcl_sac.SampleConsensusModel[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::SampleConsensusModel<pcl::PointXYZ>.
+        return self.thisptr_shared.get()
+
+cdef class SampleConsensusModelPlane:
+    cdef pcl_sac.SampleConsensusModelPlanePtr_t thisptr_shared     # SampleConsensusModelPlane
+    
+    cdef inline pcl_sac.SampleConsensusModelPlane[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelPlane<pcl::PointXYZ>.
+        return self.thisptr_shared.get()
+
+cdef class SampleConsensusModelSphere:
+    cdef pcl_sac.SampleConsensusModelSpherePtr_t thisptr_shared     # SampleConsensusModelSphere
+    
+    cdef inline pcl_sac.SampleConsensusModelSphere[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelSphere<pcl::PointXYZ>.
+        return self.thisptr_shared.get()
+
+cdef class SampleConsensusModelCylinder:
+    cdef pcl_sac.SampleConsensusModelCylinderPtr_t thisptr_shared     # SampleConsensusModelSphere
+    
+    cdef inline pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelCylinder<pcl::PointXYZ, pcl::Normal>.
+        return self.thisptr_shared.get()
+
+cdef class SampleConsensusModelLine:
+    cdef pcl_sac.SampleConsensusModelLinePtr_t thisptr_shared     # SampleConsensusModelLine
+    
+    cdef inline pcl_sac.SampleConsensusModelLine[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelLine<pcl::PointXYZ>.
+        return self.thisptr_shared.get()
+
+cdef class SampleConsensusModelRegistration:
+    cdef pcl_sac.SampleConsensusModelRegistrationPtr_t thisptr_shared     # SampleConsensusModelRegistration
+    
+    cdef inline pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelRegistration<pcl::PointXYZ>.
+        return self.thisptr_shared.get()
+
+cdef class SampleConsensusModelStick:
+    cdef pcl_sac.SampleConsensusModelStickPtr_t thisptr_shared     # SampleConsensusModelStick
+    
+    cdef inline pcl_sac.SampleConsensusModelStick[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelStick<pcl::PointXYZ>.
+        return self.thisptr_shared.get()
diff --git a/pcl/_pcl.pyx b/pcl/_pcl.pyx
index d65fa59..1017865 100644
--- a/pcl/_pcl.pyx
+++ b/pcl/_pcl.pyx
@@ -1,15 +1,24 @@
-#cython: embedsignature=True
+ -*- coding: utf-8 -*-
+# cython: embedsignature=True
+
 
 from collections import Sequence
 import numbers
 import numpy as np
-
 cimport numpy as cnp
 
+cimport pcl_common as pcl_cmn
 cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sc
+cimport pcl_features as pcl_ftr
+cimport pcl_filters as pcl_fil
+cimport pcl_range_image as pcl_r_img
+cimport pcl_segmentation as pclseg
 
 cimport cython
-from cython.operator import dereference as deref
+# from cython.operator import dereference as deref
+from cython.operator cimport dereference as deref, preincrement as inc
+from cython cimport address
 
 from cpython cimport Py_buffer
 
@@ -17,759 +26,140 @@ from libcpp.string cimport string
 from libcpp cimport bool
 from libcpp.vector cimport vector
 
-from shared_ptr cimport sp_assign
-
-cdef extern from "minipcl.h":
-    void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,
-                              double searchRadius,
-                              cpp.PointNormalCloud_t) except +
-    void mpcl_sacnormal_set_axis(cpp.SACSegmentationNormal_t,
-                                 double ax, double ay, double az) except +
-    void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,
-                      cpp.PointIndices_t *, bool) except +
-
-SAC_RANSAC = cpp.SAC_RANSAC
-SAC_LMEDS = cpp.SAC_LMEDS
-SAC_MSAC = cpp.SAC_MSAC
-SAC_RRANSAC = cpp.SAC_RRANSAC
-SAC_RMSAC = cpp.SAC_RMSAC
-SAC_MLESAC = cpp.SAC_MLESAC
-SAC_PROSAC = cpp.SAC_PROSAC
-
-SACMODEL_PLANE = cpp.SACMODEL_PLANE
-SACMODEL_LINE = cpp.SACMODEL_LINE
-SACMODEL_CIRCLE2D = cpp.SACMODEL_CIRCLE2D
-SACMODEL_CIRCLE3D = cpp.SACMODEL_CIRCLE3D
-SACMODEL_SPHERE = cpp.SACMODEL_SPHERE
-SACMODEL_CYLINDER = cpp.SACMODEL_CYLINDER
-SACMODEL_CONE = cpp.SACMODEL_CONE
-SACMODEL_TORUS = cpp.SACMODEL_TORUS
-SACMODEL_PARALLEL_LINE = cpp.SACMODEL_PARALLEL_LINE
-SACMODEL_PERPENDICULAR_PLANE = cpp.SACMODEL_PERPENDICULAR_PLANE
-SACMODEL_PARALLEL_LINES = cpp.SACMODEL_PARALLEL_LINES
-SACMODEL_NORMAL_PLANE = cpp.SACMODEL_NORMAL_PLANE 
-#SACMODEL_NORMAL_SPHERE = cpp.SACMODEL_NORMAL_SPHERE
-SACMODEL_REGISTRATION = cpp.SACMODEL_REGISTRATION
-SACMODEL_PARALLEL_PLANE = cpp.SACMODEL_PARALLEL_PLANE
-SACMODEL_NORMAL_PARALLEL_PLANE = cpp.SACMODEL_NORMAL_PARALLEL_PLANE
-SACMODEL_STICK = cpp.SACMODEL_STICK
+# cimport pcl_segmentation as pclseg
 
+from boost_shared_ptr cimport sp_assign
 
 cnp.import_array()
 
+### Enum ###
+
+## Enum Setting
+SAC_RANSAC = pcl_sc.SAC_RANSAC
+SAC_LMEDS = pcl_sc.SAC_LMEDS
+SAC_MSAC = pcl_sc.SAC_MSAC
+SAC_RRANSAC = pcl_sc.SAC_RRANSAC
+SAC_RMSAC = pcl_sc.SAC_RMSAC
+SAC_MLESAC = pcl_sc.SAC_MLESAC
+SAC_PROSAC = pcl_sc.SAC_PROSAC
+
+SACMODEL_PLANE = pcl_sc.SACMODEL_PLANE
+SACMODEL_LINE = pcl_sc.SACMODEL_LINE
+SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D
+SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D
+SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE
+SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER
+SACMODEL_CONE = pcl_sc.SACMODEL_CONE
+SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS
+SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE
+SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE
+SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES
+SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE 
+SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE
+SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION
+SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE
+SACMODEL_NORMAL_PARALLEL_PLANE = pcl_sc.SACMODEL_NORMAL_PARALLEL_PLANE
+SACMODEL_STICK = pcl_sc.SACMODEL_STICK
+
+### Enum Setting(define Class InternalType) ###
+
+# CythonCompareOp
+@cython.internal
+cdef class _CythonCompareOp_Type:
+    cdef:
+        readonly int GT
+        readonly int GE
+        readonly int LT
+        readonly int LE
+        readonly int EQ
 
-cdef class Segmentation:
-    """
-    Segmentation class for Sample Consensus methods and models
-    """
-    cdef cpp.SACSegmentation_t *me
-    def __cinit__(self):
-        self.me = new cpp.SACSegmentation_t()
-    def __dealloc__(self):
-        del self.me
-
-    def segment(self):
-        cdef cpp.PointIndices ind
-        cdef cpp.ModelCoefficients coeffs
-        self.me.segment (ind, coeffs)
-        return [ind.indices[i] for i in range(ind.indices.size())],\
-               [coeffs.values[i] for i in range(coeffs.values.size())]
-
-    def set_optimize_coefficients(self, bool b):
-        self.me.setOptimizeCoefficients(b)
-    def set_model_type(self, cpp.SacModel m):
-        self.me.setModelType(m)
-    def set_method_type(self, int m):
-        self.me.setMethodType (m)
-    def set_distance_threshold(self, float d):
-        self.me.setDistanceThreshold (d)
-
-#yeah, I can't be bothered making this inherit from SACSegmentation, I forget the rules
-#for how this works in cython templated extension types anyway
-cdef class SegmentationNormal:
-    """
-    Segmentation class for Sample Consensus methods and models that require the
-    use of surface normals for estimation.
-
-    Due to Cython limitations this should derive from pcl.Segmentation, but
-    is currently unable to do so.
-    """
-    cdef cpp.SACSegmentationNormal_t *me
-    def __cinit__(self):
-        self.me = new cpp.SACSegmentationNormal_t()
-    def __dealloc__(self):
-        del self.me
-
-    def segment(self):
-        cdef cpp.PointIndices ind
-        cdef cpp.ModelCoefficients coeffs
-        self.me.segment (ind, coeffs)
-        return [ind.indices[i] for i in range(ind.indices.size())],\
-               [coeffs.values[i] for i in range(coeffs.values.size())]
-
-    def set_optimize_coefficients(self, bool b):
-        self.me.setOptimizeCoefficients(b)
-    def set_model_type(self, cpp.SacModel m):
-        self.me.setModelType(m)
-    def set_method_type(self, int m):
-        self.me.setMethodType (m)
-    def set_distance_threshold(self, float d):
-        self.me.setDistanceThreshold (d)
-    def set_optimize_coefficients(self, bool b):
-        self.me.setOptimizeCoefficients (b)
-    def set_normal_distance_weight(self, float f):
-        self.me.setNormalDistanceWeight (f)
-    def set_max_iterations(self, int i):
-        self.me.setMaxIterations (i)
-    def set_radius_limits(self, float f1, float f2):
-        self.me.setRadiusLimits (f1, f2)
-    def set_eps_angle(self, double ea):
-        self.me.setEpsAngle (ea)
-    def set_axis(self, double ax, double ay, double az):
-        mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
-    def set_min_max_opening_angle(self, double min_angle, double max_angle):
-        """ Set the minimum and maximum cone opening angles in radians for a cone model.
-        """
-        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
-    def get_min_max_opening_angle(self):
-        min_angle = 0.0
-        max_angle = 0.0
-        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
-        return min_angle, max_angle
-
-
-# Empirically determine strides, for buffer protocol support.
-# XXX Is there a more elegant way to get these?
-cdef Py_ssize_t _strides[2]
-cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],
-                                               [4, 5, 6]], dtype=np.float32))
-cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()
-_strides[0] = (  <Py_ssize_t><void *>cpp.getptr(p, 1)
-               - <Py_ssize_t><void *>cpp.getptr(p, 0))
-_strides[1] = (  <Py_ssize_t><void *>&(cpp.getptr(p, 0).y)
-               - <Py_ssize_t><void *>&(cpp.getptr(p, 0).x))
-_pc_tmp = None
-
-
-cdef class PointCloud:
-    """Represents a cloud of points in 3-d space.
-
-    A point cloud can be initialized from either a NumPy ndarray of shape
-    (n_points, 3), from a list of triples, or from an integer n to create an
-    "empty" cloud of n points.
-
-    To load a point cloud from disk, use pcl.load.
-    """
-    def __cinit__(self, init=None):
-        cdef PointCloud other
-
-        self._view_count = 0
-
-        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
-
-        if init is None:
-            return
-        elif isinstance(init, (numbers.Integral, np.integer)):
-            self.resize(init)
-        elif isinstance(init, np.ndarray):
-            self.from_array(init)
-        elif isinstance(init, Sequence):
-            self.from_list(init)
-        elif isinstance(init, type(self)):
-            other = init
-            self.thisptr()[0] = other.thisptr()[0]
-        else:
-            raise TypeError("Can't initialize a PointCloud from a %s"
-                            % type(init))
-
-    property width:
-        """ property containing the width of the point cloud """
-        def __get__(self): return self.thisptr().width
-    property height:
-        """ property containing the height of the point cloud """
-        def __get__(self): return self.thisptr().height
-    property size:
-        """ property containing the number of points in the point cloud """
-        def __get__(self): return self.thisptr().size()
-    property is_dense:
-        """ property containing whether the cloud is dense or not """
-        def __get__(self): return self.thisptr().is_dense
-
-    def __repr__(self):
-        return "<PointCloud of %d points>" % self.size
-
-    # Buffer protocol support. Taking a view locks the pointcloud for
-    # resizing, because that can move it around in memory.
-    def __getbuffer__(self, Py_buffer *buffer, int flags):
-        # TODO parse flags
-        cdef Py_ssize_t npoints = self.thisptr().size()
-
-        if self._view_count == 0:
-            self._shape[0] = npoints
-            self._shape[1] = 3
-        self._view_count += 1
-
-        buffer.buf = <char *>&(cpp.getptr_at(self.thisptr(), 0).x)
-        buffer.format = 'f'
-        buffer.internal = NULL
-        buffer.itemsize = sizeof(float)
-        buffer.len = npoints * 3 * sizeof(float)
-        buffer.ndim = 2
-        buffer.obj = self
-        buffer.readonly = 0
-        buffer.shape = self._shape
-        buffer.strides = _strides
-        buffer.suboffsets = NULL
-
-    def __releasebuffer__(self, Py_buffer *buffer):
-        self._view_count -= 1
-
-    # Pickle support. XXX this copies the entire pointcloud; it would be nice
-    # to have an asarray member that returns a view, or even better, implement
-    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
-    def __reduce__(self):
-        return type(self), (self.to_array(),)
-
-    property sensor_origin:
-        def __get__(self):
-            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
-            cdef float *data = origin.data()
-            return np.array([data[0], data[1], data[2], data[3]],
-                            dtype=np.float32)
-
-    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()])
-
-    @cython.boundscheck(False)
-    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
-        """
-        Fill this object from a 2D numpy array (float32)
-        """
-        assert arr.shape[1] == 3
-
-        cdef cnp.npy_intp npts = arr.shape[0]
-        self.resize(npts)
-        self.thisptr().width = npts
-        self.thisptr().height = 1
-
-        cdef cpp.PointXYZ *p
-        for i in range(npts):
-            p = cpp.getptr(self.thisptr(), i)
-            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
-
-    @cython.boundscheck(False)
-    def to_array(self):
-        """
-        Return this object as a 2D numpy array (float32)
-        """
-        cdef float x,y,z
-        cdef cnp.npy_intp n = self.thisptr().size()
-        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
-        cdef cpp.PointXYZ *p
-
-        result = np.empty((n, 3), dtype=np.float32)
-
-        for i in range(n):
-            p = cpp.getptr(self.thisptr(), i)
-            result[i, 0] = p.x
-            result[i, 1] = p.y
-            result[i, 2] = p.z
-        return result
-
-    def from_list(self, _list):
-        """
-        Fill this pointcloud from a list of 3-tuples
-        """
-        cdef Py_ssize_t npts = len(_list)
-        cdef cpp.PointXYZ *p
-
-        self.resize(npts)
-        self.thisptr().width = npts
-        self.thisptr().height = 1
-        for i, l in enumerate(_list):
-            p = cpp.getptr(self.thisptr(), i)
-            p.x, p.y, p.z = l
-
-    def to_list(self):
-        """
-        Return this object as a list of 3-tuples
-        """
-        return self.to_array().tolist()
-
-    def resize(self, cnp.npy_intp x):
-        if self._view_count > 0:
-            raise ValueError("can't resize PointCloud while there are"
-                             " arrays/memoryviews referencing it")
-        self.thisptr().resize(x)
-
-    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
-        """
-        Return a point (3-tuple) at the given row/column
-        """
-        cdef cpp.PointXYZ *p = cpp.getptr_at(self.thisptr(), row, col)
-        return p.x, p.y, p.z
-
-    def __getitem__(self, cnp.npy_intp idx):
-        cdef cpp.PointXYZ *p = cpp.getptr_at(self.thisptr(), idx)
-        return p.x, p.y, p.z
-
-    def from_file(self, char *f):
-        """
-        Fill this pointcloud from a file (a local path).
-        Only pcd files supported currently.
-
-        Deprecated; use pcl.load instead.
-        """
-        return self._from_pcd_file(f)
-
-    def _from_pcd_file(self, const char *s):
-        cdef int error = 0
-        with nogil:
-            ok = cpp.loadPCDFile(string(s), deref(self.thisptr()))
-        return error
-
-    def _from_ply_file(self, const char *s):
-        cdef int ok = 0
-        with nogil:
-            error = cpp.loadPLYFile(string(s), deref(self.thisptr()))
-        return error
-
-    def to_file(self, const char *fname, bool ascii=True):
-        """Save pointcloud to a file in PCD format.
-
-        Deprecated: use pcl.save instead.
-        """
-        return self._to_pcd_file(fname, not ascii)
-
-    def _to_pcd_file(self, const char *f, bool binary=False):
-        cdef int error = 0
-        cdef string s = string(f)
-        with nogil:
-            error = cpp.savePCDFile(s, deref(self.thisptr()), binary)
-        return error
-
-    def _to_ply_file(self, const char *f, bool binary=False):
-        cdef int error = 0
-        cdef string s = string(f)
-        with nogil:
-            error = cpp.savePLYFile(s, deref(self.thisptr()), binary)
-        return error
-
-    def make_segmenter(self):
-        """
-        Return a pcl.Segmentation object with this object set as the input-cloud
-        """
-        seg = Segmentation()
-        cdef cpp.SACSegmentation_t *cseg = <cpp.SACSegmentation_t *>seg.me
-        cseg.setInputCloud(self.thisptr_shared)
-        return seg
-
-    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
-        """
-        Return a pcl.SegmentationNormal object with this object set as the input-cloud
-        """
-        cdef cpp.PointNormalCloud_t normals
-        mpcl_compute_normals(deref(self.thisptr()), ksearch, searchRadius,
-                             normals)
-
-        seg = SegmentationNormal()
-        cdef cpp.SACSegmentationNormal_t *cseg = <cpp.SACSegmentationNormal_t *>seg.me
-        cseg.setInputCloud(self.thisptr_shared)
-        cseg.setInputNormals (normals.makeShared());
-
-        return seg
 
-    def make_statistical_outlier_filter(self):
-        """
-        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
-        """
-        fil = StatisticalOutlierRemovalFilter()
-        cdef cpp.StatisticalOutlierRemoval_t *cfil = <cpp.StatisticalOutlierRemoval_t *>fil.me
-        cfil.setInputCloud(self.thisptr_shared)
-        return fil
-
-    def make_voxel_grid_filter(self):
-        """
-        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
-        """
-        fil = VoxelGridFilter()
-        cdef cpp.VoxelGrid_t *cfil = <cpp.VoxelGrid_t *>fil.me
-        cfil.setInputCloud(self.thisptr_shared)
-        return fil
-
-    def make_passthrough_filter(self):
-        """
-        Return a pcl.PassThroughFilter object with this object set as the input-cloud
-        """
-        fil = PassThroughFilter()
-        cdef cpp.PassThrough_t *cfil = <cpp.PassThrough_t *>fil.me
-        cfil.setInputCloud(self.thisptr_shared)
-        return fil
-
-    def make_moving_least_squares(self):
-        """
-        Return a pcl.MovingLeastSquares object with this object as input cloud.
-        """
-        mls = MovingLeastSquares()
-        cdef cpp.MovingLeastSquares_t *cmls = <cpp.MovingLeastSquares_t *>mls.me
-        cmls.setInputCloud(self.thisptr_shared)
-        return mls
-
-    def make_kdtree_flann(self):
-        """
-        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
-
-        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
-        """
-        return KdTreeFLANN(self)
-
-    def make_octree(self, double resolution):
-        """
-        Return a pcl.octree object with this object set as the input-cloud
-        """
-        octree = OctreePointCloud(resolution)
-        octree.set_input_cloud(self)
-        return octree
-
-    def extract(self, pyindices, bool negative=False):
-        """
-        Given a list of indices of points in the pointcloud, return a 
-        new pointcloud containing only those points.
-        """
-        cdef PointCloud result
-        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
-
-        for i in pyindices:
-            ind.indices.push_back(i)
-
-        result = PointCloud()
-        mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)
-        # XXX are we leaking memory here? del ind causes a double free...
-
-        return result
-
-cdef class StatisticalOutlierRemovalFilter:
-    """
-    Filter class uses point neighborhood statistics to filter outlier data.
-    """
-    cdef cpp.StatisticalOutlierRemoval_t *me
-    def __cinit__(self):
-        self.me = new cpp.StatisticalOutlierRemoval_t()
-    def __dealloc__(self):
-        del self.me
-
-    property mean_k:
-        def __get__(self):
-            return self.me.getMeanK()
-        def __set__(self, int k):
-            self.me.setMeanK(k)
-
-    property negative:
-        def __get__(self):
-            return self.me.getNegative()
-        def __set__(self, bool neg):
-            self.me.setNegative(neg)
-
-    property stddev_mul_thresh:
-        def __get__(self):
-            return self.me.getStddevMulThresh()
-        def __set__(self, double thresh):
-            self.me.setStddevMulThresh(thresh)
-
-    def set_mean_k(self, int k):
-        """
-        Set the number of points (k) to use for mean distance estimation. 
-        """
-        self.me.setMeanK(k)
-
-    def set_std_dev_mul_thresh(self, double std_mul):
-        """
-        Set the standard deviation multiplier threshold.
-        """
-        self.me.setStddevMulThresh(std_mul)
-
-    def set_negative(self, bool negative):
-        """
-        Set whether the indices should be returned, or all points except the indices. 
-        """
-        self.me.setNegative(negative)
-
-    def filter(self):
-        """
-        Apply the filter according to the previously set parameters and return
-        a new pointcloud
-        """
-        cdef PointCloud pc = PointCloud()
-        self.me.filter(pc.thisptr()[0])
-        return pc
-
-cdef class MovingLeastSquares:
-    """
-    Smoothing class which is an implementation of the MLS (Moving Least Squares)
-    algorithm for data smoothing and improved normal estimation.
-    """
-    cdef cpp.MovingLeastSquares_t *me
-    def __cinit__(self):
-        self.me = new cpp.MovingLeastSquares_t()
-    def __dealloc__(self):
-        del self.me
-
-    def set_search_radius(self, double radius):
-        """
-        Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. 
-        """
-        self.me.setSearchRadius (radius)
-
-    def set_polynomial_order(self, bool order):
-        """
-        Set the order of the polynomial to be fit. 
-        """
-        self.me.setPolynomialOrder(order)
-
-    def set_polynomial_fit(self, bint fit):
-        """
-        Sets whether the surface and normal are approximated using a polynomial,
-        or only via tangent estimation.
-        """
-        self.me.setPolynomialFit(fit)
-
-    def process(self):
-        """
-        Apply the smoothing according to the previously set values and return
-        a new pointcloud
-        """
-        cdef PointCloud pc = PointCloud()
-        self.me.process(pc.thisptr()[0])
-        return pc
-
-cdef class VoxelGridFilter:
-    """
-    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
-    """
-    cdef cpp.VoxelGrid_t *me
     def __cinit__(self):
-        self.me = new cpp.VoxelGrid_t()
-    def __dealloc__(self):
-        del self.me
-
-    def set_leaf_size (self, float x, float y, float z):
-        """
-        Set the voxel grid leaf size.
-        """
-        self.me.setLeafSize(x,y,z)
-
-    def filter(self):
-        """
-        Apply the filter according to the previously set parameters and return
-        a new pointcloud
-        """
-        cdef PointCloud pc = PointCloud()
-        self.me.filter(pc.thisptr()[0])
-        return pc
+        self.GT = pcl_fil.COMPAREOP_GT
+        self.GE = pcl_fil.COMPAREOP_GE
+        self.LT = pcl_fil.COMPAREOP_LT
+        self.LE = pcl_fil.COMPAREOP_LE
+        self.EQ = pcl_fil.COMPAREOP_EQ
+
+CythonCompareOp_Type = _CythonCompareOp_Type()
+
+# RangeImage 
+# CythonCoordinateFrame
+@cython.internal
+cdef class _CythonCoordinateFrame_Type:
+    cdef:
+        readonly int CAMERA_FRAME
+        readonly int LASER_FRAME
 
-cdef class PassThroughFilter:
-    """
-    Passes points in a cloud based on constraints for one particular field of the point type
-    """
-    cdef cpp.PassThrough_t *me
     def __cinit__(self):
-        self.me = new cpp.PassThrough_t()
-    def __dealloc__(self):
-        del self.me
-
-    def set_filter_field_name(self, field_name):
-        cdef bytes fname_ascii
-        if isinstance(field_name, unicode):
-            fname_ascii = field_name.encode("ascii")
-        elif not isinstance(field_name, bytes):
-            raise TypeError("field_name should be a string, got %r"
-                            % field_name)
-        else:
-            fname_ascii = field_name
-        self.me.setFilterFieldName(string(fname_ascii))
-
-    def set_filter_limits(self, float filter_min, float filter_max):
-        self.me.setFilterLimits (filter_min, filter_max)
-
-    def filter(self):
-        """
-        Apply the filter according to the previously set parameters and return
-        a new pointcloud
-        """
-        cdef PointCloud pc = PointCloud()
-        self.me.filter(pc.thisptr()[0])
-        return pc
-
-cdef class KdTreeFLANN:
-    """
-    Finds k nearest neighbours from points in another pointcloud to points in
-    a reference pointcloud.
-
-    Must be constructed from the reference point cloud, which is copied, so
-    changed to pc are not reflected in KdTreeFLANN(pc).
-    """
-    cdef cpp.KdTreeFLANN_t *me
-
-    def __cinit__(self, PointCloud pc not None):
-        self.me = new cpp.KdTreeFLANN_t()
-        self.me.setInputCloud(pc.thisptr_shared)
-
-    def __dealloc__(self):
-        del self.me
-
-    def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):
-        """
-        Find the k nearest neighbours and squared distances for all points
-        in the pointcloud. Results are in ndarrays, size (pc.size, k)
-        Returns: (k_indices, k_sqr_distances)
-        """
-        cdef cnp.npy_intp n_points = pc.size
-        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
-                                                          dtype=np.float32)
-        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
-                                                     dtype=np.int32)
-
-        for i in range(n_points):
-            self._nearest_k(pc, i, k, ind[i], sqdist[i])
-        return ind, sqdist
-
-    def nearest_k_search_for_point(self, PointCloud pc not None, int index,
-                                   int k=1):
-        """
-        Find the k nearest neighbours and squared distances for the point
-        at pc[index]. Results are in ndarrays, size (k)
-        Returns: (k_indices, k_sqr_distances)
-        """
-        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
-        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
-
-        self._nearest_k(pc, index, k, ind, sqdist)
-        return ind, sqdist
-
-    @cython.boundscheck(False)
-    cdef void _nearest_k(self, PointCloud pc, int index, int k,
-                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
-                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
-                        ) except +:
-        # k nearest neighbors query for a single point.
-        cdef vector[int] k_indices
-        cdef vector[float] k_sqr_distances
-        k_indices.resize(k)
-        k_sqr_distances.resize(k)
-        self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
-                               k_sqr_distances)
-
-        for i in range(k):
-            sqdist[i] = k_sqr_distances[i]
-            ind[i] = k_indices[i]
-
-cdef cpp.PointXYZ to_point_t(point):
-    cdef cpp.PointXYZ p
-    p.x = point[0]
-    p.y = point[1]
-    p.z = point[2]
-    return p
-
-cdef class OctreePointCloud:
-    """
-    Octree pointcloud
-    """
-    cdef cpp.OctreePointCloud_t *me
-
-    def __cinit__(self, double resolution):
-        self.me = NULL
-        if resolution <= 0.:
-            raise ValueError("Expected resolution > 0., got %r" % resolution)
-
-    def __init__(self, double resolution):
-        """
-        Constructs octree pointcloud with given resolution at lowest octree level
-        """ 
-        self.me = new cpp.OctreePointCloud_t(resolution)
-
-    def __dealloc__(self):
-        del self.me
-        self.me = NULL      # just to be sure
-
-    def set_input_cloud(self, PointCloud pc):
-        """
-        Provide a pointer to the input data set.
-        """
-        self.me.setInputCloud(pc.thisptr_shared)
-
-    def define_bounding_box(self):
-        """
-        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
-        """
-        self.me.defineBoundingBox()
-        
-    def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
-        """
-        Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
-        """
-        self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
-
-    def add_points_from_input_cloud(self):
-        """
-        Add points from input point cloud to octree.
-        """
-        self.me.addPointsFromInputCloud()
-
-    def delete_tree(self):
-        """
-        Delete the octree structure and its leaf nodes.
-        """
-        self.me.deleteTree()
-
-    def is_voxel_occupied_at_point(self, point):
-        """
-        Check if voxel at given point coordinates exist.
-        """
-        return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
-
-    def get_occupied_voxel_centers(self):
-        """
-        Get list of centers of all occupied voxels.
-        """
-        cdef cpp.AlignedPointTVector_t points_v
-        cdef int num = self.me.getOccupiedVoxelCenters (points_v)
-        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
-
-    def delete_voxel_at_point(self, point):
-        """
-        Delete leaf node / voxel at given point.
-        """
-        self.me.deleteVoxelAtPoint(to_point_t(point))
-
-cdef class OctreePointCloudSearch(OctreePointCloud):
-    """
-    Octree pointcloud search
-    """
-    def __cinit__(self, double resolution):
-        """
-        Constructs octree pointcloud with given resolution at lowest octree level
-        """ 
-        self.me = <cpp.OctreePointCloud_t*> new cpp.OctreePointCloudSearch_t(resolution)
- 
-    def radius_search (self, point, double radius, unsigned int max_nn = 0):
-        """
-        Search for all neighbors of query point that are within a given radius.
-
-        Returns: (k_indices, k_sqr_distances)
-        """
-        cdef vector[int] k_indices
-        cdef vector[float] k_sqr_distances
-        if max_nn > 0:
-            k_indices.resize(max_nn)
-            k_sqr_distances.resize(max_nn)
-        cdef int k = (<cpp.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
-        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
-        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
-        for i in range(k):
-            np_k_sqr_distances[i] = k_sqr_distances[i]
-            np_k_indices[i] = k_indices[i]
-        return np_k_indices, np_k_sqr_distances
+        self.CAMERA_FRAME = pcl_r_img.COORDINATEFRAME_CAMERA
+        self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER
+
+CythonCoordinateFrame_Type = _CythonCoordinateFrame_Type()
+
+# # features
+# # CythonBorderPolicy
+# @cython.internal
+# cdef class _CythonBorderPolicy_Type:
+#     cdef:
+#         readonly int BORDER_POLICY_IGNORE
+#         readonly int BORDER_POLICY_MIRROR
+# 
+#     def __cinit__(self):
+#         self.BORDER_POLICY_IGNORE = pcl_ftr.BORDERPOLICY2_IGNORE
+#         self.BORDER_POLICY_MIRROR = pcl_ftr.BORDERPOLICY2_MIRROR
+# 
+# CythonBorderPolicy_Type = _CythonBorderPolicy_Type()
+###
+
+
+# CythonNormalEstimationMethod
+# @cython.internal
+# cdef class _CythonNormalEstimationMethod_Type:
+#     cdef:
+#         readonly int COVARIANCE_MATRIX
+#         readonly int AVERAGE_3D_GRADIENT
+#         readonly int AVERAGE_DEPTH_CHANGE
+#         readonly int SIMPLE_3D_GRADIENT
+# 
+#     def __cinit__(self):
+#         self.COVARIANCE_MATRIX = pcl_ftr.ESTIMATIONMETHOD2_COVARIANCE_MATRIX
+#         self.AVERAGE_3D_GRADIENT = pcl_ftr.ESTIMATIONMETHOD2_AVERAGE_3D_GRADIENT
+#         self.AVERAGE_DEPTH_CHANGE = pcl_ftr.ESTIMATIONMETHOD2_AVERAGE_DEPTH_CHANGE
+#         self.SIMPLE_3D_GRADIENT = pcl_ftr.ESTIMATIONMETHOD2_SIMPLE_3D_GRADIENT
+# 
+# CythonNormalEstimationMethod_Type = _CythonNormalEstimationMethod_Type()
+###
+
+include "pxi/pxiInclude.pxi"
+
+include "pxi/PointCloud_PointXYZ.pxi"
+include "pxi/PointCloud_PointXYZI.pxi"
+include "pxi/PointCloud_PointXYZRGB.pxi"
+include "pxi/PointCloud_PointXYZRGBA.pxi"
+include "pxi/PointCloud_PointWithViewpoint.pxi"
+# include "pxi/PointCloud_Normal.pxi"
+include "pxi/PointCloud_PointNormal.pxi"
+# Add PointCloud2
+include "pxi/PointCloud_PointCloud2.pxi"
+
+### common ###
+def deg2rad(float alpha):
+    return pcl_cmn.deg2rad(alpha)
+
+def rad2deg(float alpha):
+    return pcl_cmn.rad2deg(alpha)
+
+# cdef double deg2rad(double alpha):
+#     return pcl_cmn.rad2deg(alpha)
+# 
+# cdef double rad2deg(double alpha):
+#     return pcl_cmn.rad2deg(alpha)
+# 
+# cdef float normAngle (float alpha):
+#     return pcl_cmn.normAngle(alpha)
+
+# Build NG
+# def copyPointCloud(_pcl.PointCloud cloud_in, indices, _pcl.PointCloud cloud_out):
+#     pcl_cmn.copyPointCloud_Indices [cpp.PointXYZ](<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> cloud_in.thisptr_shared, <vector[int]> indices, <cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> cloud_out.thisptr_shared)
 
diff --git a/pcl/_pcl_172.pyx b/pcl/_pcl_172.pyx
new file mode 100644
index 0000000..a968024
--- /dev/null
+++ b/pcl/_pcl_172.pyx
@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+# cython: embedsignature=True
+
+from collections import Sequence
+import numbers
+import numpy as np
+cimport numpy as cnp
+
+cimport pcl_common as pcl_cmn
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus_172 as pcl_sc
+cimport pcl_features_172 as pcl_ftr
+cimport pcl_filters_172 as pcl_fil
+cimport pcl_range_image_172 as pcl_r_img
+cimport pcl_segmentation_172 as pclseg
+
+cimport cython
+# from cython.operator import dereference as deref
+from cython.operator cimport dereference as deref, preincrement as inc
+from cython cimport address
+
+from cpython cimport Py_buffer
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+from boost_shared_ptr cimport sp_assign
+
+cnp.import_array()
+
+### Enum ###
+
+## Enum Setting
+SAC_RANSAC = pcl_sc.SAC_RANSAC
+SAC_LMEDS = pcl_sc.SAC_LMEDS
+SAC_MSAC = pcl_sc.SAC_MSAC
+SAC_RRANSAC = pcl_sc.SAC_RRANSAC
+SAC_RMSAC = pcl_sc.SAC_RMSAC
+SAC_MLESAC = pcl_sc.SAC_MLESAC
+SAC_PROSAC = pcl_sc.SAC_PROSAC
+
+SACMODEL_PLANE = pcl_sc.SACMODEL_PLANE
+SACMODEL_LINE = pcl_sc.SACMODEL_LINE
+SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D
+SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D
+SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE
+SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER
+SACMODEL_CONE = pcl_sc.SACMODEL_CONE
+SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS
+SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE
+SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE
+SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES
+SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE 
+SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE
+SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION
+SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE
+SACMODEL_NORMAL_PARALLEL_PLANE = pcl_sc.SACMODEL_NORMAL_PARALLEL_PLANE
+SACMODEL_STICK = pcl_sc.SACMODEL_STICK
+
+### Enum Setting(define Class InternalType) ###
+
+# CythonCompareOp
+@cython.internal

+cdef class _CythonCompareOp_Type:

+    cdef:

+        readonly int GT
+        readonly int GE
+        readonly int LT
+        readonly int LE
+        readonly int EQ
+


+    def __cinit__(self):

+        self.GT = pcl_fil.COMPAREOP_GT
+        self.GE = pcl_fil.COMPAREOP_GE
+        self.LT = pcl_fil.COMPAREOP_LT
+        self.LE = pcl_fil.COMPAREOP_LE
+        self.EQ = pcl_fil.COMPAREOP_EQ
+

+CythonCompareOp_Type = _CythonCompareOp_Type()
+
+# RangeImage 
+# CythonCoordinateFrame
+@cython.internal

+cdef class _CythonCoordinateFrame_Type:

+    cdef:

+        readonly int CAMERA_FRAME
+        readonly int LASER_FRAME
+

+    def __cinit__(self):

+        self.CAMERA_FRAME = pcl_r_img.COORDINATEFRAME_CAMERA
+        self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER
+
+CythonCoordinateFrame_Type = _CythonCoordinateFrame_Type()
+
+# # features
+# # CythonBorderPolicy
+# @cython.internal

+# cdef class _CythonBorderPolicy_Type:

+#     cdef:

+#         readonly int BORDER_POLICY_IGNORE
+#         readonly int BORDER_POLICY_MIRROR
+# 
+#     def __cinit__(self):

+#         self.BORDER_POLICY_IGNORE = pcl_ftr.BORDERPOLICY2_IGNORE
+#         self.BORDER_POLICY_MIRROR = pcl_ftr.BORDERPOLICY2_MIRROR
+# 
+# CythonBorderPolicy_Type = _CythonBorderPolicy_Type()
+###
+
+
+# CythonNormalEstimationMethod
+# @cython.internal

+# cdef class _CythonNormalEstimationMethod_Type:
+#     cdef:

+#         readonly int COVARIANCE_MATRIX
+#         readonly int AVERAGE_3D_GRADIENT
+#         readonly int AVERAGE_DEPTH_CHANGE
+#         readonly int SIMPLE_3D_GRADIENT
+# 
+#     def __cinit__(self):

+#         self.COVARIANCE_MATRIX = pcl_ftr.ESTIMATIONMETHOD2_COVARIANCE_MATRIX
+#         self.AVERAGE_3D_GRADIENT = pcl_ftr.ESTIMATIONMETHOD2_AVERAGE_3D_GRADIENT
+#         self.AVERAGE_DEPTH_CHANGE = pcl_ftr.ESTIMATIONMETHOD2_AVERAGE_DEPTH_CHANGE
+#         self.SIMPLE_3D_GRADIENT = pcl_ftr.ESTIMATIONMETHOD2_SIMPLE_3D_GRADIENT
+# 
+# CythonNormalEstimationMethod_Type = _CythonNormalEstimationMethod_Type()
+###
+
+include "pxi/pxiInclude_172.pxi"
+
+include "pxi/PointCloud_PointXYZ_172.pxi"
+include "pxi/PointCloud_PointXYZI_172.pxi"
+include "pxi/PointCloud_PointXYZRGB_172.pxi"
+include "pxi/PointCloud_PointXYZRGBA_172.pxi"
+include "pxi/PointCloud_PointWithViewpoint.pxi"
+# include "pxi/PointCloud_Normal.pxi"
+include "pxi/PointCloud_PointNormal.pxi"
+# Add PointCloud2
+include "pxi/PointCloud_PCLPointCloud2.pxi"
+
+### common ###
+def deg2rad(float alpha):
+    return pcl_cmn.deg2rad(alpha)
+
+def rad2deg(float alpha):
+    return pcl_cmn.rad2deg(alpha)
+
+# cdef double deg2rad(double alpha):
+#     return pcl_cmn.rad2deg(alpha)
+# 
+# cdef double rad2deg(double alpha):
+#     return pcl_cmn.rad2deg(alpha)
+# 
+# cdef float normAngle (float alpha):
+#     return pcl_cmn.normAngle(alpha)
+
diff --git a/pcl/_pcl_180.cpp b/pcl/_pcl_180.cpp
new file mode 100644
index 0000000..a581570
--- /dev/null
+++ b/pcl/_pcl_180.cpp
@@ -0,0 +1,99200 @@
+/* Generated by Cython 0.25.2 */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifndef Py_PYTHON_H
+    #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
+    #error Cython requires Python 2.6+ or Python 3.2+.
+#else
+#define CYTHON_ABI "0_25_2"
+#include <stddef.h>
+#ifndef offsetof
+  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(WIN32) && !defined(MS_WINDOWS)
+  #ifndef __stdcall
+    #define __stdcall
+  #endif
+  #ifndef __cdecl
+    #define __cdecl
+  #endif
+  #ifndef __fastcall
+    #define __fastcall
+  #endif
+#endif
+#ifndef DL_IMPORT
+  #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+  #define DL_EXPORT(t) t
+#endif
+#ifndef HAVE_LONG_LONG
+  #if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000)
+    #define HAVE_LONG_LONG
+  #endif
+#endif
+#ifndef PY_LONG_LONG
+  #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+  #define Py_HUGE_VAL HUGE_VAL
+#endif
+#ifdef PYPY_VERSION
+  #define CYTHON_COMPILING_IN_PYPY 1
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #undef CYTHON_USE_TYPE_SLOTS
+  #define CYTHON_USE_TYPE_SLOTS 0
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_INTERNALS
+  #define CYTHON_USE_UNICODE_INTERNALS 0
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #undef CYTHON_AVOID_BORROWED_REFS
+  #define CYTHON_AVOID_BORROWED_REFS 1
+  #undef CYTHON_ASSUME_SAFE_MACROS
+  #define CYTHON_ASSUME_SAFE_MACROS 0
+  #undef CYTHON_UNPACK_METHODS
+  #define CYTHON_UNPACK_METHODS 0
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#elif defined(PYSTON_VERSION)
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 1
+  #define CYTHON_COMPILING_IN_CPYTHON 0
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #undef CYTHON_USE_ASYNC_SLOTS
+  #define CYTHON_USE_ASYNC_SLOTS 0
+  #undef CYTHON_USE_PYLIST_INTERNALS
+  #define CYTHON_USE_PYLIST_INTERNALS 0
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #undef CYTHON_USE_UNICODE_WRITER
+  #define CYTHON_USE_UNICODE_WRITER 0
+  #undef CYTHON_USE_PYLONG_INTERNALS
+  #define CYTHON_USE_PYLONG_INTERNALS 0
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #undef CYTHON_FAST_THREAD_STATE
+  #define CYTHON_FAST_THREAD_STATE 0
+  #undef CYTHON_FAST_PYCALL
+  #define CYTHON_FAST_PYCALL 0
+#else
+  #define CYTHON_COMPILING_IN_PYPY 0
+  #define CYTHON_COMPILING_IN_PYSTON 0
+  #define CYTHON_COMPILING_IN_CPYTHON 1
+  #ifndef CYTHON_USE_TYPE_SLOTS
+    #define CYTHON_USE_TYPE_SLOTS 1
+  #endif
+  #if PY_MAJOR_VERSION < 3
+    #undef CYTHON_USE_ASYNC_SLOTS
+    #define CYTHON_USE_ASYNC_SLOTS 0
+  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+    #define CYTHON_USE_ASYNC_SLOTS 1
+  #endif
+  #if PY_VERSION_HEX < 0x02070000
+    #undef CYTHON_USE_PYLONG_INTERNALS
+    #define CYTHON_USE_PYLONG_INTERNALS 0
+  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+    #define CYTHON_USE_PYLONG_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_PYLIST_INTERNALS
+    #define CYTHON_USE_PYLIST_INTERNALS 1
+  #endif
+  #ifndef CYTHON_USE_UNICODE_INTERNALS
+    #define CYTHON_USE_UNICODE_INTERNALS 1
+  #endif
+  #if PY_VERSION_HEX < 0x030300F0
+    #undef CYTHON_USE_UNICODE_WRITER
+    #define CYTHON_USE_UNICODE_WRITER 0
+  #elif !defined(CYTHON_USE_UNICODE_WRITER)
+    #define CYTHON_USE_UNICODE_WRITER 1
+  #endif
+  #ifndef CYTHON_AVOID_BORROWED_REFS
+    #define CYTHON_AVOID_BORROWED_REFS 0
+  #endif
+  #ifndef CYTHON_ASSUME_SAFE_MACROS
+    #define CYTHON_ASSUME_SAFE_MACROS 1
+  #endif
+  #ifndef CYTHON_UNPACK_METHODS
+    #define CYTHON_UNPACK_METHODS 1
+  #endif
+  #ifndef CYTHON_FAST_THREAD_STATE
+    #define CYTHON_FAST_THREAD_STATE 1
+  #endif
+  #ifndef CYTHON_FAST_PYCALL
+    #define CYTHON_FAST_PYCALL 1
+  #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+  #include "longintrepr.h"
+  #undef SHIFT
+  #undef BASE
+  #undef MASK
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+  #define Py_OptimizeFlag 0
+#endif
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyClass_Type
+#else
+  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+  #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+  #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+  #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+  #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_FASTCALL
+  #define METH_FASTCALL 0x80
+  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args,
+                                              Py_ssize_t nargs, PyObject *kwnames);
+#else
+  #define __Pyx_PyCFunctionFast _PyCFunctionFast
+#endif
+#if CYTHON_FAST_PYCCALL
+#define __Pyx_PyFastCFunction_Check(func)\
+    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+  #define CYTHON_PEP393_ENABLED 1
+  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
+                                              0 : _PyUnicode_Ready((PyObject *)(op)))
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
+  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
+  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
+  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+#else
+  #define CYTHON_PEP393_ENABLED 0
+  #define PyUnicode_1BYTE_KIND  1
+  #define PyUnicode_2BYTE_KIND  2
+  #define PyUnicode_4BYTE_KIND  4
+  #define __Pyx_PyUnicode_READY(op)       (0)
+  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
+  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
+  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
+  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
+  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
+#else
+  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
+  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
+  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
+  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+  #define PyObject_Malloc(s)   PyMem_Malloc(s)
+  #define PyObject_Free(p)     PyMem_Free(p)
+  #define PyObject_Realloc(p)  PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_PYSTON
+  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#else
+  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
+  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
+#endif
+#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
+#else
+  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+  #define PyObject_ASCII(o)            PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBaseString_Type            PyUnicode_Type
+  #define PyStringObject               PyUnicodeObject
+  #define PyString_Type                PyUnicode_Type
+  #define PyString_Check               PyUnicode_Check
+  #define PyString_CheckExact          PyUnicode_CheckExact
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
+#endif
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+#if PY_MAJOR_VERSION >= 3
+  #define PyIntObject                  PyLongObject
+  #define PyInt_Type                   PyLong_Type
+  #define PyInt_Check(op)              PyLong_Check(op)
+  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
+  #define PyInt_FromString             PyLong_FromString
+  #define PyInt_FromUnicode            PyLong_FromUnicode
+  #define PyInt_FromLong               PyLong_FromLong
+  #define PyInt_FromSize_t             PyLong_FromSize_t
+  #define PyInt_FromSsize_t            PyLong_FromSsize_t
+  #define PyInt_AsLong                 PyLong_AsLong
+  #define PyInt_AS_LONG                PyLong_AS_LONG
+  #define PyInt_AsSsize_t              PyLong_AsSsize_t
+  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
+  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+  #define PyNumber_Int                 PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define PyBoolObject                 PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+  #ifndef PyUnicode_InternFromString
+    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+  #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+  typedef long Py_hash_t;
+  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
+#else
+  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
+#endif
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
+#else
+  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
+#endif
+#if CYTHON_USE_ASYNC_SLOTS
+  #if PY_VERSION_HEX >= 0x030500B1
+    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+  #else
+    typedef struct {
+        unaryfunc am_await;
+        unaryfunc am_aiter;
+        unaryfunc am_anext;
+    } __Pyx_PyAsyncMethodsStruct;
+    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+  #endif
+#else
+  #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef CYTHON_RESTRICT
+  #if defined(__GNUC__)
+    #define CYTHON_RESTRICT __restrict__
+  #elif defined(_MSC_VER) && _MSC_VER >= 1400
+    #define CYTHON_RESTRICT __restrict
+  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define CYTHON_RESTRICT restrict
+  #else
+    #define CYTHON_RESTRICT
+  #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define CYTHON_UNUSED __attribute__ ((__unused__))
+#   else
+#     define CYTHON_UNUSED
+#   endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+#   define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+#   define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+#  if defined(__cplusplus)
+     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+#  else
+#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+#  endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+#  define CYTHON_NCP_UNUSED
+# else
+#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+
+#ifndef __cplusplus
+  #error "Cython files generated with the C++ option must be compiled with a C++ compiler."
+#endif
+#ifndef CYTHON_INLINE
+  #if defined(__clang__)
+    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+  #else
+    #define CYTHON_INLINE inline
+  #endif
+#endif
+template<typename T>
+void __Pyx_call_destructor(T& x) {
+    x.~T();
+}
+template<typename T>
+class __Pyx_FakeReference {
+  public:
+    __Pyx_FakeReference() : ptr(NULL) { }
+    __Pyx_FakeReference(const T& ref) : ptr(const_cast<T*>(&ref)) { }
+    T *operator->() { return ptr; }
+    T *operator&() { return ptr; }
+    operator T&() { return *ptr; }
+    template<typename U> bool operator ==(U other) { return *ptr == other; }
+    template<typename U> bool operator !=(U other) { return *ptr != other; }
+  private:
+    T *ptr;
+};
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+  #define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+  float value;
+  memset(&value, 0xFF, sizeof(value));
+  return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+{ \
+  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
+}
+
+#if PY_MAJOR_VERSION >= 3
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
+#else
+  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
+  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
+#endif
+
+#ifndef __PYX_EXTERN_C
+  #ifdef __cplusplus
+    #define __PYX_EXTERN_C extern "C"
+  #else
+    #define __PYX_EXTERN_C extern
+  #endif
+#endif
+
+#define __PYX_HAVE__pcl___pcl
+#define __PYX_HAVE_API__pcl___pcl
+#include <stddef.h>
+#include <vector>
+#include "ios"
+#include "new"
+#include "stdexcept"
+#include "typeinfo"
+#include <string.h>
+#include <string>
+#include "boost/shared_ptr.hpp"
+#include "boost_shared_ptr_assign.h"
+#include "Eigen/Dense"
+#include "Eigen/Eigen"
+#include "Eigen/Geometry"
+#include "pcl/point_cloud.h"
+#include "pcl/point_types.h"
+#include "pcl/ModelCoefficients.h"
+#include "pcl/PointIndices.h"
+#include "pcl/pcl_base.h"
+#include "pcl/PolygonMesh.h"
+#include "pcl/TextureMesh.h"
+#include "pcl/Vertices.h"
+#include "pcl/kdtree/kdtree.h"
+#include "pcl/kdtree/kdtree_flann.h"
+#include "pcl/range_image/range_image.h"
+#include "pcl/range_image/range_image_planar.h"
+#include "pcl/features/feature.h"
+#include "pcl/features/3dsc.h"
+#include "pcl/features/boundary.h"
+#include "pcl/features/esf.h"
+#include "pcl/features/fpfh.h"
+#include "pcl/features/fpfh_omp.h"
+#include "pcl/features/integral_image_normal.h"
+#include "pcl/features/intensity_gradient.h"
+#include "pcl/features/intensity_spin.h"
+#include "pcl/features/moment_invariants.h"
+#include "pcl/features/multiscale_feature_persistence.h"
+#include "pcl/features/normal_3d.h"
+#include "pcl/features/normal_3d_omp.h"
+#include "pcl/features/normal_based_signature.h"
+#include "pcl/features/pfh.h"
+#include "pcl/features/pfhrgb.h"
+#include "pcl/features/ppf.h"
+#include "pcl/features/ppfrgb.h"
+#include "pcl/features/principal_curvatures.h"
+#include "pcl/features/range_image_border_extractor.h"
+#include "pcl/features/rift.h"
+#include "pcl/features/shot.h"
+#include "pcl/features/shot_lrf.h"
+#include "pcl/features/shot_lrf_omp.h"
+#include "pcl/features/shot_omp.h"
+#include "pcl/features/spin_image.h"
+#include "pcl/features/statistical_multiscale_interest_region_extraction.h"
+#include "pcl/features/vfh.h"
+#include "pcl/sample_consensus/sac_model.h"
+#include "pcl/sample_consensus/sac.h"
+#include "pcl/sample_consensus/rransac.h"
+#include "pcl/sample_consensus/sac_model_plane.h"
+#include "pcl/sample_consensus/sac_model_sphere.h"
+#include "pcl/sample_consensus/lmeds.h"
+#include "pcl/sample_consensus/mlesac.h"
+#include "pcl/sample_consensus/msac.h"
+#include "pcl/sample_consensus/prosac.h"
+#include "pcl/sample_consensus/ransac.h"
+#include "pcl/sample_consensus/rmsac.h"
+#include "pcl/sample_consensus/sac_model_circle.h"
+#include "pcl/sample_consensus/sac_model_cone.h"
+#include "pcl/sample_consensus/sac_model_cylinder.h"
+#include "pcl/sample_consensus/sac_model_line.h"
+#include "pcl/sample_consensus/sac_model_normal_parallel_plane.h"
+#include "pcl/sample_consensus/sac_model_normal_plane.h"
+#include "pcl/sample_consensus/sac_model_normal_sphere.h"
+#include "pcl/sample_consensus/sac_model_parallel_line.h"
+#include "pcl/sample_consensus/sac_model_parallel_plane.h"
+#include "pcl/sample_consensus/sac_model_perpendicular_plane.h"
+#include "pcl/sample_consensus/sac_model_registration.h"
+#include "pcl/sample_consensus/sac_model_stick.h"
+#include "pcl/sample_consensus/method_types.h"
+#include "pcl/sample_consensus/model_types.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "numpy/arrayobject.h"
+#include "numpy/ufuncobject.h"
+#include "pcl/common/angles.h"
+#include "pcl/common/io.h"
+#include <utility>
+#include "pcl/filters/conditional_removal.h"
+#include "pcl/filters/filter.h"
+#include "pcl/filters/filter_indices.h"
+#include "pcl/filters/approximate_voxel_grid.h"
+#include "pcl/filters/bilateral.h"
+#include "pcl/filters/crop_box.h"
+#include "pcl/filters/crop_hull.h"
+#include "pcl/filters/extract_indices.h"
+#include "pcl/filters/normal_space.h"
+#include "pcl/filters/passthrough.h"
+#include "pcl/filters/plane_clipper3D.h"
+#include "pcl/filters/project_inliers.h"
+#include "pcl/filters/radius_outlier_removal.h"
+#include "pcl/filters/random_sample.h"
+#include "pcl/filters/statistical_outlier_removal.h"
+#include "pcl/filters/voxel_grid.h"
+#include "pcl/surface/reconstruction.h"
+#include "pcl/surface/processing.h"
+#include "pcl/surface/bilateral_upsampling.h"
+#include "pcl/surface/concave_hull.h"
+#include "pcl/surface/convex_hull.h"
+#include "pcl/surface/gp3.h"
+#include "pcl/surface/grid_projection.h"
+#include "pcl/surface/mls.h"
+#include "pcl/segmentation/sac_segmentation.h"
+#include "pcl/segmentation/comparator.h"
+#include "pcl/segmentation/plane_coefficient_comparator.h"
+#include "pcl/segmentation/edge_aware_plane_comparator.h"
+#include "pcl/segmentation/euclidean_cluster_comparator.h"
+#include "pcl/segmentation/euclidean_plane_coefficient_comparator.h"
+#include "pcl/segmentation/extract_clusters.h"
+#include "pcl/segmentation/extract_labeled_clusters.h"
+#include "pcl/segmentation/extract_polygonal_prism_data.h"
+#include "pcl/segmentation/min_cut_segmentation.h"
+#include "pcl/segmentation/organized_connected_component_segmentation.h"
+#include "pcl/segmentation/progressive_morphological_filter.h"
+#include "pcl/octree/octree_container.h"
+#include "pcl/octree/octree_pointcloud_density.h"
+#include "pcl/octree/octree_base.h"
+#include "pcl/octree/octree2buf_base.h"
+#include "pcl/octree/octree_iterator.h"
+#include "pcl/octree/octree_key.h"
+#include "pcl/octree/octree_pointcloud.h"
+#include "pcl/octree/octree_pointcloud_changedetector.h"
+#include "pcl/octree/octree_search.h"
+#include "pcl/registration/registration.h"
+#include "pcl/registration/warp_point_rigid.h"
+#include "pcl/registration/correspondence_rejection.h"
+#include "pcl/registration/correspondence_estimation.h"
+#include "pcl/registration/icp.h"
+#include "pcl/registration/gicp.h"
+#include "pcl/registration/icp_nl.h"
+#include "pcl/registration/correspondence_estimation_normal_shooting.h"
+#include "pcl/registration/correspondence_estimation_organized_projection.h"
+#include "pcl/registration/correspondence_rejection_distance.h"
+#include "pcl/registration/correspondence_rejection_features.h"
+#include "pcl/registration/correspondence_rejection_median_distance.h"
+#include "pcl/registration/correspondence_rejection_one_to_one.h"
+#include "pcl/registration/correspondence_rejection_organized_boundary.h"
+#include "pcl/registration/correspondence_rejection_poly.h"
+#include "pcl/registration/correspondence_rejection_sample_consensus.h"
+#include "pcl/registration/correspondence_rejection_sample_consensus_2d.h"
+#include "pcl/registration/correspondence_rejection_surface_normal.h"
+#include "pcl/registration/correspondence_rejection_trimmed.h"
+#include "pcl/registration/correspondence_rejection_var_trimmed.h"
+#include "pcl/registration/elch.h"
+#include "pcl/registration/ia_ransac.h"
+#include "pcl/registration/lum.h"
+#include "pcl/registration/ndt.h"
+#include "pcl/registration/ndt_2d.h"
+#include "pcl/registration/ppf_registration.h"
+#include "pcl/registration/pyramid_feature_matching.h"
+#include "pcl/registration/sample_consensus_prerejective.h"
+#include "pcl/registration/transformation_estimation.h"
+#include "pcl/registration/transformation_estimation_2D.h"
+#include "pcl/registration/transformation_estimation_dual_quaternion.h"
+#include "pcl/registration/transformation_estimation_lm.h"
+#include "pcl/registration/transformation_estimation_point_to_plane.h"
+#include "pcl/registration/transformation_estimation_point_to_plane_lls.h"
+#include "pcl/registration/transformation_estimation_point_to_plane_lls_weighted.h"
+#include "pcl/registration/transformation_estimation_point_to_plane_weighted.h"
+#include "pcl/registration/transformation_estimation_svd.h"
+#include "pcl/registration/transformation_estimation_svd_scale.h"
+#include "pcl/registration/transformation_validation.h"
+#include "pcl/registration/transformation_validation_euclidean.h"
+#include "pcl/registration/warp_point_rigid_3d.h"
+#include "pcl/registration/warp_point_rigid_6d.h"
+#include "pcl/registration/bfgs.h"
+#include "pcl/features/board.h"
+#include "pcl/features/cppf.h"
+#include "pcl/features/crh.h"
+#include "pcl/features/don.h"
+#include "pcl/features/gfpfh.h"
+#include "pcl/features/linear_least_squares_normal.h"
+#include "pcl/features/moment_of_inertia_estimation.h"
+#include "pcl/features/our_cvfh.h"
+#include "pcl/features/rops_estimation.h"
+#include "minipcl.h"
+#include "pcl/keypoints/keypoint.h"
+#include "pcl/keypoints/harris_3d.h"
+#include "pcl/keypoints/narf_keypoint.h"
+#include "pcl/keypoints/sift_keypoint.h"
+#include "pcl/keypoints/smoothed_surfaces_keypoint.h"
+#include "pcl/keypoints/uniform_sampling.h"
+#include "pcl/io/pcd_io.h"
+#include "pcl/io/ply_io.h"
+#include "indexing.hpp"
+#include "ProjectInliers.h"
+#include "pythread.h"
+#ifdef _OPENMP
+#include <omp.h>
+#endif /* _OPENMP */
+
+#ifdef PYREX_WITHOUT_ASSERTIONS
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (\
+    (sizeof(type) < sizeof(Py_ssize_t))  ||\
+    (sizeof(type) > sizeof(Py_ssize_t) &&\
+          likely(v < (type)PY_SSIZE_T_MAX ||\
+                 v == (type)PY_SSIZE_T_MAX)  &&\
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+                                v == (type)PY_SSIZE_T_MIN)))  ||\
+    (sizeof(type) == sizeof(Py_ssize_t) &&\
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+                               v == (type)PY_SSIZE_T_MAX)))  )
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER) && defined (_M_X64)
+    #define __Pyx_sst_abs(value) _abs64(value)
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyObject_AsSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s)    ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+#if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
+{
+    const Py_UNICODE *u_end = u;
+    while (*u_end++) ;
+    return (size_t)(u_end - u - 1);
+}
+#else
+#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
+#endif
+#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
+    PyObject* ascii_chars_b = NULL;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+  #define likely(x)   __builtin_expect(!!(x), 1)
+  #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+  #define likely(x)   (x)
+  #define unlikely(x) (x)
+#endif /* __GNUC__ */
+
+static PyObject *__pyx_m;
+static PyObject *__pyx_d;
+static PyObject *__pyx_b;
+static PyObject *__pyx_empty_tuple;
+static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+/* Header.proto */
+#if !defined(CYTHON_CCOMPLEX)
+  #if defined(__cplusplus)
+    #define CYTHON_CCOMPLEX 1
+  #elif defined(_Complex_I)
+    #define CYTHON_CCOMPLEX 1
+  #else
+    #define CYTHON_CCOMPLEX 0
+  #endif
+#endif
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #include <complex>
+  #else
+    #include <complex.h>
+  #endif
+#endif
+#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
+  #undef _Complex_I
+  #define _Complex_I 1.0fj
+#endif
+
+
+static const char *__pyx_f[] = {
+  "pcl/pxi/Segmentation/Segmentation.pxi",
+  "pcl/pxi/Filters/PassThroughFilter_180.pxi",
+  "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi",
+  "pcl/pxi/PointCloud_PointXYZ_180.pxi",
+  "pcl/_pcl_180.pyx",
+  "pcl/pxi/PointXYZtoPointXYZ.pxi",
+  "pcl/pxi/Segmentation/SegmentationNormal.pxi",
+  "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi",
+  "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi",
+  "pcl/pxi/Filters/VoxelGridFilter_180.pxi",
+  "pcl/pxi/Filters/ApproximateVoxelGrid.pxi",
+  "pcl/pxi/Surface/MovingLeastSquares.pxi",
+  "pcl/pxi/KdTree/KdTree_FLANN.pxi",
+  "pcl/pxi/Octree/OctreePointCloud_180.pxi",
+  "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi",
+  "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi",
+  "pcl/pxi/Vertices.pxi",
+  "pcl/pxi/Filters/CropHull_180.pxi",
+  "pcl/pxi/Filters/CropBox_180.pxi",
+  "pcl/pxi/Filters/ProjectInliers.pxi",
+  "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi",
+  "pcl/pxi/Filters/ConditionAnd.pxi",
+  "pcl/pxi/Filters/ConditionalRemoval.pxi",
+  "pcl/pxi/Surface/ConcaveHull.pxi",
+  "pcl/pxi/Common/RangeImage/RangeImages_180.pxi",
+  "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi",
+  "pcl/pxi/registration/IterativeClosestPoint_180.pxi",
+  "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi",
+  "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi",
+  "pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi",
+  "pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi",
+  "pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi",
+  "pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi",
+  "pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi",
+  "pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi",
+  "pcl/pxi/Features/NormalEstimation_180.pxi",
+  "pcl/pxi/Features/VFHEstimation_180.pxi",
+  "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi",
+  "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi",
+  "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi",
+  "pcl/pxi/registration/NormalDistributionsTransform_180.pxi",
+  "pcl/pxi/PointCloud_PointXYZI_180.pxi",
+  "pcl/pxi/PointCloud_PointXYZRGB_180.pxi",
+  "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi",
+  "pcl/pxi/PointCloud_PointWithViewpoint.pxi",
+  "pcl/pxi/PointCloud_PointNormal.pxi",
+  "__init__.pxd",
+  "stringsource",
+  "pcl/_pcl.pxd",
+  "type.pxd",
+  "bool.pxd",
+  "complex.pxd",
+};
+/* BufferFormatStructs.proto */
+#define IS_UNSIGNED(type) (((type) -1) > 0)
+struct __Pyx_StructField_;
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+typedef struct {
+  const char* name;
+  struct __Pyx_StructField_* fields;
+  size_t size;
+  size_t arraysize[8];
+  int ndim;
+  char typegroup;
+  char is_unsigned;
+  int flags;
+} __Pyx_TypeInfo;
+typedef struct __Pyx_StructField_ {
+  __Pyx_TypeInfo* type;
+  const char* name;
+  size_t offset;
+} __Pyx_StructField;
+typedef struct {
+  __Pyx_StructField* field;
+  size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+typedef struct {
+  __Pyx_StructField root;
+  __Pyx_BufFmt_StackElem* head;
+  size_t fmt_offset;
+  size_t new_count, enc_count;
+  size_t struct_alignment;
+  int is_complex;
+  char enc_type;
+  char new_packmode;
+  char enc_packmode;
+  char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":725
+ * # in Cython to enable them only on the right systems.
+ * 
+ * ctypedef npy_int8       int8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ */
+typedef npy_int8 __pyx_t_5numpy_int8_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":726
+ * 
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t
+ */
+typedef npy_int16 __pyx_t_5numpy_int16_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":727
+ * ctypedef npy_int8       int8_t
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_int64      int64_t
+ * #ctypedef npy_int96      int96_t
+ */
+typedef npy_int32 __pyx_t_5numpy_int32_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":728
+ * ctypedef npy_int16      int16_t
+ * ctypedef npy_int32      int32_t
+ * ctypedef npy_int64      int64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_int96      int96_t
+ * #ctypedef npy_int128     int128_t
+ */
+typedef npy_int64 __pyx_t_5numpy_int64_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":732
+ * #ctypedef npy_int128     int128_t
+ * 
+ * ctypedef npy_uint8      uint8_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ */
+typedef npy_uint8 __pyx_t_5numpy_uint8_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":733
+ * 
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t
+ */
+typedef npy_uint16 __pyx_t_5numpy_uint16_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":734
+ * ctypedef npy_uint8      uint8_t
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uint64     uint64_t
+ * #ctypedef npy_uint96     uint96_t
+ */
+typedef npy_uint32 __pyx_t_5numpy_uint32_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":735
+ * ctypedef npy_uint16     uint16_t
+ * ctypedef npy_uint32     uint32_t
+ * ctypedef npy_uint64     uint64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_uint96     uint96_t
+ * #ctypedef npy_uint128    uint128_t
+ */
+typedef npy_uint64 __pyx_t_5numpy_uint64_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":739
+ * #ctypedef npy_uint128    uint128_t
+ * 
+ * ctypedef npy_float32    float32_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_float64    float64_t
+ * #ctypedef npy_float80    float80_t
+ */
+typedef npy_float32 __pyx_t_5numpy_float32_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":740
+ * 
+ * ctypedef npy_float32    float32_t
+ * ctypedef npy_float64    float64_t             # <<<<<<<<<<<<<<
+ * #ctypedef npy_float80    float80_t
+ * #ctypedef npy_float128   float128_t
+ */
+typedef npy_float64 __pyx_t_5numpy_float64_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":749
+ * # The int types are mapped a bit surprising --
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t
+ */
+typedef npy_long __pyx_t_5numpy_int_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":750
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong   longlong_t
+ * 
+ */
+typedef npy_longlong __pyx_t_5numpy_long_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":751
+ * ctypedef npy_long       int_t
+ * ctypedef npy_longlong   long_t
+ * ctypedef npy_longlong   longlong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_ulong      uint_t
+ */
+typedef npy_longlong __pyx_t_5numpy_longlong_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":753
+ * ctypedef npy_longlong   longlong_t
+ * 
+ * ctypedef npy_ulong      uint_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t
+ */
+typedef npy_ulong __pyx_t_5numpy_uint_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":754
+ * 
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":755
+ * ctypedef npy_ulong      uint_t
+ * ctypedef npy_ulonglong  ulong_t
+ * ctypedef npy_ulonglong  ulonglong_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_intp       intp_t
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":757
+ * ctypedef npy_ulonglong  ulonglong_t
+ * 
+ * ctypedef npy_intp       intp_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_uintp      uintp_t
+ * 
+ */
+typedef npy_intp __pyx_t_5numpy_intp_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":758
+ * 
+ * ctypedef npy_intp       intp_t
+ * ctypedef npy_uintp      uintp_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_double     float_t
+ */
+typedef npy_uintp __pyx_t_5numpy_uintp_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":760
+ * ctypedef npy_uintp      uintp_t
+ * 
+ * ctypedef npy_double     float_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t
+ */
+typedef npy_double __pyx_t_5numpy_float_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":761
+ * 
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ */
+typedef npy_double __pyx_t_5numpy_double_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":762
+ * ctypedef npy_double     float_t
+ * ctypedef npy_double     double_t
+ * ctypedef npy_longdouble longdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ */
+typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< float > __pyx_t_float_complex;
+  #else
+    typedef float _Complex __pyx_t_float_complex;
+  #endif
+#else
+    typedef struct { float real, imag; } __pyx_t_float_complex;
+#endif
+static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
+
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    typedef ::std::complex< double > __pyx_t_double_complex;
+  #else
+    typedef double _Complex __pyx_t_double_complex;
+  #endif
+#else
+    typedef struct { double real, imag; } __pyx_t_double_complex;
+#endif
+static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
+
+
+/*--- Type declarations ---*/
+struct __pyx_obj_3pcl_4_pcl_PointCloud;
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_Vertices;
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint;
+struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal;
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal;
+struct __pyx_obj_3pcl_4_pcl_KdTree;
+struct __pyx_obj_3pcl_4_pcl_RangeImages;
+struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation;
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel;
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane;
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere;
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder;
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine;
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration;
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick;
+struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type;
+struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type;
+struct __pyx_obj_3pcl_4_pcl_Segmentation;
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_SegmentationNormal;
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal;
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal;
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal;
+struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction;
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter;
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter;
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter;
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid;
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares;
+struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN;
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_CropHull;
+struct __pyx_obj_3pcl_4_pcl_CropBox;
+struct __pyx_obj_3pcl_4_pcl_ProjectInliers;
+struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval;
+struct __pyx_obj_3pcl_4_pcl_ConditionAnd;
+struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval;
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull;
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI;
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB;
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA;
+struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint;
+struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint;
+struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear;
+struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus;
+struct __pyx_obj_3pcl_4_pcl_NormalEstimation;
+struct __pyx_obj_3pcl_4_pcl_VFHEstimation;
+struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation;
+struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D;
+struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform;
+
+/* "eigen.pxd":84
+ * # VectorXf
+ * 
+ * ctypedef aligned_allocator[cpp.PointXYZ] aligned_allocator_t             # <<<<<<<<<<<<<<
+ * ctypedef aligned_allocator[cpp.PointXYZI] aligned_allocator_PointXYZI_t
+ * ctypedef aligned_allocator[cpp.PointXYZRGB] aligned_allocator_PointXYZRGB_t
+ */
+typedef Eigen::aligned_allocator<struct pcl::PointXYZ>  __pyx_t_3pcl_5eigen_aligned_allocator_t;
+
+/* "eigen.pxd":85
+ * 
+ * ctypedef aligned_allocator[cpp.PointXYZ] aligned_allocator_t
+ * ctypedef aligned_allocator[cpp.PointXYZI] aligned_allocator_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef aligned_allocator[cpp.PointXYZRGB] aligned_allocator_PointXYZRGB_t
+ * ctypedef aligned_allocator[cpp.PointXYZRGBA] aligned_allocator_PointXYZRGBA_t
+ */
+typedef Eigen::aligned_allocator<struct pcl::PointXYZI>  __pyx_t_3pcl_5eigen_aligned_allocator_PointXYZI_t;
+
+/* "eigen.pxd":86
+ * ctypedef aligned_allocator[cpp.PointXYZ] aligned_allocator_t
+ * ctypedef aligned_allocator[cpp.PointXYZI] aligned_allocator_PointXYZI_t
+ * ctypedef aligned_allocator[cpp.PointXYZRGB] aligned_allocator_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef aligned_allocator[cpp.PointXYZRGBA] aligned_allocator_PointXYZRGBA_t
+ * ctypedef vector2[cpp.PointXYZ, aligned_allocator_t] AlignedPointTVector_t
+ */
+typedef Eigen::aligned_allocator<struct pcl::PointXYZRGB>  __pyx_t_3pcl_5eigen_aligned_allocator_PointXYZRGB_t;
+
+/* "eigen.pxd":87
+ * ctypedef aligned_allocator[cpp.PointXYZI] aligned_allocator_PointXYZI_t
+ * ctypedef aligned_allocator[cpp.PointXYZRGB] aligned_allocator_PointXYZRGB_t
+ * ctypedef aligned_allocator[cpp.PointXYZRGBA] aligned_allocator_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef vector2[cpp.PointXYZ, aligned_allocator_t] AlignedPointTVector_t
+ * ctypedef vector2[cpp.PointXYZI, aligned_allocator_PointXYZI_t] AlignedPointTVector_PointXYZI_t
+ */
+typedef Eigen::aligned_allocator<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_5eigen_aligned_allocator_PointXYZRGBA_t;
+
+/* "eigen.pxd":88
+ * ctypedef aligned_allocator[cpp.PointXYZRGB] aligned_allocator_PointXYZRGB_t
+ * ctypedef aligned_allocator[cpp.PointXYZRGBA] aligned_allocator_PointXYZRGBA_t
+ * ctypedef vector2[cpp.PointXYZ, aligned_allocator_t] AlignedPointTVector_t             # <<<<<<<<<<<<<<
+ * ctypedef vector2[cpp.PointXYZI, aligned_allocator_PointXYZI_t] AlignedPointTVector_PointXYZI_t
+ * ctypedef vector2[cpp.PointXYZRGB, aligned_allocator_PointXYZRGB_t] AlignedPointTVector_PointXYZRGB_t
+ */
+typedef std::vector<struct pcl::PointXYZ,__pyx_t_3pcl_5eigen_aligned_allocator_t>  __pyx_t_3pcl_5eigen_AlignedPointTVector_t;
+
+/* "eigen.pxd":89
+ * ctypedef aligned_allocator[cpp.PointXYZRGBA] aligned_allocator_PointXYZRGBA_t
+ * ctypedef vector2[cpp.PointXYZ, aligned_allocator_t] AlignedPointTVector_t
+ * ctypedef vector2[cpp.PointXYZI, aligned_allocator_PointXYZI_t] AlignedPointTVector_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef vector2[cpp.PointXYZRGB, aligned_allocator_PointXYZRGB_t] AlignedPointTVector_PointXYZRGB_t
+ * ctypedef vector2[cpp.PointXYZRGBA, aligned_allocator_PointXYZRGBA_t] AlignedPointTVector_PointXYZRGBA_t
+ */
+typedef std::vector<struct pcl::PointXYZI,__pyx_t_3pcl_5eigen_aligned_allocator_PointXYZI_t>  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZI_t;
+
+/* "eigen.pxd":90
+ * ctypedef vector2[cpp.PointXYZ, aligned_allocator_t] AlignedPointTVector_t
+ * ctypedef vector2[cpp.PointXYZI, aligned_allocator_PointXYZI_t] AlignedPointTVector_PointXYZI_t
+ * ctypedef vector2[cpp.PointXYZRGB, aligned_allocator_PointXYZRGB_t] AlignedPointTVector_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef vector2[cpp.PointXYZRGBA, aligned_allocator_PointXYZRGBA_t] AlignedPointTVector_PointXYZRGBA_t
+ * 
+ */
+typedef std::vector<struct pcl::PointXYZRGB,__pyx_t_3pcl_5eigen_aligned_allocator_PointXYZRGB_t>  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZRGB_t;
+
+/* "eigen.pxd":91
+ * ctypedef vector2[cpp.PointXYZI, aligned_allocator_PointXYZI_t] AlignedPointTVector_PointXYZI_t
+ * ctypedef vector2[cpp.PointXYZRGB, aligned_allocator_PointXYZRGB_t] AlignedPointTVector_PointXYZRGB_t
+ * ctypedef vector2[cpp.PointXYZRGBA, aligned_allocator_PointXYZRGBA_t] AlignedPointTVector_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * # Eigen2Support?
+ */
+typedef std::vector<struct pcl::PointXYZRGBA,__pyx_t_3pcl_5eigen_aligned_allocator_PointXYZRGBA_t>  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZRGBA_t;
+
+/* "pcl_defs.pxd":463
+ *         vector[float] values
+ * 
+ * ctypedef ModelCoefficients ModelCoefficients_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ModelCoefficients] ModelCoefficientsPtr_t
+ * 
+ */
+typedef struct pcl::ModelCoefficients __pyx_t_3pcl_8pcl_defs_ModelCoefficients_t;
+
+/* "pcl_defs.pxd":464
+ * 
+ * ctypedef ModelCoefficients ModelCoefficients_t
+ * ctypedef shared_ptr[ModelCoefficients] ModelCoefficientsPtr_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef boost::shared_ptr<struct pcl::ModelCoefficients>  __pyx_t_3pcl_8pcl_defs_ModelCoefficientsPtr_t;
+
+/* "pcl_defs.pxd":480
+ *         vector[int] indices
+ * 
+ * ctypedef PointIndices PointIndices_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointIndices] PointIndicesPtr_t
+ * ###
+ */
+typedef pcl::PointIndices __pyx_t_3pcl_8pcl_defs_PointIndices_t;
+
+/* "pcl_defs.pxd":481
+ * 
+ * ctypedef PointIndices PointIndices_t
+ * ctypedef shared_ptr[PointIndices] PointIndicesPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::PointIndices>  __pyx_t_3pcl_8pcl_defs_PointIndicesPtr_t;
+
+/* "pcl_defs.pxd":484
+ * ###
+ * 
+ * ctypedef PointCloud[PointXYZ] PointCloud_t             # <<<<<<<<<<<<<<
+ * ctypedef PointCloud[PointXYZI] PointCloud_PointXYZI_t
+ * ctypedef PointCloud[PointXYZRGB] PointCloud_PointXYZRGB_t
+ */
+typedef pcl::PointCloud<struct pcl::PointXYZ>  __pyx_t_3pcl_8pcl_defs_PointCloud_t;
+
+/* "pcl_defs.pxd":485
+ * 
+ * ctypedef PointCloud[PointXYZ] PointCloud_t
+ * ctypedef PointCloud[PointXYZI] PointCloud_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef PointCloud[PointXYZRGB] PointCloud_PointXYZRGB_t
+ * ctypedef PointCloud[PointXYZRGBA] PointCloud_PointXYZRGBA_t
+ */
+typedef pcl::PointCloud<struct pcl::PointXYZI>  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZI_t;
+
+/* "pcl_defs.pxd":486
+ * ctypedef PointCloud[PointXYZ] PointCloud_t
+ * ctypedef PointCloud[PointXYZI] PointCloud_PointXYZI_t
+ * ctypedef PointCloud[PointXYZRGB] PointCloud_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef PointCloud[PointXYZRGBA] PointCloud_PointXYZRGBA_t
+ * ctypedef PointCloud[VFHSignature308] PointCloud_VFHSignature308_t
+ */
+typedef pcl::PointCloud<struct pcl::PointXYZRGB>  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGB_t;
+
+/* "pcl_defs.pxd":487
+ * ctypedef PointCloud[PointXYZI] PointCloud_PointXYZI_t
+ * ctypedef PointCloud[PointXYZRGB] PointCloud_PointXYZRGB_t
+ * ctypedef PointCloud[PointXYZRGBA] PointCloud_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef PointCloud[VFHSignature308] PointCloud_VFHSignature308_t
+ * ctypedef PointCloud[PointWithViewpoint] PointCloud_PointWithViewpoint_t
+ */
+typedef pcl::PointCloud<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGBA_t;
+
+/* "pcl_defs.pxd":488
+ * ctypedef PointCloud[PointXYZRGB] PointCloud_PointXYZRGB_t
+ * ctypedef PointCloud[PointXYZRGBA] PointCloud_PointXYZRGBA_t
+ * ctypedef PointCloud[VFHSignature308] PointCloud_VFHSignature308_t             # <<<<<<<<<<<<<<
+ * ctypedef PointCloud[PointWithViewpoint] PointCloud_PointWithViewpoint_t
+ * 
+ */
+typedef pcl::PointCloud<struct pcl::VFHSignature308>  __pyx_t_3pcl_8pcl_defs_PointCloud_VFHSignature308_t;
+
+/* "pcl_defs.pxd":489
+ * ctypedef PointCloud[PointXYZRGBA] PointCloud_PointXYZRGBA_t
+ * ctypedef PointCloud[VFHSignature308] PointCloud_VFHSignature308_t
+ * ctypedef PointCloud[PointWithViewpoint] PointCloud_PointWithViewpoint_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[PointCloud[PointXYZ]] PointCloudPtr_t
+ */
+typedef pcl::PointCloud<struct pcl::PointWithViewpoint>  __pyx_t_3pcl_8pcl_defs_PointCloud_PointWithViewpoint_t;
+
+/* "pcl_defs.pxd":491
+ * ctypedef PointCloud[PointWithViewpoint] PointCloud_PointWithViewpoint_t
+ * 
+ * ctypedef shared_ptr[PointCloud[PointXYZ]] PointCloudPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointCloud[PointXYZI]] PointCloud_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZRGB]] PointCloud_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> >  __pyx_t_3pcl_8pcl_defs_PointCloudPtr_t;
+
+/* "pcl_defs.pxd":492
+ * 
+ * ctypedef shared_ptr[PointCloud[PointXYZ]] PointCloudPtr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZI]] PointCloud_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointCloud[PointXYZRGB]] PointCloud_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZRGBA]] PointCloud_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZI> >  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZI_Ptr_t;
+
+/* "pcl_defs.pxd":493
+ * ctypedef shared_ptr[PointCloud[PointXYZ]] PointCloudPtr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZI]] PointCloud_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZRGB]] PointCloud_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointCloud[PointXYZRGBA]] PointCloud_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[PointCloud[VFHSignature308]] PointCloud_VFHSignature308_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGB_Ptr_t;
+
+/* "pcl_defs.pxd":494
+ * ctypedef shared_ptr[PointCloud[PointXYZI]] PointCloud_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZRGB]] PointCloud_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZRGBA]] PointCloud_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointCloud[VFHSignature308]] PointCloud_VFHSignature308_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointWithViewpoint]] PointCloud_PointWithViewpoint_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGBA_Ptr_t;
+
+/* "pcl_defs.pxd":495
+ * ctypedef shared_ptr[PointCloud[PointXYZRGB]] PointCloud_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointXYZRGBA]] PointCloud_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[PointCloud[VFHSignature308]] PointCloud_VFHSignature308_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointCloud[PointWithViewpoint]] PointCloud_PointWithViewpoint_Ptr_t
+ * 
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::VFHSignature308> >  __pyx_t_3pcl_8pcl_defs_PointCloud_VFHSignature308_Ptr_t;
+
+/* "pcl_defs.pxd":496
+ * ctypedef shared_ptr[PointCloud[PointXYZRGBA]] PointCloud_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[PointCloud[VFHSignature308]] PointCloud_VFHSignature308_Ptr_t
+ * ctypedef shared_ptr[PointCloud[PointWithViewpoint]] PointCloud_PointWithViewpoint_Ptr_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef PointCloud[Normal] PointCloud_Normal_t
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::PointWithViewpoint> >  __pyx_t_3pcl_8pcl_defs_PointCloud_PointWithViewpoint_Ptr_t;
+
+/* "pcl_defs.pxd":498
+ * ctypedef shared_ptr[PointCloud[PointWithViewpoint]] PointCloud_PointWithViewpoint_Ptr_t
+ * 
+ * ctypedef PointCloud[Normal] PointCloud_Normal_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointCloud[Normal]] PointCloud_Normal_Ptr_t
+ * 
+ */
+typedef pcl::PointCloud<struct pcl::Normal>  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t;
+
+/* "pcl_defs.pxd":499
+ * 
+ * ctypedef PointCloud[Normal] PointCloud_Normal_t
+ * ctypedef shared_ptr[PointCloud[Normal]] PointCloud_Normal_Ptr_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef PointCloud[PointNormal] PointCloud_PointNormal_t
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::Normal> >  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_Ptr_t;
+
+/* "pcl_defs.pxd":501
+ * ctypedef shared_ptr[PointCloud[Normal]] PointCloud_Normal_Ptr_t
+ * 
+ * ctypedef PointCloud[PointNormal] PointCloud_PointNormal_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PointCloud[PointNormal]] PointCloud_PointNormal_Ptr_t
+ * 
+ */
+typedef pcl::PointCloud<struct pcl::PointNormal>  __pyx_t_3pcl_8pcl_defs_PointCloud_PointNormal_t;
+
+/* "pcl_defs.pxd":502
+ * 
+ * ctypedef PointCloud[PointNormal] PointCloud_PointNormal_t
+ * ctypedef shared_ptr[PointCloud[PointNormal]] PointCloud_PointNormal_Ptr_t             # <<<<<<<<<<<<<<
+ * 
+ * # definitions used everywhere
+ */
+typedef boost::shared_ptr<pcl::PointCloud<struct pcl::PointNormal> >  __pyx_t_3pcl_8pcl_defs_PointCloud_PointNormal_Ptr_t;
+
+/* "pcl_defs.pxd":505
+ * 
+ * # definitions used everywhere
+ * ctypedef shared_ptr[vector[int]] IndicesPtr_t;             # <<<<<<<<<<<<<<
+ * # ctypedef shared_ptr[vector[int]] IndicesConstPtr_t;
+ * 
+ */
+typedef boost::shared_ptr<std::vector<int> >  __pyx_t_3pcl_8pcl_defs_IndicesPtr_t;
+
+/* "pcl_defs.pxd":532
+ * 
+ * 
+ * ctypedef PCLBase[PointXYZ] PCLBase_t             # <<<<<<<<<<<<<<
+ * ctypedef PCLBase[PointXYZI] PCLBase_PointXYZI_t
+ * ctypedef PCLBase[PointXYZRGB] PCLBase_PointXYZRGB_t
+ */
+typedef pcl::PCLBase<struct pcl::PointXYZ>  __pyx_t_3pcl_8pcl_defs_PCLBase_t;
+
+/* "pcl_defs.pxd":533
+ * 
+ * ctypedef PCLBase[PointXYZ] PCLBase_t
+ * ctypedef PCLBase[PointXYZI] PCLBase_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef PCLBase[PointXYZRGB] PCLBase_PointXYZRGB_t
+ * ctypedef PCLBase[PointXYZRGBA] PCLBase_PointXYZRGBA_t
+ */
+typedef pcl::PCLBase<struct pcl::PointXYZI>  __pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZI_t;
+
+/* "pcl_defs.pxd":534
+ * ctypedef PCLBase[PointXYZ] PCLBase_t
+ * ctypedef PCLBase[PointXYZI] PCLBase_PointXYZI_t
+ * ctypedef PCLBase[PointXYZRGB] PCLBase_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef PCLBase[PointXYZRGBA] PCLBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[PCLBase[PointXYZ]] PCLBasePtr_t
+ */
+typedef pcl::PCLBase<struct pcl::PointXYZRGB>  __pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGB_t;
+
+/* "pcl_defs.pxd":535
+ * ctypedef PCLBase[PointXYZI] PCLBase_PointXYZI_t
+ * ctypedef PCLBase[PointXYZRGB] PCLBase_PointXYZRGB_t
+ * ctypedef PCLBase[PointXYZRGBA] PCLBase_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PCLBase[PointXYZ]] PCLBasePtr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZI]] PCLBase_PointXYZI_Ptr_t
+ */
+typedef pcl::PCLBase<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGBA_t;
+
+/* "pcl_defs.pxd":536
+ * ctypedef PCLBase[PointXYZRGB] PCLBase_PointXYZRGB_t
+ * ctypedef PCLBase[PointXYZRGBA] PCLBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[PCLBase[PointXYZ]] PCLBasePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PCLBase[PointXYZI]] PCLBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZRGB]] PCLBase_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::PCLBase<struct pcl::PointXYZ> >  __pyx_t_3pcl_8pcl_defs_PCLBasePtr_t;
+
+/* "pcl_defs.pxd":537
+ * ctypedef PCLBase[PointXYZRGBA] PCLBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[PCLBase[PointXYZ]] PCLBasePtr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZI]] PCLBase_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PCLBase[PointXYZRGB]] PCLBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZRGBA]] PCLBase_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::PCLBase<struct pcl::PointXYZI> >  __pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZI_Ptr_t;
+
+/* "pcl_defs.pxd":538
+ * ctypedef shared_ptr[PCLBase[PointXYZ]] PCLBasePtr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZI]] PCLBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZRGB]] PCLBase_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[PCLBase[PointXYZRGBA]] PCLBase_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::PCLBase<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGB_Ptr_t;
+
+/* "pcl_defs.pxd":539
+ * ctypedef shared_ptr[PCLBase[PointXYZI]] PCLBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZRGB]] PCLBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[PCLBase[PointXYZRGBA]] PCLBase_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::PCLBase<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGBA_Ptr_t;
+
+/* "pcl_defs.pxd":603
+ * 
+ * # ctypedef Vertices Vertices_t
+ * ctypedef shared_ptr[Vertices] VerticesPtr_t             # <<<<<<<<<<<<<<
+ * # ctypedef shared_ptr[Vertices const] VerticesConstPtr
+ * # inline std::ostream& operator<<(std::ostream& s, const  ::pcl::Vertices & v)
+ */
+typedef boost::shared_ptr<pcl::Vertices>  __pyx_t_3pcl_8pcl_defs_VerticesPtr_t;
+
+/* "pcl_kdtree.pxd":185
+ *         # inline int getMinPts () const
+ * 
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZ>  __pyx_t_3pcl_10pcl_kdtree_KdTree_t;
+
+/* "pcl_kdtree.pxd":186
+ * 
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZI>  __pyx_t_3pcl_10pcl_kdtree_KdTree_PointXYZI_t;
+
+/* "pcl_kdtree.pxd":187
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZRGB>  __pyx_t_3pcl_10pcl_kdtree_KdTree_PointXYZRGB_t;
+
+/* "pcl_kdtree.pxd":188
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_10pcl_kdtree_KdTree_PointXYZRGBA_t;
+
+/* "pcl_kdtree.pxd":190
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZ> >  __pyx_t_3pcl_10pcl_kdtree_KdTreePtr_t;
+
+/* "pcl_kdtree.pxd":191
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZI> >  __pyx_t_3pcl_10pcl_kdtree_KdTree_PointXYZI_Ptr_t;
+
+/* "pcl_kdtree.pxd":192
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_10pcl_kdtree_KdTree_PointXYZRGB_Ptr_t;
+
+/* "pcl_kdtree.pxd":193
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_10pcl_kdtree_KdTree_PointXYZRGBA_Ptr_t;
+
+/* "pcl_kdtree.pxd":311
+ * ###
+ * 
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZ>  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_t;
+
+/* "pcl_kdtree.pxd":312
+ * 
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZI>  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZI_t;
+
+/* "pcl_kdtree.pxd":313
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZRGB>  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGB_t;
+
+/* "pcl_kdtree.pxd":314
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGBA_t;
+
+/* "pcl_kdtree.pxd":316
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZ> >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANNPtr_t;
+
+/* "pcl_kdtree.pxd":317
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZI> >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZI_Ptr_t;
+
+/* "pcl_kdtree.pxd":318
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ * 
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGB_Ptr_t;
+
+/* "pcl_kdtree.pxd":319
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGBA_Ptr_t;
+
+/* "pcl_kdtree.pxd":321
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANNConstPtr_t;
+
+/* "pcl_kdtree.pxd":322
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZI_ConstPtr_t;
+
+/* "pcl_kdtree.pxd":323
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+ * 
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_kdtree.pxd":324
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_range_image.pxd":821
+ * 
+ * 
+ * ctypedef RangeImage RangeImage_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+ */
+typedef pcl::RangeImage __pyx_t_3pcl_15pcl_range_image_RangeImage_t;
+
+/* "pcl_range_image.pxd":822
+ * 
+ * ctypedef RangeImage RangeImage_t
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RangeImage>  __pyx_t_3pcl_15pcl_range_image_RangeImagePtr_t;
+
+/* "pcl_range_image.pxd":823
+ * ctypedef RangeImage RangeImage_t
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RangeImage const >  __pyx_t_3pcl_15pcl_range_image_RangeImageConstPtr_t;
+
+/* "pcl_range_image.pxd":964
+ * 
+ * 
+ * ctypedef RangeImagePlanar RangeImagePlanar_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+ */
+typedef pcl::RangeImagePlanar __pyx_t_3pcl_15pcl_range_image_RangeImagePlanar_t;
+
+/* "pcl_range_image.pxd":965
+ * 
+ * ctypedef RangeImagePlanar RangeImagePlanar_t
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RangeImagePlanar>  __pyx_t_3pcl_15pcl_range_image_RangeImagePlanarPtr_t;
+
+/* "pcl_range_image.pxd":966
+ * ctypedef RangeImagePlanar RangeImagePlanar_t
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RangeImagePlanar const >  __pyx_t_3pcl_15pcl_range_image_RangeImagePlanarConstPtr_t;
+
+/* "pcl_features.pxd":454
+ * 
+ * 
+ * ctypedef FPFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.PFHSignature125] FPFHEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FPFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.PFHSignature125]] FPFHEstimationPtr_t
+ * # template <typename PointInT, typename PointNT>
+ */
+typedef pcl::FPFHEstimation<struct pcl::PointXYZ,struct pcl::Normal,struct pcl::PFHSignature125>  __pyx_t_3pcl_12pcl_features_FPFHEstimation_t;
+
+/* "pcl_features.pxd":455
+ * 
+ * ctypedef FPFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.PFHSignature125] FPFHEstimation_t
+ * ctypedef shared_ptr[FPFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.PFHSignature125]] FPFHEstimationPtr_t             # <<<<<<<<<<<<<<
+ * # template <typename PointInT, typename PointNT>
+ * # class FPFHEstimation<PointInT, PointNT, Eigen::MatrixXf> : public FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>
+ */
+typedef boost::shared_ptr<pcl::FPFHEstimation<struct pcl::PointXYZ,struct pcl::Normal,struct pcl::PFHSignature125> >  __pyx_t_3pcl_12pcl_features_FPFHEstimationPtr_t;
+
+/* "pcl_features.pxd":584
+ *         inline void useSensorOriginAsViewPoint ()
+ * 
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_t;
+
+/* "pcl_features.pxd":585
+ * 
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_PointXYZI_t;
+
+/* "pcl_features.pxd":586
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_PointXYZRGB_t;
+
+/* "pcl_features.pxd":587
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_PointXYZRGBA_t;
+
+/* "pcl_features.pxd":588
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimationPtr_t;
+
+/* "pcl_features.pxd":589
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_PointXYZI_Ptr_t;
+
+/* "pcl_features.pxd":590
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_PointXYZRGB_Ptr_t;
+
+/* "pcl_features.pxd":591
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal]) IntegralImageNormalEstimation_PointXYZI_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t;
+
+/* "pcl_features.pxd":1290
+ *         inline void useSensorOriginAsViewPoint ()
+ * 
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_NormalEstimation_t;
+
+/* "pcl_features.pxd":1291
+ * 
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_NormalEstimation_PointXYZI_t;
+
+/* "pcl_features.pxd":1292
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_NormalEstimation_PointXYZRGB_t;
+
+/* "pcl_features.pxd":1293
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_12pcl_features_NormalEstimation_PointXYZRGBA_t;
+
+/* "pcl_features.pxd":2759
+ * 
+ * 
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZ,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_12pcl_features_VFHEstimation_t;
+
+/* "pcl_features.pxd":2760
+ * 
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZI,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_12pcl_features_VFHEstimation_PointXYZI_t;
+
+/* "pcl_features.pxd":2761
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZRGB,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_12pcl_features_VFHEstimation_PointXYZRGB_t;
+
+/* "pcl_features.pxd":2762
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_12pcl_features_VFHEstimation_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":156
+ * 
+ * 
+ * ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_t;
+
+/* "pcl_sample_consensus.pxd":157
+ * 
+ * ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":158
+ * ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":159
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":160
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPtr_t;
+
+/* "pcl_sample_consensus.pxd":161
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":162
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":163
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":164
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":165
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":166
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":167
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModel_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":208
+ * # ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGB_t
+ * # ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormalsPtr_t;
+
+/* "pcl_sample_consensus.pxd":209
+ * # ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormals_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":210
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":211
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":212
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormalsConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":213
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":214
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":215
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":290
+ * 
+ * 
+ * ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_t;
+
+/* "pcl_sample_consensus.pxd":291
+ * 
+ * ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":292
+ * ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":293
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":294
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusPtr_t;
+
+/* "pcl_sample_consensus.pxd":295
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":296
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":297
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":298
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":299
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":300
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":301
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":494
+ * 
+ * 
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_t;
+
+/* "pcl_sample_consensus.pxd":495
+ * 
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":496
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":497
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":498
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlanePtr_t;
+
+/* "pcl_sample_consensus.pxd":499
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":500
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":501
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":502
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlaneConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":503
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":504
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":505
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":622
+ * 
+ * 
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_t;
+
+/* "pcl_sample_consensus.pxd":623
+ * 
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":624
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":625
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":626
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSpherePtr_t;
+
+/* "pcl_sample_consensus.pxd":627
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":628
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":629
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":630
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphereConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":631
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":632
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":633
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":786
+ * 
+ * 
+ * ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_t;
+
+/* "pcl_sample_consensus.pxd":787
+ * 
+ * ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":788
+ * ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":789
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":790
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensusPtr_t;
+
+/* "pcl_sample_consensus.pxd":791
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":792
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":793
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":794
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":795
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":796
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":797
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":838
+ * 
+ * 
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_t;
+
+/* "pcl_sample_consensus.pxd":839
+ * 
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":840
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":841
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":842
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensusPtr_t;
+
+/* "pcl_sample_consensus.pxd":843
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":844
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":845
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":846
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":847
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":848
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":849
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":891
+ * 
+ * 
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_t;
+
+/* "pcl_sample_consensus.pxd":892
+ * 
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":893
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":894
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":895
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensusPtr_t;
+
+/* "pcl_sample_consensus.pxd":896
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":897
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":898
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":899
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":900
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":901
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":902
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":975
+ * 
+ * 
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_t;
+
+/* "pcl_sample_consensus.pxd":976
+ * 
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":977
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":978
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":979
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2DPtr_t;
+
+/* "pcl_sample_consensus.pxd":980
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":981
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":982
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":983
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2DConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":984
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":985
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":986
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1107
+ * 
+ * 
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCone_t;
+
+/* "pcl_sample_consensus.pxd":1108
+ * 
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCone_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1109
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCone_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1110
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCone_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1111
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelConePtr_t;
+
+/* "pcl_sample_consensus.pxd":1112
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCone_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1113
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCone_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1114
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCone_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1252
+ * 
+ * 
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_t;
+
+/* "pcl_sample_consensus.pxd":1253
+ * 
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1254
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1255
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1256
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinderPtr_t;
+
+/* "pcl_sample_consensus.pxd":1257
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1258
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1259
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1260
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinderConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1261
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1262
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1263
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1368
+ * 
+ * 
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_t;
+
+/* "pcl_sample_consensus.pxd":1369
+ * 
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1370
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1371
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1372
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLinePtr_t;
+
+/* "pcl_sample_consensus.pxd":1373
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1374
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1375
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1376
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLineConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1377
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1378
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1379
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1509
+ * 
+ * 
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_t;
+
+/* "pcl_sample_consensus.pxd":1510
+ * 
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1511
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1512
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1513
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlanePtr_t;
+
+/* "pcl_sample_consensus.pxd":1514
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1515
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1516
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1517
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlaneConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1518
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1519
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1520
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1601
+ * 
+ * 
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_t;
+
+/* "pcl_sample_consensus.pxd":1602
+ * 
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1603
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1604
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1605
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlanePtr_t;
+
+/* "pcl_sample_consensus.pxd":1606
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1607
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1608
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1609
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlaneConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1610
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1611
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1612
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1687
+ * 
+ * 
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_t;
+
+/* "pcl_sample_consensus.pxd":1688
+ * 
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1689
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1690
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1691
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSpherePtr_t;
+
+/* "pcl_sample_consensus.pxd":1692
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1693
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1694
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1695
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphereConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1696
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1697
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1698
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1784
+ * 
+ * 
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_t;
+
+/* "pcl_sample_consensus.pxd":1785
+ * 
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1786
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1787
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1788
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLinePtr_t;
+
+/* "pcl_sample_consensus.pxd":1789
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1790
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1791
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1792
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLineConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1793
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1794
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1795
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1882
+ * 
+ * 
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_t;
+
+/* "pcl_sample_consensus.pxd":1883
+ * 
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1884
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1885
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1886
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlanePtr_t;
+
+/* "pcl_sample_consensus.pxd":1887
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1888
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1889
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1890
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlaneConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1891
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1892
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1893
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1984
+ * 
+ * 
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_t;
+
+/* "pcl_sample_consensus.pxd":1985
+ * 
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":1986
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":1987
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":1988
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlanePtr_t;
+
+/* "pcl_sample_consensus.pxd":1989
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1990
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1991
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":1992
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlaneConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1993
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1994
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":1995
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2096
+ * 
+ * 
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_t;
+
+/* "pcl_sample_consensus.pxd":2097
+ * 
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":2098
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":2099
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":2100
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistrationPtr_t;
+
+/* "pcl_sample_consensus.pxd":2101
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":2102
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":2103
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":2104
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistrationConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2105
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2106
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2107
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2208
+ * 
+ * 
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_t;
+
+/* "pcl_sample_consensus.pxd":2209
+ * 
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZI_t;
+
+/* "pcl_sample_consensus.pxd":2210
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZRGB_t;
+
+/* "pcl_sample_consensus.pxd":2211
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus.pxd":2212
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStickPtr_t;
+
+/* "pcl_sample_consensus.pxd":2213
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":2214
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":2215
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus.pxd":2216
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStickConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2217
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2218
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus.pxd":2219
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":764
+ * ctypedef npy_longdouble longdouble_t
+ * 
+ * ctypedef npy_cfloat      cfloat_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t
+ */
+typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":765
+ * 
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t             # <<<<<<<<<<<<<<
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ */
+typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":766
+ * ctypedef npy_cfloat      cfloat_t
+ * ctypedef npy_cdouble     cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef npy_cdouble     complex_t
+ */
+typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":768
+ * ctypedef npy_clongdouble clongdouble_t
+ * 
+ * ctypedef npy_cdouble     complex_t             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ */
+typedef npy_cdouble __pyx_t_5numpy_complex_t;
+
+/* "pcl_sample_consensus_180.pxd":156
+ * 
+ * 
+ * ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_t;
+
+/* "pcl_sample_consensus_180.pxd":157
+ * 
+ * ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":158
+ * ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":159
+ * ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModel<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":160
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":161
+ * ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":162
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":163
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":164
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":165
+ * ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":166
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":167
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModel<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModel_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":208
+ * # ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGB_t
+ * # ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormalsPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":209
+ * # ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormals_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":210
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":211
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":212
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormalsConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":213
+ * ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":214
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":215
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelFromNormals<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":290
+ * 
+ * 
+ * ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_t;
+
+/* "pcl_sample_consensus_180.pxd":291
+ * 
+ * ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":292
+ * ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":293
+ * ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":294
+ * ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":295
+ * ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":296
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":297
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":298
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":299
+ * ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":300
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":301
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":494
+ * 
+ * 
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_t;
+
+/* "pcl_sample_consensus_180.pxd":495
+ * 
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":496
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":497
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":498
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlanePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":499
+ * ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":500
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":501
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":502
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlaneConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":503
+ * ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":504
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":505
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPlane<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":622
+ * 
+ * 
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_t;
+
+/* "pcl_sample_consensus_180.pxd":623
+ * 
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":624
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":625
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":626
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSpherePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":627
+ * ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":628
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":629
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":630
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphereConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":631
+ * ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":632
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":633
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelSphere<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":786
+ * 
+ * 
+ * ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_t;
+
+/* "pcl_sample_consensus_180.pxd":787
+ * 
+ * ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":788
+ * ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":789
+ * ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::RandomSampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":790
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensusPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":791
+ * ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":792
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":793
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":794
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":795
+ * ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":796
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":797
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RandomSampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomSampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":838
+ * 
+ * 
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_t;
+
+/* "pcl_sample_consensus_180.pxd":839
+ * 
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":840
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":841
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":842
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensusPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":843
+ * ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":844
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":845
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":846
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":847
+ * ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":848
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":849
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RandomizedMEstimatorSampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":891
+ * 
+ * 
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_t;
+
+/* "pcl_sample_consensus_180.pxd":892
+ * 
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":893
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":894
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ */
+typedef pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":895
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensusPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":896
+ * ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":897
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":898
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":899
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensusConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":900
+ * ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":901
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":902
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RandomizedRandomSampleConsensus<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":975
+ * 
+ * 
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_t;
+
+/* "pcl_sample_consensus_180.pxd":976
+ * 
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":977
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":978
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":979
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2DPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":980
+ * ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":981
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":982
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":983
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2DConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":984
+ * ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":985
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":986
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCircle2D<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1107
+ * 
+ * 
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCone_t;
+
+/* "pcl_sample_consensus_180.pxd":1108
+ * 
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCone_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1109
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCone_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1110
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelCone<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCone_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1111
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelConePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1112
+ * ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCone_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1113
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCone_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1114
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCone<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCone_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1252
+ * 
+ * 
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_t;
+
+/* "pcl_sample_consensus_180.pxd":1253
+ * 
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1254
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1255
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1256
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinderPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1257
+ * ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1258
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1259
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1260
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinderConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1261
+ * ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1262
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1263
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1368
+ * 
+ * 
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_t;
+
+/* "pcl_sample_consensus_180.pxd":1369
+ * 
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1370
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1371
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelLine<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1372
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLinePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1373
+ * ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1374
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1375
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1376
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLineConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1377
+ * ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1378
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1379
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelLine<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1509
+ * 
+ * 
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_t;
+
+/* "pcl_sample_consensus_180.pxd":1510
+ * 
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1511
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1512
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1513
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlanePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1514
+ * ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1515
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1516
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1517
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlaneConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1518
+ * ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1519
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1520
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalParallelPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1601
+ * 
+ * 
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_t;
+
+/* "pcl_sample_consensus_180.pxd":1602
+ * 
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1603
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1604
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1605
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlanePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1606
+ * ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1607
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1608
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1609
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlaneConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1610
+ * ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1611
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1612
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalPlane<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1687
+ * 
+ * 
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_t;
+
+/* "pcl_sample_consensus_180.pxd":1688
+ * 
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1689
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1690
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1691
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSpherePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1692
+ * ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1693
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1694
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1695
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZ,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphereConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1696
+ * ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZI,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1697
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGB,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1698
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelNormalSphere<struct pcl::PointXYZRGBA,struct pcl::Normal>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1784
+ * 
+ * 
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_t;
+
+/* "pcl_sample_consensus_180.pxd":1785
+ * 
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1786
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1787
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1788
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLinePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1789
+ * ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1790
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1791
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1792
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLineConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1793
+ * ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1794
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1795
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelLine<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1882
+ * 
+ * 
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_t;
+
+/* "pcl_sample_consensus_180.pxd":1883
+ * 
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1884
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1885
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1886
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlanePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1887
+ * ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1888
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1889
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1890
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlaneConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1891
+ * ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1892
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1893
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelParallelPlane<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1984
+ * 
+ * 
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_t;
+
+/* "pcl_sample_consensus_180.pxd":1985
+ * 
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":1986
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":1987
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":1988
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlanePtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1989
+ * ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1990
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1991
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":1992
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlaneConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1993
+ * ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1994
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":1995
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelPerpendicularPlane<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2096
+ * 
+ * 
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_t;
+
+/* "pcl_sample_consensus_180.pxd":2097
+ * 
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":2098
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":2099
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":2100
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistrationPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2101
+ * ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":2102
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":2103
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":2104
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistrationConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2105
+ * ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2106
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2107
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2208
+ * 
+ * 
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_t;
+
+/* "pcl_sample_consensus_180.pxd":2209
+ * 
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZI>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZI_t;
+
+/* "pcl_sample_consensus_180.pxd":2210
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZRGB>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZRGB_t;
+
+/* "pcl_sample_consensus_180.pxd":2211
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ */
+typedef pcl::SampleConsensusModelStick<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZRGBA_t;
+
+/* "pcl_sample_consensus_180.pxd":2212
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZ> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStickPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2213
+ * ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZI> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZI_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":2214
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZRGB_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":2215
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZRGBA_Ptr_t;
+
+/* "pcl_sample_consensus_180.pxd":2216
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStickConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2217
+ * ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZI_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2218
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_sample_consensus_180.pxd":2219
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SampleConsensusModelStick<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_24pcl_sample_consensus_180_SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":37
+ * 
+ * 
+ * ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t             # <<<<<<<<<<<<<<
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_t;
+
+/* "pcl_filters_180.pxd":38
+ * 
+ * ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":39
+ * ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":40
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":41
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBasePtr_t;
+
+/* "pcl_filters_180.pxd":42
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":43
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":44
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":45
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBaseConstPtr_t;
+
+/* "pcl_filters_180.pxd":46
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":47
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":48
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_15pcl_filters_180_ComparisonBase_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":73
+ * 
+ * 
+ * ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_t;
+
+/* "pcl_filters_180.pxd":74
+ * 
+ * ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":75
+ * ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":76
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":77
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_ConditionBasePtr_t;
+
+/* "pcl_filters_180.pxd":78
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":79
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":80
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":81
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionBaseConstPtr_t;
+
+/* "pcl_filters_180.pxd":82
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":83
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":84
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionBase_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":110
+ * 
+ * 
+ * ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_FilterPtr_t;
+
+/* "pcl_filters_180.pxd":111
+ * 
+ * ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_Filter_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":112
+ * ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_Filter_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":113
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_Filter_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":114
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_15pcl_filters_180_FilterConstPtr_t;
+
+/* "pcl_filters_180.pxd":115
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_15pcl_filters_180_Filter_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":116
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_15pcl_filters_180_Filter_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":117
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_15pcl_filters_180_Filter_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":332
+ * 
+ * 
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t             # <<<<<<<<<<<<<<
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGrid_t;
+
+/* "pcl_filters_180.pxd":333
+ * 
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGrid_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":334
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGrid_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":335
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGrid_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":336
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGridPtr_t;
+
+/* "pcl_filters_180.pxd":337
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGrid_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":338
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGrid_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":339
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_ApproximateVoxelGrid_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":455
+ * 
+ * 
+ * ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t             # <<<<<<<<<<<<<<
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_t;
+
+/* "pcl_filters_180.pxd":456
+ * 
+ * ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":457
+ * ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":458
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":459
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_FieldComparisonPtr_t;
+
+/* "pcl_filters_180.pxd":460
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":461
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":462
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":463
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_15pcl_filters_180_FieldComparisonConstPtr_t;
+
+/* "pcl_filters_180.pxd":464
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":465
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":466
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_15pcl_filters_180_FieldComparison_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":575
+ * 
+ * 
+ * ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_t;
+
+/* "pcl_filters_180.pxd":576
+ * 
+ * ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":577
+ * ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":578
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":579
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_ConditionAndPtr_t;
+
+/* "pcl_filters_180.pxd":580
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":581
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":582
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":583
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionAndConstPtr_t;
+
+/* "pcl_filters_180.pxd":584
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":585
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":586
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionAnd_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":601
+ * 
+ * 
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_ConditionOrPtr_t;
+
+/* "pcl_filters_180.pxd":602
+ * 
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_ConditionOr_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":603
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_ConditionOr_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":604
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_ConditionOr_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":605
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionOrConstPtr_t;
+
+/* "pcl_filters_180.pxd":606
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionOr_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":607
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionOr_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":608
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionOr_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":650
+ * 
+ * 
+ * ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_t;
+
+/* "pcl_filters_180.pxd":651
+ * 
+ * ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":652
+ * ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":653
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":654
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZ> >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemovalPtr_t;
+
+/* "pcl_filters_180.pxd":655
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZI> >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZI_Ptr_t;
+
+/* "pcl_filters_180.pxd":656
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters_180.pxd":657
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters_180.pxd":658
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemovalConstPtr_t;
+
+/* "pcl_filters_180.pxd":659
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":660
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":661
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_15pcl_filters_180_ConditionalRemoval_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters_180.pxd":711
+ * 
+ * 
+ * ctypedef CropBox[cpp.PointXYZ] CropBox_t             # <<<<<<<<<<<<<<
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ */
+typedef pcl::CropBox<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_CropBox_t;
+
+/* "pcl_filters_180.pxd":712
+ * 
+ * ctypedef CropBox[cpp.PointXYZ] CropBox_t
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ * ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t
+ */
+typedef pcl::CropBox<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_CropBox_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":713
+ * ctypedef CropBox[cpp.PointXYZ] CropBox_t
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::CropBox<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_CropBox_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":714
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ * ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::CropBox<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_CropBox_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":801
+ * 
+ * 
+ * ctypedef CropHull[cpp.PointXYZ] CropHull_t             # <<<<<<<<<<<<<<
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ */
+typedef pcl::CropHull<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_CropHull_t;
+
+/* "pcl_filters_180.pxd":802
+ * 
+ * ctypedef CropHull[cpp.PointXYZ] CropHull_t
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ * ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t
+ */
+typedef pcl::CropHull<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_CropHull_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":803
+ * ctypedef CropHull[cpp.PointXYZ] CropHull_t
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::CropHull<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_CropHull_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":804
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ * ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::CropHull<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_CropHull_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":920
+ * 
+ * 
+ * ctypedef PassThrough[cpp.PointXYZ] PassThrough_t             # <<<<<<<<<<<<<<
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_PassThrough_t;
+
+/* "pcl_filters_180.pxd":921
+ * 
+ * ctypedef PassThrough[cpp.PointXYZ] PassThrough_t
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ * ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_PassThrough_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":922
+ * ctypedef PassThrough[cpp.PointXYZ] PassThrough_t
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_PassThrough_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":923
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ * ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_PassThrough_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":1037
+ *         bool getCopyAllData ()
+ * 
+ * ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t             # <<<<<<<<<<<<<<
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_ProjectInliers_t;
+
+/* "pcl_filters_180.pxd":1038
+ * 
+ * ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_ProjectInliers_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":1039
+ * ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] ProjectInliersPtr_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_ProjectInliers_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":1040
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] ProjectInliersPtr_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] ProjectInliers_PointXYZI_Ptr_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_ProjectInliers_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":1107
+ *         int getMinNeighborsInRadius ()
+ * 
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t             # <<<<<<<<<<<<<<
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_RadiusOutlierRemoval_t;
+
+/* "pcl_filters_180.pxd":1108
+ * 
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_RadiusOutlierRemoval_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":1109
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] RadiusOutlierRemovalPtr_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_RadiusOutlierRemoval_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":1110
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] RadiusOutlierRemovalPtr_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] RadiusOutlierRemoval_PointXYZI_Ptr_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_RadiusOutlierRemoval_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":1216
+ * 
+ * 
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t             # <<<<<<<<<<<<<<
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_StatisticalOutlierRemoval_t;
+
+/* "pcl_filters_180.pxd":1217
+ * 
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_StatisticalOutlierRemoval_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":1218
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_StatisticalOutlierRemoval_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":1219
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_StatisticalOutlierRemoval_PointXYZRGBA_t;
+
+/* "pcl_filters_180.pxd":1483
+ * ###
+ * 
+ * ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t             # <<<<<<<<<<<<<<
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZ>  __pyx_t_3pcl_15pcl_filters_180_VoxelGrid_t;
+
+/* "pcl_filters_180.pxd":1484
+ * 
+ * ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZI>  __pyx_t_3pcl_15pcl_filters_180_VoxelGrid_PointXYZI_t;
+
+/* "pcl_filters_180.pxd":1485
+ * ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZRGB>  __pyx_t_3pcl_15pcl_filters_180_VoxelGrid_PointXYZRGB_t;
+
+/* "pcl_filters_180.pxd":1486
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_15pcl_filters_180_VoxelGrid_PointXYZRGBA_t;
+
+/* "pcl_range_image_180.pxd":820
+ * 
+ * 
+ * ctypedef RangeImage RangeImage_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+ */
+typedef pcl::RangeImage __pyx_t_3pcl_19pcl_range_image_180_RangeImage_t;
+
+/* "pcl_range_image_180.pxd":821
+ * 
+ * ctypedef RangeImage RangeImage_t
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RangeImage>  __pyx_t_3pcl_19pcl_range_image_180_RangeImagePtr_t;
+
+/* "pcl_range_image_180.pxd":822
+ * ctypedef RangeImage RangeImage_t
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RangeImage const >  __pyx_t_3pcl_19pcl_range_image_180_RangeImageConstPtr_t;
+
+/* "pcl_range_image_180.pxd":963
+ * 
+ * 
+ * ctypedef RangeImagePlanar RangeImagePlanar_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+ */
+typedef pcl::RangeImagePlanar __pyx_t_3pcl_19pcl_range_image_180_RangeImagePlanar_t;
+
+/* "pcl_range_image_180.pxd":964
+ * 
+ * ctypedef RangeImagePlanar RangeImagePlanar_t
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RangeImagePlanar>  __pyx_t_3pcl_19pcl_range_image_180_RangeImagePlanarPtr_t;
+
+/* "pcl_range_image_180.pxd":965
+ * ctypedef RangeImagePlanar RangeImagePlanar_t
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RangeImagePlanar const >  __pyx_t_3pcl_19pcl_range_image_180_RangeImagePlanarConstPtr_t;
+
+/* "pcl_surface.pxd":406
+ * 
+ * 
+ * ctypedef ConcaveHull[cpp.PointXYZ] ConcaveHull_t             # <<<<<<<<<<<<<<
+ * ctypedef ConcaveHull[cpp.PointXYZI] ConcaveHull_PointXYZI_t
+ * ctypedef ConcaveHull[cpp.PointXYZRGB] ConcaveHull_PointXYZRGB_t
+ */
+typedef pcl::ConcaveHull<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_surface_ConcaveHull_t;
+
+/* "pcl_surface.pxd":407
+ * 
+ * ctypedef ConcaveHull[cpp.PointXYZ] ConcaveHull_t
+ * ctypedef ConcaveHull[cpp.PointXYZI] ConcaveHull_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ConcaveHull[cpp.PointXYZRGB] ConcaveHull_PointXYZRGB_t
+ * ctypedef ConcaveHull[cpp.PointXYZRGBA] ConcaveHull_PointXYZRGBA_t
+ */
+typedef pcl::ConcaveHull<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZI_t;
+
+/* "pcl_surface.pxd":408
+ * ctypedef ConcaveHull[cpp.PointXYZ] ConcaveHull_t
+ * ctypedef ConcaveHull[cpp.PointXYZI] ConcaveHull_PointXYZI_t
+ * ctypedef ConcaveHull[cpp.PointXYZRGB] ConcaveHull_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ConcaveHull[cpp.PointXYZRGBA] ConcaveHull_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::ConcaveHull<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZRGB_t;
+
+/* "pcl_surface.pxd":409
+ * ctypedef ConcaveHull[cpp.PointXYZI] ConcaveHull_PointXYZI_t
+ * ctypedef ConcaveHull[cpp.PointXYZRGB] ConcaveHull_PointXYZRGB_t
+ * ctypedef ConcaveHull[cpp.PointXYZRGBA] ConcaveHull_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::ConcaveHull<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZRGBA_t;
+
+/* "pcl_surface.pxd":1803
+ *         pclkdt.KdTreePtr_t getSearchMethod ()
+ * 
+ * ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointXYZ] MovingLeastSquares_t             # <<<<<<<<<<<<<<
+ * ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointXYZI] MovingLeastSquares_PointXYZI_t
+ * ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointXYZRGB] MovingLeastSquares_PointXYZRGB_t
+ */
+typedef pcl::MovingLeastSquares<struct pcl::PointXYZ,struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_t;
+
+/* "pcl_surface.pxd":1804
+ * 
+ * ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointXYZ] MovingLeastSquares_t
+ * ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointXYZI] MovingLeastSquares_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointXYZRGB] MovingLeastSquares_PointXYZRGB_t
+ * ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointXYZRGBA] MovingLeastSquares_PointXYZRGBA_t
+ */
+typedef pcl::MovingLeastSquares<struct pcl::PointXYZI,struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZI_t;
+
+/* "pcl_surface.pxd":1805
+ * ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointXYZ] MovingLeastSquares_t
+ * ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointXYZI] MovingLeastSquares_PointXYZI_t
+ * ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointXYZRGB] MovingLeastSquares_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointXYZRGBA] MovingLeastSquares_PointXYZRGBA_t
+ * # NG
+ */
+typedef pcl::MovingLeastSquares<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGB_t;
+
+/* "pcl_surface.pxd":1806
+ * ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointXYZI] MovingLeastSquares_PointXYZI_t
+ * ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointXYZRGB] MovingLeastSquares_PointXYZRGB_t
+ * ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointXYZRGBA] MovingLeastSquares_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * # NG
+ * # ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointNormal] MovingLeastSquares_t
+ */
+typedef pcl::MovingLeastSquares<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGBA_t;
+
+/* "pcl_segmentation_180.pxd":132
+ * 
+ * 
+ * ctypedef SACSegmentation[PointXYZ] SACSegmentation_t             # <<<<<<<<<<<<<<
+ * ctypedef SACSegmentation[PointXYZI] SACSegmentation_PointXYZI_t
+ * ctypedef SACSegmentation[PointXYZRGB] SACSegmentation_PointXYZRGB_t
+ */
+typedef pcl::SACSegmentation<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_t;
+
+/* "pcl_segmentation_180.pxd":133
+ * 
+ * ctypedef SACSegmentation[PointXYZ] SACSegmentation_t
+ * ctypedef SACSegmentation[PointXYZI] SACSegmentation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SACSegmentation[PointXYZRGB] SACSegmentation_PointXYZRGB_t
+ * ctypedef SACSegmentation[PointXYZRGBA] SACSegmentation_PointXYZRGBA_t
+ */
+typedef pcl::SACSegmentation<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZI_t;
+
+/* "pcl_segmentation_180.pxd":134
+ * ctypedef SACSegmentation[PointXYZ] SACSegmentation_t
+ * ctypedef SACSegmentation[PointXYZI] SACSegmentation_PointXYZI_t
+ * ctypedef SACSegmentation[PointXYZRGB] SACSegmentation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SACSegmentation[PointXYZRGBA] SACSegmentation_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::SACSegmentation<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGB_t;
+
+/* "pcl_segmentation_180.pxd":135
+ * ctypedef SACSegmentation[PointXYZI] SACSegmentation_PointXYZI_t
+ * ctypedef SACSegmentation[PointXYZRGB] SACSegmentation_PointXYZRGB_t
+ * ctypedef SACSegmentation[PointXYZRGBA] SACSegmentation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::SACSegmentation<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGBA_t;
+
+/* "pcl_segmentation_180.pxd":204
+ * 
+ * 
+ * ctypedef SACSegmentationFromNormals[PointXYZ,Normal] SACSegmentationFromNormals_t             # <<<<<<<<<<<<<<
+ * ctypedef SACSegmentationFromNormals[PointXYZI,Normal] SACSegmentationFromNormals_PointXYZI_t
+ * ctypedef SACSegmentationFromNormals[PointXYZRGB,Normal] SACSegmentationFromNormals_PointXYZRGB_t
+ */
+typedef pcl::SACSegmentationFromNormals<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_t;
+
+/* "pcl_segmentation_180.pxd":205
+ * 
+ * ctypedef SACSegmentationFromNormals[PointXYZ,Normal] SACSegmentationFromNormals_t
+ * ctypedef SACSegmentationFromNormals[PointXYZI,Normal] SACSegmentationFromNormals_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef SACSegmentationFromNormals[PointXYZRGB,Normal] SACSegmentationFromNormals_PointXYZRGB_t
+ * ctypedef SACSegmentationFromNormals[PointXYZRGBA,Normal] SACSegmentationFromNormals_PointXYZRGBA_t
+ */
+typedef pcl::SACSegmentationFromNormals<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZI_t;
+
+/* "pcl_segmentation_180.pxd":206
+ * ctypedef SACSegmentationFromNormals[PointXYZ,Normal] SACSegmentationFromNormals_t
+ * ctypedef SACSegmentationFromNormals[PointXYZI,Normal] SACSegmentationFromNormals_PointXYZI_t
+ * ctypedef SACSegmentationFromNormals[PointXYZRGB,Normal] SACSegmentationFromNormals_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef SACSegmentationFromNormals[PointXYZRGBA,Normal] SACSegmentationFromNormals_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::SACSegmentationFromNormals<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGB_t;
+
+/* "pcl_segmentation_180.pxd":207
+ * ctypedef SACSegmentationFromNormals[PointXYZI,Normal] SACSegmentationFromNormals_PointXYZI_t
+ * ctypedef SACSegmentationFromNormals[PointXYZRGB,Normal] SACSegmentationFromNormals_PointXYZRGB_t
+ * ctypedef SACSegmentationFromNormals[PointXYZRGBA,Normal] SACSegmentationFromNormals_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::SACSegmentationFromNormals<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGBA_t;
+
+/* "pcl_segmentation_180.pxd":409
+ * 
+ * 
+ * ctypedef EuclideanClusterComparator[PointXYZ, Normal, PointXYZ] EuclideanClusterComparator_t             # <<<<<<<<<<<<<<
+ * ctypedef EuclideanClusterComparator[PointXYZI, Normal, PointXYZ] EuclideanClusterComparator_PointXYZI_t
+ * ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t
+ */
+typedef pcl::EuclideanClusterComparator<struct pcl::PointXYZ,struct pcl::Normal,struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparator_t;
+
+/* "pcl_segmentation_180.pxd":410
+ * 
+ * ctypedef EuclideanClusterComparator[PointXYZ, Normal, PointXYZ] EuclideanClusterComparator_t
+ * ctypedef EuclideanClusterComparator[PointXYZI, Normal, PointXYZ] EuclideanClusterComparator_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t
+ * ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t
+ */
+typedef pcl::EuclideanClusterComparator<struct pcl::PointXYZI,struct pcl::Normal,struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparator_PointXYZI_t;
+
+/* "pcl_segmentation_180.pxd":411
+ * ctypedef EuclideanClusterComparator[PointXYZ, Normal, PointXYZ] EuclideanClusterComparator_t
+ * ctypedef EuclideanClusterComparator[PointXYZI, Normal, PointXYZ] EuclideanClusterComparator_PointXYZI_t
+ * ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t
+ */
+typedef pcl::EuclideanClusterComparator<struct pcl::PointXYZRGB,struct pcl::Normal,struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparator_PointXYZRGB_t;
+
+/* "pcl_segmentation_180.pxd":412
+ * ctypedef EuclideanClusterComparator[PointXYZI, Normal, PointXYZ] EuclideanClusterComparator_PointXYZI_t
+ * ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t
+ * ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t
+ */
+typedef pcl::EuclideanClusterComparator<struct pcl::PointXYZRGBA,struct pcl::Normal,struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparator_PointXYZRGBA_t;
+
+/* "pcl_segmentation_180.pxd":413
+ * ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t
+ * ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::EuclideanClusterComparator<struct pcl::PointXYZ,struct pcl::Normal,struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparatorPtr_t;
+
+/* "pcl_segmentation_180.pxd":414
+ * ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::EuclideanClusterComparator<struct pcl::PointXYZI,struct pcl::Normal,struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparator_PointXYZI_Ptr_t;
+
+/* "pcl_segmentation_180.pxd":415
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::EuclideanClusterComparator<struct pcl::PointXYZRGB,struct pcl::Normal,struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparator_PointXYZRGB_Ptr_t;
+
+/* "pcl_segmentation_180.pxd":416
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::EuclideanClusterComparator<struct pcl::PointXYZRGBA,struct pcl::Normal,struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterComparator_PointXYZRGBA_Ptr_t;
+
+/* "pcl_segmentation_180.pxd":597
+ * 
+ * 
+ * ctypedef EuclideanClusterExtraction[PointXYZ] EuclideanClusterExtraction_t             # <<<<<<<<<<<<<<
+ * ctypedef EuclideanClusterExtraction[PointXYZI] EuclideanClusterExtraction_PointXYZI_t
+ * ctypedef EuclideanClusterExtraction[PointXYZRGB] EuclideanClusterExtraction_PointXYZRGB_t
+ */
+typedef pcl::EuclideanClusterExtraction<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_t;
+
+/* "pcl_segmentation_180.pxd":598
+ * 
+ * ctypedef EuclideanClusterExtraction[PointXYZ] EuclideanClusterExtraction_t
+ * ctypedef EuclideanClusterExtraction[PointXYZI] EuclideanClusterExtraction_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef EuclideanClusterExtraction[PointXYZRGB] EuclideanClusterExtraction_PointXYZRGB_t
+ * ctypedef EuclideanClusterExtraction[PointXYZRGBA] EuclideanClusterExtraction_PointXYZRGBA_t
+ */
+typedef pcl::EuclideanClusterExtraction<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_PointXYZI_t;
+
+/* "pcl_segmentation_180.pxd":599
+ * ctypedef EuclideanClusterExtraction[PointXYZ] EuclideanClusterExtraction_t
+ * ctypedef EuclideanClusterExtraction[PointXYZI] EuclideanClusterExtraction_PointXYZI_t
+ * ctypedef EuclideanClusterExtraction[PointXYZRGB] EuclideanClusterExtraction_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef EuclideanClusterExtraction[PointXYZRGBA] EuclideanClusterExtraction_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::EuclideanClusterExtraction<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_PointXYZRGB_t;
+
+/* "pcl_segmentation_180.pxd":600
+ * ctypedef EuclideanClusterExtraction[PointXYZI] EuclideanClusterExtraction_PointXYZI_t
+ * ctypedef EuclideanClusterExtraction[PointXYZRGB] EuclideanClusterExtraction_PointXYZRGB_t
+ * ctypedef EuclideanClusterExtraction[PointXYZRGBA] EuclideanClusterExtraction_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::EuclideanClusterExtraction<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_PointXYZRGBA_t;
+
+/* "pcl_segmentation_180.pxd":2982
+ * 
+ * 
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZ] ProgressiveMorphologicalFilter_t             # <<<<<<<<<<<<<<
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZI] ProgressiveMorphologicalFilter_PointXYZI_t
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZRGB] ProgressiveMorphologicalFilter_PointXYZRGB_t
+ */
+typedef pcl::ProgressiveMorphologicalFilter<struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_segmentation_180_ProgressiveMorphologicalFilter_t;
+
+/* "pcl_segmentation_180.pxd":2983
+ * 
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZ] ProgressiveMorphologicalFilter_t
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZI] ProgressiveMorphologicalFilter_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZRGB] ProgressiveMorphologicalFilter_PointXYZRGB_t
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZRGBA] ProgressiveMorphologicalFilter_PointXYZRGBA_t
+ */
+typedef pcl::ProgressiveMorphologicalFilter<struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_segmentation_180_ProgressiveMorphologicalFilter_PointXYZI_t;
+
+/* "pcl_segmentation_180.pxd":2984
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZ] ProgressiveMorphologicalFilter_t
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZI] ProgressiveMorphologicalFilter_PointXYZI_t
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZRGB] ProgressiveMorphologicalFilter_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZRGBA] ProgressiveMorphologicalFilter_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::ProgressiveMorphologicalFilter<struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_segmentation_180_ProgressiveMorphologicalFilter_PointXYZRGB_t;
+
+/* "pcl_segmentation_180.pxd":2985
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZI] ProgressiveMorphologicalFilter_PointXYZI_t
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZRGB] ProgressiveMorphologicalFilter_PointXYZRGB_t
+ * ctypedef ProgressiveMorphologicalFilter[PointXYZRGBA] ProgressiveMorphologicalFilter_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::ProgressiveMorphologicalFilter<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_segmentation_180_ProgressiveMorphologicalFilter_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":37
+ * 
+ * 
+ * ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t             # <<<<<<<<<<<<<<
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_ComparisonBase_t;
+
+/* "pcl_filters.pxd":38
+ * 
+ * ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZI_t;
+
+/* "pcl_filters.pxd":39
+ * ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":40
+ * ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ */
+typedef pcl::ComparisonBase<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":41
+ * ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_ComparisonBasePtr_t;
+
+/* "pcl_filters.pxd":42
+ * ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":43
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":44
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":45
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_11pcl_filters_ComparisonBaseConstPtr_t;
+
+/* "pcl_filters.pxd":46
+ * ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters.pxd":47
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters.pxd":48
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_11pcl_filters_ComparisonBase_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters.pxd":73
+ * 
+ * 
+ * ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_ConditionBase_t;
+
+/* "pcl_filters.pxd":74
+ * 
+ * ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZI_t;
+
+/* "pcl_filters.pxd":75
+ * ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":76
+ * ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ */
+typedef pcl::ConditionBase<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":77
+ * ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_ConditionBasePtr_t;
+
+/* "pcl_filters.pxd":78
+ * ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":79
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":80
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":81
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_11pcl_filters_ConditionBaseConstPtr_t;
+
+/* "pcl_filters.pxd":82
+ * ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters.pxd":83
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters.pxd":84
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionBase<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_11pcl_filters_ConditionBase_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters.pxd":111
+ * 
+ * 
+ * ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_FilterPtr_t;
+
+/* "pcl_filters.pxd":112
+ * 
+ * ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_Filter_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":113
+ * ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_Filter_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":114
+ * ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_Filter_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":115
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_11pcl_filters_FilterConstPtr_t;
+
+/* "pcl_filters.pxd":116
+ * ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_11pcl_filters_Filter_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters.pxd":117
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_11pcl_filters_Filter_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters.pxd":118
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::Filter<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_11pcl_filters_Filter_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters.pxd":299
+ * 
+ * 
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t             # <<<<<<<<<<<<<<
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_t;
+
+/* "pcl_filters.pxd":300
+ * 
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZI_t;
+
+/* "pcl_filters.pxd":301
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":302
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ */
+typedef pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":303
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGridPtr_t;
+
+/* "pcl_filters.pxd":304
+ * ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":305
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":306
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ApproximateVoxelGrid<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":422
+ * 
+ * 
+ * ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t             # <<<<<<<<<<<<<<
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_FieldComparison_t;
+
+/* "pcl_filters.pxd":423
+ * 
+ * ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZI_t;
+
+/* "pcl_filters.pxd":424
+ * ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":425
+ * ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ */
+typedef pcl::FieldComparison<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":426
+ * ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_FieldComparisonPtr_t;
+
+/* "pcl_filters.pxd":427
+ * ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":428
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":429
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":430
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_11pcl_filters_FieldComparisonConstPtr_t;
+
+/* "pcl_filters.pxd":431
+ * ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters.pxd":432
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters.pxd":433
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::FieldComparison<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_11pcl_filters_FieldComparison_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters.pxd":542
+ * 
+ * 
+ * ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_ConditionAnd_t;
+
+/* "pcl_filters.pxd":543
+ * 
+ * ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZI_t;
+
+/* "pcl_filters.pxd":544
+ * ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":545
+ * ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ */
+typedef pcl::ConditionAnd<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":546
+ * ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_ConditionAndPtr_t;
+
+/* "pcl_filters.pxd":547
+ * ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":548
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":549
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":550
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_11pcl_filters_ConditionAndConstPtr_t;
+
+/* "pcl_filters.pxd":551
+ * ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters.pxd":552
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters.pxd":553
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionAnd<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_11pcl_filters_ConditionAnd_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters.pxd":568
+ * 
+ * 
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_ConditionOrPtr_t;
+
+/* "pcl_filters.pxd":569
+ * 
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_ConditionOr_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":570
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_ConditionOr_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":571
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_ConditionOr_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":572
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_11pcl_filters_ConditionOrConstPtr_t;
+
+/* "pcl_filters.pxd":573
+ * ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_11pcl_filters_ConditionOr_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters.pxd":574
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_11pcl_filters_ConditionOr_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters.pxd":575
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionOr<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_11pcl_filters_ConditionOr_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters.pxd":617
+ * 
+ * 
+ * ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_t;
+
+/* "pcl_filters.pxd":618
+ * 
+ * ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZI_t;
+
+/* "pcl_filters.pxd":619
+ * ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":620
+ * ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ */
+typedef pcl::ConditionalRemoval<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":621
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZ> >  __pyx_t_3pcl_11pcl_filters_ConditionalRemovalPtr_t;
+
+/* "pcl_filters.pxd":622
+ * ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZI> >  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZI_Ptr_t;
+
+/* "pcl_filters.pxd":623
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZRGB_Ptr_t;
+
+/* "pcl_filters.pxd":624
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZRGBA_Ptr_t;
+
+/* "pcl_filters.pxd":625
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_11pcl_filters_ConditionalRemovalConstPtr_t;
+
+/* "pcl_filters.pxd":626
+ * ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZI_ConstPtr_t;
+
+/* "pcl_filters.pxd":627
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_filters.pxd":628
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::ConditionalRemoval<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_filters.pxd":677
+ * 
+ * 
+ * ctypedef CropBox[cpp.PointXYZ] CropBox_t             # <<<<<<<<<<<<<<
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ */
+typedef pcl::CropBox<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_CropBox_t;
+
+/* "pcl_filters.pxd":678
+ * 
+ * ctypedef CropBox[cpp.PointXYZ] CropBox_t
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ * ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t
+ */
+typedef pcl::CropBox<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_CropBox_PointXYZI_t;
+
+/* "pcl_filters.pxd":679
+ * ctypedef CropBox[cpp.PointXYZ] CropBox_t
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::CropBox<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_CropBox_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":680
+ * ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ * ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ * ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::CropBox<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_CropBox_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":767
+ * 
+ * 
+ * ctypedef CropHull[cpp.PointXYZ] CropHull_t             # <<<<<<<<<<<<<<
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ */
+typedef pcl::CropHull<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_CropHull_t;
+
+/* "pcl_filters.pxd":768
+ * 
+ * ctypedef CropHull[cpp.PointXYZ] CropHull_t
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ * ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t
+ */
+typedef pcl::CropHull<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_CropHull_PointXYZI_t;
+
+/* "pcl_filters.pxd":769
+ * ctypedef CropHull[cpp.PointXYZ] CropHull_t
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::CropHull<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_CropHull_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":770
+ * ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ * ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ * ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::CropHull<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_CropHull_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":887
+ * 
+ * 
+ * ctypedef PassThrough[cpp.PointXYZ] PassThrough_t             # <<<<<<<<<<<<<<
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_PassThrough_t;
+
+/* "pcl_filters.pxd":888
+ * 
+ * ctypedef PassThrough[cpp.PointXYZ] PassThrough_t
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ * ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZI_t;
+
+/* "pcl_filters.pxd":889
+ * ctypedef PassThrough[cpp.PointXYZ] PassThrough_t
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":890
+ * ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ * ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ * ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::PassThrough<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":1004
+ *         bool getCopyAllData ()
+ * 
+ * ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t             # <<<<<<<<<<<<<<
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_ProjectInliers_t;
+
+/* "pcl_filters.pxd":1005
+ * 
+ * ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_ProjectInliers_PointXYZI_t;
+
+/* "pcl_filters.pxd":1006
+ * ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] ProjectInliersPtr_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_ProjectInliers_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":1007
+ * ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ * ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] ProjectInliersPtr_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] ProjectInliers_PointXYZI_Ptr_t
+ */
+typedef pcl::ProjectInliers<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_ProjectInliers_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":1074
+ *         int getMinNeighborsInRadius ()
+ * 
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t             # <<<<<<<<<<<<<<
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_t;
+
+/* "pcl_filters.pxd":1075
+ * 
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_PointXYZI_t;
+
+/* "pcl_filters.pxd":1076
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] RadiusOutlierRemovalPtr_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":1077
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ * ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] RadiusOutlierRemovalPtr_t
+ * # ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] RadiusOutlierRemoval_PointXYZI_Ptr_t
+ */
+typedef pcl::RadiusOutlierRemoval<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":1185
+ * 
+ * 
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t             # <<<<<<<<<<<<<<
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_t;
+
+/* "pcl_filters.pxd":1186
+ * 
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZI_t;
+
+/* "pcl_filters.pxd":1187
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":1188
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ * ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::StatisticalOutlierRemoval<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGBA_t;
+
+/* "pcl_filters.pxd":1456
+ * ###
+ * 
+ * ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t             # <<<<<<<<<<<<<<
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZ>  __pyx_t_3pcl_11pcl_filters_VoxelGrid_t;
+
+/* "pcl_filters.pxd":1457
+ * 
+ * ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZI>  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZI_t;
+
+/* "pcl_filters.pxd":1458
+ * ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZRGB>  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGB_t;
+
+/* "pcl_filters.pxd":1459
+ * ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ * ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef pcl::VoxelGrid<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGBA_t;
+
+/* "pcl_octree_180.pxd":96
+ * 
+ * 
+ * ctypedef OctreeContainerEmpty OctreeContainerEmpty_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreeContainerEmpty] OctreeContainerEmptyPtr_t
+ * ###
+ */
+typedef pcl::octree::OctreeContainerEmpty __pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t;
+
+/* "pcl_octree_180.pxd":97
+ * 
+ * ctypedef OctreeContainerEmpty OctreeContainerEmpty_t
+ * ctypedef shared_ptr[OctreeContainerEmpty] OctreeContainerEmptyPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::octree::OctreeContainerEmpty>  __pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmptyPtr_t;
+
+/* "pcl_octree_180.pxd":161
+ * 
+ * 
+ * ctypedef OctreeContainerPointIndices OctreeContainerPointIndices_t             # <<<<<<<<<<<<<<
+ * # ctypedef shared_ptr[OctreeContainerPointIndices] OctreeContainerPointIndicesPtr_t
+ * ###
+ */
+typedef pcl::octree::OctreeContainerPointIndices __pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t;
+
+/* "pcl_octree_180.pxd":193
+ * 
+ * 
+ * ctypedef OctreePointCloudDensityContainer OctreePointCloudDensityContainer_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudDensityContainer] OctreePointCloudDensityContainerPtr_t
+ * ###
+ */
+typedef pcl::octree::OctreePointCloudDensityContainer __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensityContainer_t;
+
+/* "pcl_octree_180.pxd":194
+ * 
+ * ctypedef OctreePointCloudDensityContainer OctreePointCloudDensityContainer_t
+ * ctypedef shared_ptr[OctreePointCloudDensityContainer] OctreePointCloudDensityContainerPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudDensityContainer>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensityContainerPtr_t;
+
+/* "pcl_octree_180.pxd":358
+ * 
+ * 
+ * ctypedef OctreeBase[int, OctreeContainerEmpty_t] OctreeBase_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreeBase[int, OctreeContainerEmpty_t]] OctreeBasePtr_t
+ * # use OctreePointCloud
+ */
+typedef pcl::octree::OctreeBase<int,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t>  __pyx_t_3pcl_14pcl_octree_180_OctreeBase_t;
+
+/* "pcl_octree_180.pxd":359
+ * 
+ * ctypedef OctreeBase[int, OctreeContainerEmpty_t] OctreeBase_t
+ * ctypedef shared_ptr[OctreeBase[int, OctreeContainerEmpty_t]] OctreeBasePtr_t             # <<<<<<<<<<<<<<
+ * # use OctreePointCloud
+ * ctypedef OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] OctreeBase_OctreeContainerPointIndices_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreeBase<int,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t> >  __pyx_t_3pcl_14pcl_octree_180_OctreeBasePtr_t;
+
+/* "pcl_octree_180.pxd":361
+ * ctypedef shared_ptr[OctreeBase[int, OctreeContainerEmpty_t]] OctreeBasePtr_t
+ * # use OctreePointCloud
+ * ctypedef OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] OctreeBase_OctreeContainerPointIndices_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] OctreeBase_OctreeContainerPointIndicesPtr_t
+ * # use OctreePointCloudDensity
+ */
+typedef pcl::octree::OctreeBase<__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t>  __pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreeContainerPointIndices_t;
+
+/* "pcl_octree_180.pxd":362
+ * # use OctreePointCloud
+ * ctypedef OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] OctreeBase_OctreeContainerPointIndices_t
+ * ctypedef shared_ptr[OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] OctreeBase_OctreeContainerPointIndicesPtr_t             # <<<<<<<<<<<<<<
+ * # use OctreePointCloudDensity
+ * ctypedef OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t] OctreeBase_OctreePointCloudDensity_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreeBase<__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t> >  __pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreeContainerPointIndicesPtr_t;
+
+/* "pcl_octree_180.pxd":364
+ * ctypedef shared_ptr[OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] OctreeBase_OctreeContainerPointIndicesPtr_t
+ * # use OctreePointCloudDensity
+ * ctypedef OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t] OctreeBase_OctreePointCloudDensity_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t]] OctreeBase_OctreePointCloudDensityPtr_t
+ * ###
+ */
+typedef pcl::octree::OctreeBase<__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensityContainer_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t>  __pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreePointCloudDensity_t;
+
+/* "pcl_octree_180.pxd":365
+ * # use OctreePointCloudDensity
+ * ctypedef OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t] OctreeBase_OctreePointCloudDensity_t
+ * ctypedef shared_ptr[OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t]] OctreeBase_OctreePointCloudDensityPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::octree::OctreeBase<__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensityContainer_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t> >  __pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreePointCloudDensityPtr_t;
+
+/* "pcl_octree_180.pxd":604
+ * 
+ * 
+ * ctypedef Octree2BufBase[int, OctreeContainerEmpty_t] Octree2BufBase_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Octree2BufBase[int, OctreeContainerEmpty_t]] Octree2BufBasePtr_t
+ * ctypedef Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] Octree2BufBase_OctreeContainerPointIndices_t
+ */
+typedef pcl::octree::Octree2BufBase<int,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t>  __pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_t;
+
+/* "pcl_octree_180.pxd":605
+ * 
+ * ctypedef Octree2BufBase[int, OctreeContainerEmpty_t] Octree2BufBase_t
+ * ctypedef shared_ptr[Octree2BufBase[int, OctreeContainerEmpty_t]] Octree2BufBasePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] Octree2BufBase_OctreeContainerPointIndices_t
+ * ctypedef shared_ptr[Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] Octree2BufBasePtr_OctreeContainerPointIndicesPtr_t
+ */
+typedef boost::shared_ptr<pcl::octree::Octree2BufBase<int,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t> >  __pyx_t_3pcl_14pcl_octree_180_Octree2BufBasePtr_t;
+
+/* "pcl_octree_180.pxd":606
+ * ctypedef Octree2BufBase[int, OctreeContainerEmpty_t] Octree2BufBase_t
+ * ctypedef shared_ptr[Octree2BufBase[int, OctreeContainerEmpty_t]] Octree2BufBasePtr_t
+ * ctypedef Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] Octree2BufBase_OctreeContainerPointIndices_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] Octree2BufBasePtr_OctreeContainerPointIndicesPtr_t
+ * ###
+ */
+typedef pcl::octree::Octree2BufBase<__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t>  __pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_OctreeContainerPointIndices_t;
+
+/* "pcl_octree_180.pxd":607
+ * ctypedef shared_ptr[Octree2BufBase[int, OctreeContainerEmpty_t]] Octree2BufBasePtr_t
+ * ctypedef Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] Octree2BufBase_OctreeContainerPointIndices_t
+ * ctypedef shared_ptr[Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] Octree2BufBasePtr_OctreeContainerPointIndicesPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::octree::Octree2BufBase<__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t> >  __pyx_t_3pcl_14pcl_octree_180_Octree2BufBasePtr_OctreeContainerPointIndicesPtr_t;
+
+/* "pcl_octree_180.pxd":1260
+ * 
+ * 
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZI_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGB_t
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZ,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_t;
+
+/* "pcl_octree_180.pxd":1261
+ * 
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_t
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGB_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGBA_t
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZI,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZI_t;
+
+/* "pcl_octree_180.pxd":1262
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_t
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZI_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGBA_t
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_t
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZRGB,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZRGB_t;
+
+/* "pcl_octree_180.pxd":1263
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZI_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGB_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_t
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZI_t
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZRGBA,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_OctreeBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZRGBA_t;
+
+/* "pcl_octree_180.pxd":1264
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGB_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGBA_t
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZI_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGB_t
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZ,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_t;
+
+/* "pcl_octree_180.pxd":1265
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGBA_t
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_t
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGB_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGBA_t
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZI,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZI_t;
+
+/* "pcl_octree_180.pxd":1266
+ * ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_t
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZI_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZRGB,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZRGB_t;
+
+/* "pcl_octree_180.pxd":1267
+ * ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZI_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGB_t
+ * ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::octree::OctreePointCloud<struct pcl::PointXYZRGBA,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerPointIndices_t,__pyx_t_3pcl_14pcl_octree_180_OctreeContainerEmpty_t,__pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_OctreeContainerPointIndices_t>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZRGBA_t;
+
+/* "pcl_octree_180.pxd":1290
+ * 
+ * 
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZ] OctreePointCloudChangeDetector_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZI] OctreePointCloudChangeDetector_PointXYZI_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t
+ */
+typedef pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZ>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_t;
+
+/* "pcl_octree_180.pxd":1291
+ * 
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZ] OctreePointCloudChangeDetector_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZI] OctreePointCloudChangeDetector_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t
+ */
+typedef pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZI>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZI_t;
+
+/* "pcl_octree_180.pxd":1292
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZ] OctreePointCloudChangeDetector_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZI] OctreePointCloudChangeDetector_PointXYZI_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t
+ */
+typedef pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZRGB>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGB_t;
+
+/* "pcl_octree_180.pxd":1293
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZI] OctreePointCloudChangeDetector_PointXYZI_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t
+ */
+typedef pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGBA_t;
+
+/* "pcl_octree_180.pxd":1294
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGB]] OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZ> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetectorPtr_t;
+
+/* "pcl_octree_180.pxd":1295
+ * ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGB]] OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGBA]] OctreePointCloudChangeDetector_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZI> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZI_Ptr_t;
+
+/* "pcl_octree_180.pxd":1296
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGB]] OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGBA]] OctreePointCloudChangeDetector_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t;
+
+/* "pcl_octree_180.pxd":1297
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGB]] OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGBA]] OctreePointCloudChangeDetector_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudChangeDetector<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGBA_Ptr_t;
+
+/* "pcl_octree_180.pxd":1315
+ * 
+ * 
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZ] OctreePointCloudDensity_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZI] OctreePointCloudDensity_PointXYZI_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t
+ */
+typedef pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZ>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensity_t;
+
+/* "pcl_octree_180.pxd":1316
+ * 
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZ] OctreePointCloudDensity_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZI] OctreePointCloudDensity_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t
+ */
+typedef pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZI>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensity_PointXYZI_t;
+
+/* "pcl_octree_180.pxd":1317
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZ] OctreePointCloudDensity_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZI] OctreePointCloudDensity_PointXYZI_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t
+ */
+typedef pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZRGB>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensity_PointXYZRGB_t;
+
+/* "pcl_octree_180.pxd":1318
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZI] OctreePointCloudDensity_PointXYZI_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t
+ */
+typedef pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensity_PointXYZRGBA_t;
+
+/* "pcl_octree_180.pxd":1319
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGB]] OctreePointCloudDensity_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZ> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensityPtr_t;
+
+/* "pcl_octree_180.pxd":1320
+ * ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGB]] OctreePointCloudDensity_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGBA]] OctreePointCloudDensity_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZI> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensity_PointXYZI_Ptr_t;
+
+/* "pcl_octree_180.pxd":1321
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGB]] OctreePointCloudDensity_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGBA]] OctreePointCloudDensity_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensity_PointXYZRGB_Ptr_t;
+
+/* "pcl_octree_180.pxd":1322
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGB]] OctreePointCloudDensity_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGBA]] OctreePointCloudDensity_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudDensity<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudDensity_PointXYZRGBA_Ptr_t;
+
+/* "pcl_octree_180.pxd":1431
+ * 
+ * 
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZ] OctreePointCloudSearch_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZI] OctreePointCloudSearch_PointXYZI_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t
+ */
+typedef pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZ>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_t;
+
+/* "pcl_octree_180.pxd":1432
+ * 
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZ] OctreePointCloudSearch_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZI] OctreePointCloudSearch_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t
+ */
+typedef pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZI>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZI_t;
+
+/* "pcl_octree_180.pxd":1433
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZ] OctreePointCloudSearch_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZI] OctreePointCloudSearch_PointXYZI_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t
+ */
+typedef pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZRGB>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGB_t;
+
+/* "pcl_octree_180.pxd":1434
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZI] OctreePointCloudSearch_PointXYZI_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t
+ */
+typedef pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGBA_t;
+
+/* "pcl_octree_180.pxd":1435
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGB]] OctreePointCloudSearch_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZ> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearchPtr_t;
+
+/* "pcl_octree_180.pxd":1436
+ * ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGB]] OctreePointCloudSearch_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGBA]] OctreePointCloudSearch_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZI> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZI_Ptr_t;
+
+/* "pcl_octree_180.pxd":1437
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGB]] OctreePointCloudSearch_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGBA]] OctreePointCloudSearch_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGB_Ptr_t;
+
+/* "pcl_octree_180.pxd":1438
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGB]] OctreePointCloudSearch_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGBA]] OctreePointCloudSearch_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::octree::OctreePointCloudSearch<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGBA_Ptr_t;
+
+/* "pcl_registration_180.pxd":675
+ * 
+ * 
+ * ctypedef IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPoint_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPoint_PointXYZI_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPoint_PointXYZRGB_t
+ */
+typedef pcl::IterativeClosestPoint<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_t;
+
+/* "pcl_registration_180.pxd":676
+ * 
+ * ctypedef IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPoint_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPoint_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPoint_PointXYZRGB_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPoint_PointXYZRGBA_t
+ */
+typedef pcl::IterativeClosestPoint<struct pcl::PointXYZI,struct pcl::PointXYZI,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_PointXYZI_t;
+
+/* "pcl_registration_180.pxd":677
+ * ctypedef IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPoint_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPoint_PointXYZI_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPoint_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPoint_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointPtr_t
+ */
+typedef pcl::IterativeClosestPoint<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_PointXYZRGB_t;
+
+/* "pcl_registration_180.pxd":678
+ * ctypedef IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPoint_PointXYZI_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPoint_PointXYZRGB_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPoint_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointPtr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPoint_PointXYZI_Ptr_t
+ */
+typedef pcl::IterativeClosestPoint<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_PointXYZRGBA_t;
+
+/* "pcl_registration_180.pxd":679
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPoint_PointXYZRGB_t
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPoint_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPoint_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPoint_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPoint<struct pcl::PointXYZ,struct pcl::PointXYZ,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointPtr_t;
+
+/* "pcl_registration_180.pxd":680
+ * ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPoint_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointPtr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPoint_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPoint_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPoint_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPoint<struct pcl::PointXYZI,struct pcl::PointXYZI,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_PointXYZI_Ptr_t;
+
+/* "pcl_registration_180.pxd":681
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointPtr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPoint_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPoint_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPoint_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPoint<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_PointXYZRGB_Ptr_t;
+
+/* "pcl_registration_180.pxd":682
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPoint_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPoint_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPoint_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPoint<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_PointXYZRGBA_Ptr_t;
+
+/* "pcl_registration_180.pxd":714
+ * 
+ * 
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointWithNormals_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointWithNormals_PointXYZI_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointWithNormals_PointXYZRGB_t
+ */
+typedef pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormals_t;
+
+/* "pcl_registration_180.pxd":715
+ * 
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointWithNormals_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointWithNormals_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointWithNormals_PointXYZRGB_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointWithNormals_PointXYZRGBA_t
+ */
+typedef pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZI,struct pcl::PointXYZI,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormals_PointXYZI_t;
+
+/* "pcl_registration_180.pxd":716
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointWithNormals_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointWithNormals_PointXYZI_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointWithNormals_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointWithNormals_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointWithNormalsPtr_t
+ */
+typedef pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormals_PointXYZRGB_t;
+
+/* "pcl_registration_180.pxd":717
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointWithNormals_PointXYZI_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointWithNormals_PointXYZRGB_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointWithNormals_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointWithNormalsPtr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointWithNormals_PointXYZI_Ptr_t
+ */
+typedef pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormals_PointXYZRGBA_t;
+
+/* "pcl_registration_180.pxd":718
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointWithNormals_PointXYZRGB_t
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointWithNormals_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointWithNormalsPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointWithNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointWithNormals_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZ,struct pcl::PointXYZ,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormalsPtr_t;
+
+/* "pcl_registration_180.pxd":719
+ * ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointWithNormals_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointWithNormalsPtr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointWithNormals_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointWithNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointWithNormals_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZI,struct pcl::PointXYZI,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormals_PointXYZI_Ptr_t;
+
+/* "pcl_registration_180.pxd":720
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointWithNormalsPtr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointWithNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointWithNormals_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointWithNormals_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormals_PointXYZRGB_Ptr_t;
+
+/* "pcl_registration_180.pxd":721
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointWithNormals_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointWithNormals_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointWithNormals_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointWithNormals<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointWithNormals_PointXYZRGBA_Ptr_t;
+
+/* "pcl_registration_180.pxd":853
+ * 
+ * 
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] GeneralizedIterativeClosestPoint_t             # <<<<<<<<<<<<<<
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] GeneralizedIterativeClosestPoint_PointXYZI_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t
+ */
+typedef pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZ,struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_t;
+
+/* "pcl_registration_180.pxd":854
+ * 
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] GeneralizedIterativeClosestPoint_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] GeneralizedIterativeClosestPoint_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t
+ */
+typedef pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZI,struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_PointXYZI_t;
+
+/* "pcl_registration_180.pxd":855
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] GeneralizedIterativeClosestPoint_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] GeneralizedIterativeClosestPoint_PointXYZI_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t
+ */
+typedef pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_PointXYZRGB_t;
+
+/* "pcl_registration_180.pxd":856
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] GeneralizedIterativeClosestPoint_PointXYZI_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t
+ */
+typedef pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_PointXYZRGBA_t;
+
+/* "pcl_registration_180.pxd":857
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZ,struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPointPtr_t;
+
+/* "pcl_registration_180.pxd":858
+ * ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] GeneralizedIterativeClosestPoint_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZI,struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t;
+
+/* "pcl_registration_180.pxd":859
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] GeneralizedIterativeClosestPoint_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t;
+
+/* "pcl_registration_180.pxd":860
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] GeneralizedIterativeClosestPoint_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::GeneralizedIterativeClosestPoint<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_PointXYZRGBA_Ptr_t;
+
+/* "pcl_registration_180.pxd":885
+ * 
+ * 
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointNonLinear_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointNonLinear_PointXYZI_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointNonLinear_PointXYZRGB_t
+ */
+typedef pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_t;
+
+/* "pcl_registration_180.pxd":886
+ * 
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointNonLinear_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointNonLinear_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointNonLinear_PointXYZRGB_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointNonLinear_PointXYZRGBA_t
+ */
+typedef pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZI,struct pcl::PointXYZI,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_PointXYZI_t;
+
+/* "pcl_registration_180.pxd":887
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointNonLinear_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointNonLinear_PointXYZI_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointNonLinear_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointNonLinear_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointNonLinearPtr_t
+ */
+typedef pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_PointXYZRGB_t;
+
+/* "pcl_registration_180.pxd":888
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointNonLinear_PointXYZI_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointNonLinear_PointXYZRGB_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointNonLinear_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointNonLinearPtr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t
+ */
+typedef pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA,float>  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_PointXYZRGBA_t;
+
+/* "pcl_registration_180.pxd":889
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointNonLinear_PointXYZRGB_t
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointNonLinear_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointNonLinearPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZ,struct pcl::PointXYZ,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinearPtr_t;
+
+/* "pcl_registration_180.pxd":890
+ * ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointNonLinear_PointXYZRGBA_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointNonLinearPtr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointNonLinear_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZI,struct pcl::PointXYZI,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_PointXYZI_Ptr_t;
+
+/* "pcl_registration_180.pxd":891
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointNonLinearPtr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointNonLinear_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t;
+
+/* "pcl_registration_180.pxd":892
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointNonLinear_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::IterativeClosestPointNonLinear<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA,float> >  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_PointXYZRGBA_Ptr_t;
+
+/* "pcl_registration_180.pxd":3257
+ * 
+ * 
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ] NormalDistributionsTransform_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI] NormalDistributionsTransform_PointXYZI_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB] NormalDistributionsTransform_PointXYZRGB_t
+ */
+typedef pcl::NormalDistributionsTransform<struct pcl::PointXYZ,struct pcl::PointXYZ>  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_t;
+
+/* "pcl_registration_180.pxd":3258
+ * 
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ] NormalDistributionsTransform_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI] NormalDistributionsTransform_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB] NormalDistributionsTransform_PointXYZRGB_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA] NormalDistributionsTransform_PointXYZRGBA_t
+ */
+typedef pcl::NormalDistributionsTransform<struct pcl::PointXYZI,struct pcl::PointXYZI>  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_PointXYZI_t;
+
+/* "pcl_registration_180.pxd":3259
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ] NormalDistributionsTransform_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI] NormalDistributionsTransform_PointXYZI_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB] NormalDistributionsTransform_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA] NormalDistributionsTransform_PointXYZRGBA_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ]] NormalDistributionsTransformPtr_t
+ */
+typedef pcl::NormalDistributionsTransform<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB>  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_PointXYZRGB_t;
+
+/* "pcl_registration_180.pxd":3260
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI] NormalDistributionsTransform_PointXYZI_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB] NormalDistributionsTransform_PointXYZRGB_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA] NormalDistributionsTransform_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ]] NormalDistributionsTransformPtr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI]] NormalDistributionsTransform_PointXYZI_Ptr_t
+ */
+typedef pcl::NormalDistributionsTransform<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA>  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_PointXYZRGBA_t;
+
+/* "pcl_registration_180.pxd":3261
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB] NormalDistributionsTransform_PointXYZRGB_t
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA] NormalDistributionsTransform_PointXYZRGBA_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ]] NormalDistributionsTransformPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI]] NormalDistributionsTransform_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB]] NormalDistributionsTransform_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::NormalDistributionsTransform<struct pcl::PointXYZ,struct pcl::PointXYZ> >  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransformPtr_t;
+
+/* "pcl_registration_180.pxd":3262
+ * ctypedef NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA] NormalDistributionsTransform_PointXYZRGBA_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ]] NormalDistributionsTransformPtr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI]] NormalDistributionsTransform_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB]] NormalDistributionsTransform_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] NormalDistributionsTransform_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::NormalDistributionsTransform<struct pcl::PointXYZI,struct pcl::PointXYZI> >  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_PointXYZI_Ptr_t;
+
+/* "pcl_registration_180.pxd":3263
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ]] NormalDistributionsTransformPtr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI]] NormalDistributionsTransform_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB]] NormalDistributionsTransform_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] NormalDistributionsTransform_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::NormalDistributionsTransform<struct pcl::PointXYZRGB,struct pcl::PointXYZRGB> >  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_PointXYZRGB_Ptr_t;
+
+/* "pcl_registration_180.pxd":3264
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI]] NormalDistributionsTransform_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB]] NormalDistributionsTransform_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] NormalDistributionsTransform_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::NormalDistributionsTransform<struct pcl::PointXYZRGBA,struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_PointXYZRGBA_Ptr_t;
+
+/* "pcl_kdtree_180.pxd":185
+ *         # inline int getMinPts () const
+ * 
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZ>  __pyx_t_3pcl_14pcl_kdtree_180_KdTree_t;
+
+/* "pcl_kdtree_180.pxd":186
+ * 
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZI>  __pyx_t_3pcl_14pcl_kdtree_180_KdTree_PointXYZI_t;
+
+/* "pcl_kdtree_180.pxd":187
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZRGB>  __pyx_t_3pcl_14pcl_kdtree_180_KdTree_PointXYZRGB_t;
+
+/* "pcl_kdtree_180.pxd":188
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_14pcl_kdtree_180_KdTree_PointXYZRGBA_t;
+
+/* "pcl_kdtree_180.pxd":190
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZ> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreePtr_t;
+
+/* "pcl_kdtree_180.pxd":191
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZI> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTree_PointXYZI_Ptr_t;
+
+/* "pcl_kdtree_180.pxd":192
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTree_PointXYZRGB_Ptr_t;
+
+/* "pcl_kdtree_180.pxd":193
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTree_PointXYZRGBA_Ptr_t;
+
+/* "pcl_kdtree_180.pxd":311
+ * ###
+ * 
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZ>  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_t;
+
+/* "pcl_kdtree_180.pxd":312
+ * 
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZI>  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZI_t;
+
+/* "pcl_kdtree_180.pxd":313
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZRGB>  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZRGB_t;
+
+/* "pcl_kdtree_180.pxd":314
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZRGBA_t;
+
+/* "pcl_kdtree_180.pxd":316
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZ> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANNPtr_t;
+
+/* "pcl_kdtree_180.pxd":317
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZI> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZI_Ptr_t;
+
+/* "pcl_kdtree_180.pxd":318
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ * 
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZRGB_Ptr_t;
+
+/* "pcl_kdtree_180.pxd":319
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZRGBA_Ptr_t;
+
+/* "pcl_kdtree_180.pxd":321
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANNConstPtr_t;
+
+/* "pcl_kdtree_180.pxd":322
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZI_ConstPtr_t;
+
+/* "pcl_kdtree_180.pxd":323
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+ * 
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_kdtree_180.pxd":324
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_14pcl_kdtree_180_KdTreeFLANN_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_features_180.pxd":789
+ * 
+ * 
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZ] MomentOfInertiaEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZI] MomentOfInertiaEstimation_PointXYZI_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGB] MomentOfInertiaEstimation_PointXYZRGB_t
+ */
+typedef pcl::MomentOfInertiaEstimation<struct pcl::PointXYZ>  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_t;
+
+/* "pcl_features_180.pxd":790
+ * 
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZ] MomentOfInertiaEstimation_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZI] MomentOfInertiaEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGB] MomentOfInertiaEstimation_PointXYZRGB_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGBA] MomentOfInertiaEstimation_PointXYZRGBA_t
+ */
+typedef pcl::MomentOfInertiaEstimation<struct pcl::PointXYZI>  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_PointXYZI_t;
+
+/* "pcl_features_180.pxd":791
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZ] MomentOfInertiaEstimation_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZI] MomentOfInertiaEstimation_PointXYZI_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGB] MomentOfInertiaEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGBA] MomentOfInertiaEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZ]] MomentOfInertiaEstimationPtr_t
+ */
+typedef pcl::MomentOfInertiaEstimation<struct pcl::PointXYZRGB>  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_PointXYZRGB_t;
+
+/* "pcl_features_180.pxd":792
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZI] MomentOfInertiaEstimation_PointXYZI_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGB] MomentOfInertiaEstimation_PointXYZRGB_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGBA] MomentOfInertiaEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZ]] MomentOfInertiaEstimationPtr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZI]] MomentOfInertiaEstimation_PointXYZI_Ptr_t
+ */
+typedef pcl::MomentOfInertiaEstimation<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_PointXYZRGBA_t;
+
+/* "pcl_features_180.pxd":793
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGB] MomentOfInertiaEstimation_PointXYZRGB_t
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGBA] MomentOfInertiaEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZ]] MomentOfInertiaEstimationPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZI]] MomentOfInertiaEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGB]] MomentOfInertiaEstimation_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::MomentOfInertiaEstimation<struct pcl::PointXYZ> >  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimationPtr_t;
+
+/* "pcl_features_180.pxd":794
+ * ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGBA] MomentOfInertiaEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZ]] MomentOfInertiaEstimationPtr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZI]] MomentOfInertiaEstimation_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGB]] MomentOfInertiaEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGBA]] MomentOfInertiaEstimation_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::MomentOfInertiaEstimation<struct pcl::PointXYZI> >  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_PointXYZI_Ptr_t;
+
+/* "pcl_features_180.pxd":795
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZ]] MomentOfInertiaEstimationPtr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZI]] MomentOfInertiaEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGB]] MomentOfInertiaEstimation_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGBA]] MomentOfInertiaEstimation_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::MomentOfInertiaEstimation<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_PointXYZRGB_Ptr_t;
+
+/* "pcl_features_180.pxd":796
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZI]] MomentOfInertiaEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGB]] MomentOfInertiaEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGBA]] MomentOfInertiaEstimation_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::MomentOfInertiaEstimation<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_PointXYZRGBA_Ptr_t;
+
+/* "pcl_features_180.pxd":1580
+ *         inline void useSensorOriginAsViewPoint ()
+ * 
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimation_t;
+
+/* "pcl_features_180.pxd":1581
+ * 
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimation_PointXYZI_t;
+
+/* "pcl_features_180.pxd":1582
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimation_PointXYZRGB_t;
+
+/* "pcl_features_180.pxd":1583
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimation_PointXYZRGBA_t;
+
+/* "pcl_features_180.pxd":1584
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimationPtr_t;
+
+/* "pcl_features_180.pxd":1585
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimation_PointXYZI_Ptr_t;
+
+/* "pcl_features_180.pxd":1586
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimation_PointXYZRGB_Ptr_t;
+
+/* "pcl_features_180.pxd":1587
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal]) IntegralImageNormalEstimation_PointXYZI_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_180_IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t;
+
+/* "pcl_features_180.pxd":2286
+ *         inline void useSensorOriginAsViewPoint ()
+ * 
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_NormalEstimation_t;
+
+/* "pcl_features_180.pxd":2287
+ * 
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_NormalEstimation_PointXYZI_t;
+
+/* "pcl_features_180.pxd":2288
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_NormalEstimation_PointXYZRGB_t;
+
+/* "pcl_features_180.pxd":2289
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_180_NormalEstimation_PointXYZRGBA_t;
+
+/* "pcl_features_180.pxd":3755
+ * 
+ * 
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZ,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_180_VFHEstimation_t;
+
+/* "pcl_features_180.pxd":3756
+ * 
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZI,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_180_VFHEstimation_PointXYZI_t;
+
+/* "pcl_features_180.pxd":3757
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZRGB,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_180_VFHEstimation_PointXYZRGB_t;
+
+/* "pcl_features_180.pxd":3758
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_180_VFHEstimation_PointXYZRGBA_t;
+
+/* "pcl_kdtree_172.pxd":185
+ *         # inline int getMinPts () const
+ * 
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZ>  __pyx_t_3pcl_14pcl_kdtree_172_KdTree_t;
+
+/* "pcl_kdtree_172.pxd":186
+ * 
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZI>  __pyx_t_3pcl_14pcl_kdtree_172_KdTree_PointXYZI_t;
+
+/* "pcl_kdtree_172.pxd":187
+ * ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZRGB>  __pyx_t_3pcl_14pcl_kdtree_172_KdTree_PointXYZRGB_t;
+
+/* "pcl_kdtree_172.pxd":188
+ * ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ * ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ */
+typedef pcl::search::KdTree<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_14pcl_kdtree_172_KdTree_PointXYZRGBA_t;
+
+/* "pcl_kdtree_172.pxd":190
+ * ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZ> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreePtr_t;
+
+/* "pcl_kdtree_172.pxd":191
+ * 
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZI> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTree_PointXYZI_Ptr_t;
+
+/* "pcl_kdtree_172.pxd":192
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTree_PointXYZRGB_Ptr_t;
+
+/* "pcl_kdtree_172.pxd":193
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::search::KdTree<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTree_PointXYZRGBA_Ptr_t;
+
+/* "pcl_kdtree_172.pxd":311
+ * ###
+ * 
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZ>  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_t;
+
+/* "pcl_kdtree_172.pxd":312
+ * 
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZI>  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZI_t;
+
+/* "pcl_kdtree_172.pxd":313
+ * ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZRGB>  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZRGB_t;
+
+/* "pcl_kdtree_172.pxd":314
+ * ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ */
+typedef pcl::KdTreeFLANN<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZRGBA_t;
+
+/* "pcl_kdtree_172.pxd":316
+ * ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZ> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANNPtr_t;
+
+/* "pcl_kdtree_172.pxd":317
+ * 
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZI> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZI_Ptr_t;
+
+/* "pcl_kdtree_172.pxd":318
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ * 
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZRGB_Ptr_t;
+
+/* "pcl_kdtree_172.pxd":319
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZRGBA_Ptr_t;
+
+/* "pcl_kdtree_172.pxd":321
+ * ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZ>  const >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANNConstPtr_t;
+
+/* "pcl_kdtree_172.pxd":322
+ * 
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZI>  const >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZI_ConstPtr_t;
+
+/* "pcl_kdtree_172.pxd":323
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+ * 
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGB>  const >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZRGB_ConstPtr_t;
+
+/* "pcl_kdtree_172.pxd":324
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ * ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef boost::shared_ptr<pcl::KdTreeFLANN<struct pcl::PointXYZRGBA>  const >  __pyx_t_3pcl_14pcl_kdtree_172_KdTreeFLANN_PointXYZRGBA_ConstPtr_t;
+
+/* "pcl_range_image_172.pxd":856
+ * 
+ * 
+ * ctypedef RangeImage RangeImage_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+ */
+typedef pcl::RangeImage __pyx_t_3pcl_19pcl_range_image_172_RangeImage_t;
+
+/* "pcl_range_image_172.pxd":857
+ * 
+ * ctypedef RangeImage RangeImage_t
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RangeImage>  __pyx_t_3pcl_19pcl_range_image_172_RangeImagePtr_t;
+
+/* "pcl_range_image_172.pxd":858
+ * ctypedef RangeImage RangeImage_t
+ * ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ * ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RangeImage const >  __pyx_t_3pcl_19pcl_range_image_172_RangeImageConstPtr_t;
+
+/* "pcl_range_image_172.pxd":999
+ * 
+ * 
+ * ctypedef RangeImagePlanar RangeImagePlanar_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+ */
+typedef pcl::RangeImagePlanar __pyx_t_3pcl_19pcl_range_image_172_RangeImagePlanar_t;
+
+/* "pcl_range_image_172.pxd":1000
+ * 
+ * ctypedef RangeImagePlanar RangeImagePlanar_t
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::RangeImagePlanar>  __pyx_t_3pcl_19pcl_range_image_172_RangeImagePlanarPtr_t;
+
+/* "pcl_range_image_172.pxd":1001
+ * ctypedef RangeImagePlanar RangeImagePlanar_t
+ * ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ * ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::RangeImagePlanar const >  __pyx_t_3pcl_19pcl_range_image_172_RangeImagePlanarConstPtr_t;
+
+/* "pcl_features_172.pxd":1582
+ *         inline void useSensorOriginAsViewPoint ()
+ * 
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimation_t;
+
+/* "pcl_features_172.pxd":1583
+ * 
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimation_PointXYZI_t;
+
+/* "pcl_features_172.pxd":1584
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimation_PointXYZRGB_t;
+
+/* "pcl_features_172.pxd":1585
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ */
+typedef pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimation_PointXYZRGBA_t;
+
+/* "pcl_features_172.pxd":1586
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimationPtr_t;
+
+/* "pcl_features_172.pxd":1587
+ * ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimation_PointXYZI_Ptr_t;
+
+/* "pcl_features_172.pxd":1588
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimation_PointXYZRGB_Ptr_t;
+
+/* "pcl_features_172.pxd":1589
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+ * # ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal]) IntegralImageNormalEstimation_PointXYZI_t
+ */
+typedef boost::shared_ptr<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal> >  __pyx_t_3pcl_16pcl_features_172_IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t;
+
+/* "pcl_features_172.pxd":2288
+ *         inline void useSensorOriginAsViewPoint ()
+ * 
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_NormalEstimation_t;
+
+/* "pcl_features_172.pxd":2289
+ * 
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_NormalEstimation_PointXYZI_t;
+
+/* "pcl_features_172.pxd":2290
+ * ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+ * 
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZRGB,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_NormalEstimation_PointXYZRGB_t;
+
+/* "pcl_features_172.pxd":2291
+ * ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ * ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+typedef pcl::NormalEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal>  __pyx_t_3pcl_16pcl_features_172_NormalEstimation_PointXYZRGBA_t;
+
+/* "pcl_features_172.pxd":3757
+ * 
+ * 
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZ,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_172_VFHEstimation_t;
+
+/* "pcl_features_172.pxd":3758
+ * 
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZI,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_172_VFHEstimation_PointXYZI_t;
+
+/* "pcl_features_172.pxd":3759
+ * ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+ * ###
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZRGB,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_172_VFHEstimation_PointXYZRGB_t;
+
+/* "pcl_features_172.pxd":3760
+ * ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ * ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef pcl::VFHEstimation<struct pcl::PointXYZRGBA,struct pcl::Normal,struct pcl::VFHSignature308>  __pyx_t_3pcl_16pcl_features_172_VFHEstimation_PointXYZRGBA_t;
+
+/* "pcl_keypoints_180.pxd":149
+ * 
+ * 
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_t             # <<<<<<<<<<<<<<
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZI_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t
+ */
+typedef pcl::HarrisKeypoint3D<struct pcl::PointXYZ,struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_t;
+
+/* "pcl_keypoints_180.pxd":150
+ * 
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t
+ */
+typedef pcl::HarrisKeypoint3D<struct pcl::PointXYZI,struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_PointXYZI_t;
+
+/* "pcl_keypoints_180.pxd":151
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZI_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t
+ */
+typedef pcl::HarrisKeypoint3D<struct pcl::PointXYZRGB,struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_PointXYZRGB_t;
+
+/* "pcl_keypoints_180.pxd":152
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZI_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t
+ */
+typedef pcl::HarrisKeypoint3D<struct pcl::PointXYZRGBA,struct pcl::PointXYZI,struct pcl::Normal>  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_PointXYZRGBA_t;
+
+/* "pcl_keypoints_180.pxd":153
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::HarrisKeypoint3D<struct pcl::PointXYZ,struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3DPtr_t;
+
+/* "pcl_keypoints_180.pxd":154
+ * ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::HarrisKeypoint3D<struct pcl::PointXYZI,struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_PointXYZI_Ptr_t;
+
+/* "pcl_keypoints_180.pxd":155
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::HarrisKeypoint3D<struct pcl::PointXYZRGB,struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_PointXYZRGB_Ptr_t;
+
+/* "pcl_keypoints_180.pxd":156
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::HarrisKeypoint3D<struct pcl::PointXYZRGBA,struct pcl::PointXYZI,struct pcl::Normal> >  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_PointXYZRGBA_Ptr_t;
+
+/* "pcl_keypoints_180.pxd":256
+ * # inline std::ostream& operator << (std::ostream& os, const NarfKeypoint::Parameters& p)
+ * 
+ * ctypedef NarfKeypoint NarfKeypoint_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[NarfKeypoint] NarfKeypointPtr_t
+ * ###
+ */
+typedef pcl::NarfKeypoint __pyx_t_3pcl_17pcl_keypoints_180_NarfKeypoint_t;
+
+/* "pcl_keypoints_180.pxd":257
+ * 
+ * ctypedef NarfKeypoint NarfKeypoint_t
+ * ctypedef shared_ptr[NarfKeypoint] NarfKeypointPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::NarfKeypoint>  __pyx_t_3pcl_17pcl_keypoints_180_NarfKeypointPtr_t;
+
+/* "pcl_keypoints_180.pxd":279
+ * 
+ * # pcl::SIFTKeypoint<pcl::PointNormal, pcl::PointWithScale> sift;
+ * ctypedef SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale] SIFTKeypoint_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale]] SIFTKeypointPtr_t
+ * ###
+ */
+typedef pcl::SIFTKeypoint<struct pcl::PointNormal,struct pcl::PointWithScale>  __pyx_t_3pcl_17pcl_keypoints_180_SIFTKeypoint_t;
+
+/* "pcl_keypoints_180.pxd":280
+ * # pcl::SIFTKeypoint<pcl::PointNormal, pcl::PointWithScale> sift;
+ * ctypedef SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale] SIFTKeypoint_t
+ * ctypedef shared_ptr[SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale]] SIFTKeypointPtr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::SIFTKeypoint<struct pcl::PointNormal,struct pcl::PointWithScale> >  __pyx_t_3pcl_17pcl_keypoints_180_SIFTKeypointPtr_t;
+
+/* "pcl_keypoints_180.pxd":319
+ * 
+ * 
+ * ctypedef UniformSampling[cpp.PointXYZ] UniformSampling_t             # <<<<<<<<<<<<<<
+ * ctypedef UniformSampling[cpp.PointXYZI] UniformSampling_PointXYZI_t
+ * ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t
+ */
+typedef pcl::UniformSampling<struct pcl::PointXYZ>  __pyx_t_3pcl_17pcl_keypoints_180_UniformSampling_t;
+
+/* "pcl_keypoints_180.pxd":320
+ * 
+ * ctypedef UniformSampling[cpp.PointXYZ] UniformSampling_t
+ * ctypedef UniformSampling[cpp.PointXYZI] UniformSampling_PointXYZI_t             # <<<<<<<<<<<<<<
+ * ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t
+ * ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t
+ */
+typedef pcl::UniformSampling<struct pcl::PointXYZI>  __pyx_t_3pcl_17pcl_keypoints_180_UniformSampling_PointXYZI_t;
+
+/* "pcl_keypoints_180.pxd":321
+ * ctypedef UniformSampling[cpp.PointXYZ] UniformSampling_t
+ * ctypedef UniformSampling[cpp.PointXYZI] UniformSampling_PointXYZI_t
+ * ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t             # <<<<<<<<<<<<<<
+ * ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t
+ */
+typedef pcl::UniformSampling<struct pcl::PointXYZRGB>  __pyx_t_3pcl_17pcl_keypoints_180_UniformSampling_PointXYZRGB_t;
+
+/* "pcl_keypoints_180.pxd":322
+ * ctypedef UniformSampling[cpp.PointXYZI] UniformSampling_PointXYZI_t
+ * ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t
+ * ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t
+ */
+typedef pcl::UniformSampling<struct pcl::PointXYZRGBA>  __pyx_t_3pcl_17pcl_keypoints_180_UniformSampling_PointXYZRGBA_t;
+
+/* "pcl_keypoints_180.pxd":323
+ * ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t
+ * ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGB]] UniformSampling_PointXYZRGB_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::UniformSampling<struct pcl::PointXYZ> >  __pyx_t_3pcl_17pcl_keypoints_180_UniformSamplingPtr_t;
+
+/* "pcl_keypoints_180.pxd":324
+ * ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGB]] UniformSampling_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGBA]] UniformSampling_PointXYZRGBA_Ptr_t
+ */
+typedef boost::shared_ptr<pcl::UniformSampling<struct pcl::PointXYZI> >  __pyx_t_3pcl_17pcl_keypoints_180_UniformSampling_PointXYZI_Ptr_t;
+
+/* "pcl_keypoints_180.pxd":325
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGB]] UniformSampling_PointXYZRGB_Ptr_t             # <<<<<<<<<<<<<<
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGBA]] UniformSampling_PointXYZRGBA_Ptr_t
+ * ###
+ */
+typedef boost::shared_ptr<pcl::UniformSampling<struct pcl::PointXYZRGB> >  __pyx_t_3pcl_17pcl_keypoints_180_UniformSampling_PointXYZRGB_Ptr_t;
+
+/* "pcl_keypoints_180.pxd":326
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGB]] UniformSampling_PointXYZRGB_Ptr_t
+ * ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGBA]] UniformSampling_PointXYZRGBA_Ptr_t             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+typedef boost::shared_ptr<pcl::UniformSampling<struct pcl::PointXYZRGBA> >  __pyx_t_3pcl_17pcl_keypoints_180_UniformSampling_PointXYZRGBA_Ptr_t;
+struct __pyx_opt_args_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run;
+struct __pyx_opt_args_3pcl_4_pcl_21IterativeClosestPoint_run;
+struct __pyx_opt_args_3pcl_4_pcl_30IterativeClosestPointNonLinear_run;
+struct __pyx_ctuple_float__and_float__and_float__and_float__and_float__and_float;
+typedef struct __pyx_ctuple_float__and_float__and_float__and_float__and_float__and_float __pyx_ctuple_float__and_float__and_float__and_float__and_float__and_float;
+
+/* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":24
+ *         del self.me
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         # 1.6.0 NG(No descrription)
+ *         # reg.setInputSource(source.thisptr_shared)
+ */
+struct __pyx_opt_args_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run {
+  int __pyx_n;
+  PyObject *max_iter;
+};
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":54
+ *     #     return self.me.getFinalNumIteration()
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ */
+struct __pyx_opt_args_3pcl_4_pcl_21IterativeClosestPoint_run {
+  int __pyx_n;
+  PyObject *max_iter;
+};
+
+/* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":24
+ *         del self.me
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         # 1.6.0 NG(No descrription)
+ *         # reg.setInputSource(source.thisptr_shared)
+ */
+struct __pyx_opt_args_3pcl_4_pcl_30IterativeClosestPointNonLinear_run {
+  int __pyx_n;
+  PyObject *max_iter;
+};
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":119
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z             # <<<<<<<<<<<<<<
+ * 
+ *     def to_list(self):
+ */
+struct __pyx_ctuple_float__and_float__and_float__and_float__and_float__and_float {
+  float f0;
+  float f1;
+  float f2;
+  float f3;
+  float f4;
+  float f5;
+};
+
+/* "pcl/_pcl.pxd":15
+ * 
+ * # class override(PointCloud)
+ * cdef class PointCloud:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloudPtr_t thisptr_shared     # XYZ
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_PointCloud {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_PointCloudPtr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":28
+ * 
+ * # class override(PointCloud_PointXYZI)
+ * cdef class PointCloud_PointXYZI:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloud_PointXYZI_Ptr_t thisptr_shared     # XYZI
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZI_Ptr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":41
+ * 
+ * # class override(PointCloud_PointXYZRGB)
+ * cdef class PointCloud_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloud_PointXYZRGB_Ptr_t thisptr_shared
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGB_Ptr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":54
+ * 
+ * # class override(PointCloud_PointXYZRGBA)
+ * cdef class PointCloud_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloud_PointXYZRGBA_Ptr_t thisptr_shared   # XYZRGBA
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGBA_Ptr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":66
+ * 
+ * # class override
+ * cdef class Vertices:             # <<<<<<<<<<<<<<
+ *     cdef cpp.VerticesPtr_t thisptr_shared     # Vertices
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_Vertices {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_Vertices *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_VerticesPtr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":78
+ * 
+ * # class override(PointCloud_PointWithViewpoint)
+ * cdef class PointCloud_PointWithViewpoint:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloud_PointWithViewpoint_Ptr_t thisptr_shared   # PointWithViewpoint
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_PointWithViewpoint_Ptr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":91
+ * 
+ * # class override(PointCloud_Normal)
+ * cdef class PointCloud_Normal:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloud_Normal_Ptr_t thisptr_shared   # Normal
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_Normal *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_Ptr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":104
+ * 
+ * # class override(PointCloud_PointNormal)
+ * cdef class PointCloud_PointNormal:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloud_PointNormal_Ptr_t thisptr_shared   # PointNormal
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointNormal *__pyx_vtab;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_PointNormal_Ptr_t thisptr_shared;
+  Py_ssize_t _shape[2];
+  Py_ssize_t _view_count;
+};
+
+
+/* "pcl/_pcl.pxd":118
+ * ## KdTree
+ * # class override
+ * cdef class KdTree:             # <<<<<<<<<<<<<<
+ *     cdef pclkdt.KdTreePtr_t thisptr_shared   # KdTree
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_KdTree {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_KdTree *__pyx_vtab;
+  __pyx_t_3pcl_10pcl_kdtree_KdTreePtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":135
+ * ## RangeImages
+ * # class override
+ * cdef class RangeImages:             # <<<<<<<<<<<<<<
+ *     cdef pcl_rngimg.RangeImagePtr_t thisptr_shared   # RangeImages
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_RangeImages {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_RangeImages *__pyx_vtab;
+  __pyx_t_3pcl_15pcl_range_image_RangeImagePtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":145
+ * ### Features
+ * # class override
+ * cdef class IntegralImageNormalEstimation:             # <<<<<<<<<<<<<<
+ *     cdef pcl_ftr.IntegralImageNormalEstimationPtr_t thisptr_shared     # IntegralImageNormalEstimation
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_vtab;
+  __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimationPtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":155
+ * ## SampleConsensus
+ * # class override
+ * cdef class SampleConsensusModel:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelPtr_t thisptr_shared     # SampleConsensusModel
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModel *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":162
+ *         return self.thisptr_shared.get()
+ * 
+ * cdef class SampleConsensusModelPlane:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelPlanePtr_t thisptr_shared     # SampleConsensusModelPlane
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlanePtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":169
+ *         return self.thisptr_shared.get()
+ * 
+ * cdef class SampleConsensusModelSphere:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelSpherePtr_t thisptr_shared     # SampleConsensusModelSphere
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSpherePtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":176
+ *         return self.thisptr_shared.get()
+ * 
+ * cdef class SampleConsensusModelCylinder:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelCylinderPtr_t thisptr_shared     # SampleConsensusModelSphere
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelCylinder *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinderPtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":183
+ *         return self.thisptr_shared.get()
+ * 
+ * cdef class SampleConsensusModelLine:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelLinePtr_t thisptr_shared     # SampleConsensusModelLine
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelLine *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLinePtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":190
+ *         return self.thisptr_shared.get()
+ * 
+ * cdef class SampleConsensusModelRegistration:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelRegistrationPtr_t thisptr_shared     # SampleConsensusModelRegistration
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelRegistration *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistrationPtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl.pxd":197
+ *         return self.thisptr_shared.get()
+ * 
+ * cdef class SampleConsensusModelStick:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelStickPtr_t thisptr_shared     # SampleConsensusModelStick
+ * 
+ */
+struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelStick *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStickPtr_t thisptr_shared;
+};
+
+
+/* "pcl/_pcl_180.pyx":68
+ * # CythonCompareOp
+ * @cython.internal
+ * cdef class _CythonCompareOp_Type:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         readonly int GT
+ */
+struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type {
+  PyObject_HEAD
+  int GT;
+  int GE;
+  int LT;
+  int LE;
+  int EQ;
+};
+
+
+/* "pcl/_pcl_180.pyx":89
+ * # CythonCoordinateFrame
+ * @cython.internal
+ * cdef class _CythonCoordinateFrame_Type:             # <<<<<<<<<<<<<<
+ *     cdef:
+ *         readonly int CAMERA_FRAME
+ */
+struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type {
+  PyObject_HEAD
+  int CAMERA_FRAME;
+  int LASER_FRAME;
+};
+
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":6
+ * cimport pcl_defs as cpp
+ * 
+ * cdef class Segmentation:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models
+ */
+struct __pyx_obj_3pcl_4_pcl_Segmentation {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":35
+ *         self.me.setMaxIterations (count)
+ * 
+ * cdef class Segmentation_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models
+ */
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":63
+ * 
+ * 
+ * cdef class Segmentation_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models
+ */
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":91
+ * 
+ * 
+ * cdef class Segmentation_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models
+ */
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":18
+ * #yeah, I can't be bothered making this inherit from SACSegmentation, I forget the rules
+ * #for how this works in cython templated extension types anyway
+ * cdef class SegmentationNormal:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models that require the
+ */
+struct __pyx_obj_3pcl_4_pcl_SegmentationNormal {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":71
+ * 
+ * 
+ * cdef class Segmentation_PointXYZI_Normal:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models that require the
+ */
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":124
+ * 
+ * 
+ * cdef class Segmentation_PointXYZRGB_Normal:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models that require the
+ */
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":177
+ * 
+ * 
+ * cdef class Segmentation_PointXYZRGBA_Normal:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for Sample Consensus methods and models that require the
+ */
+struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":7
+ * from libcpp.vector cimport vector
+ * 
+ * cdef class EuclideanClusterExtraction:             # <<<<<<<<<<<<<<
+ *     """
+ *     Segmentation class for EuclideanClusterExtraction
+ */
+struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_t *me;
+};
+
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":5
+ * cimport pcl_filters as pclfil
+ * 
+ * cdef class StatisticalOutlierRemovalFilter:             # <<<<<<<<<<<<<<
+ *     """
+ *     Filter class uses point neighborhood statistics to filter outlier data.
+ */
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_t *me;
+};
+
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":67
+ * 
+ * 
+ * cdef class StatisticalOutlierRemovalFilter_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Filter class uses point neighborhood statistics to filter outlier data.
+ */
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":129
+ * 
+ * 
+ * cdef class StatisticalOutlierRemovalFilter_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Filter class uses point neighborhood statistics to filter outlier data.
+ */
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":191
+ * 
+ * 
+ * cdef class StatisticalOutlierRemovalFilter_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Filter class uses point neighborhood statistics to filter outlier data.
+ */
+struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":5
+ * cimport pcl_filters_180 as pclfil
+ * 
+ * cdef class VoxelGridFilter:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_t *me;
+};
+
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":30
+ *         return pc
+ * 
+ * cdef class VoxelGridFilter_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":55
+ *         return pc
+ * 
+ * cdef class VoxelGridFilter_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":80
+ *         return pc
+ * 
+ * cdef class VoxelGridFilter_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":5
+ * cimport pcl_filters_180 as pclfil
+ * 
+ * cdef class PassThroughFilter:             # <<<<<<<<<<<<<<
+ *     """
+ *     Passes points in a cloud based on constraints for one particular field of the point type
+ */
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_PassThrough_t *me;
+};
+
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":42
+ * 
+ * 
+ * cdef class PassThroughFilter_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Passes points in a cloud based on constraints for one particular field of the point type
+ */
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":76
+ * 
+ * 
+ * cdef class PassThroughFilter_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Passes points in a cloud based on constraints for one particular field of the point type
+ */
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":110
+ * 
+ * 
+ * cdef class PassThroughFilter_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Passes points in a cloud based on constraints for one particular field of the point type
+ */
+struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":5
+ * cimport pcl_filters as pclfil
+ * 
+ * cdef class ApproximateVoxelGrid:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_t *me;
+};
+
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":35
+ *         return pc
+ * 
+ * cdef class ApproximateVoxelGrid_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":64
+ *         return pc
+ * 
+ * cdef class ApproximateVoxelGrid_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":92
+ *         return pc
+ * 
+ * cdef class ApproximateVoxelGrid_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+ */
+struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":7
+ * cimport pcl_kdtree as pclkdt
+ * 
+ * cdef class MovingLeastSquares:             # <<<<<<<<<<<<<<
+ *     """
+ *     Smoothing class which is an implementation of the MLS (Moving Least Squares)
+ */
+struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_t *me;
+};
+
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":105
+ * 
+ * 
+ * cdef class MovingLeastSquares_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Smoothing class which is an implementation of the MLS (Moving Least Squares)
+ */
+struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":149
+ *         # return pcNormal
+ * 
+ * cdef class MovingLeastSquares_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Smoothing class which is an implementation of the MLS (Moving Least Squares)
+ */
+struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":5
+ * cimport pcl_kdtree as pclkdt
+ * 
+ * cdef class KdTreeFLANN:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN *__pyx_vtab;
+  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_t *me;
+};
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":101
+ *             ind[i] = radius_indices[i]
+ * 
+ * cdef class KdTreeFLANN_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_vtab;
+  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":165
+ * 
+ * 
+ * cdef class KdTreeFLANN_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_vtab;
+  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":229
+ * 
+ * 
+ * cdef class KdTreeFLANN_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_vtab;
+  __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":7
+ * cimport eigen as eig
+ * 
+ * cdef class OctreePointCloud:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":88
+ * 
+ * 
+ * cdef class OctreePointCloud_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":170
+ * 
+ * 
+ * cdef class OctreePointCloud_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":248
+ * 
+ * 
+ * cdef class OctreePointCloud_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":7
+ * cimport eigen as eig
+ * 
+ * cdef class OctreePointCloud2Buf:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":85
+ * 
+ * 
+ * cdef class OctreePointCloud2Buf_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":164
+ * 
+ * 
+ * cdef class OctreePointCloud2Buf_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":239
+ * 
+ * 
+ * cdef class OctreePointCloud2Buf_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":8
+ * # include "OctreePointCloud.pxi"
+ * 
+ * cdef class OctreePointCloudSearch(OctreePointCloud):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud search
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud __pyx_base;
+  struct __pyx_vtabstruct_3pcl_4_pcl_OctreePointCloudSearch *__pyx_vtab;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_t *me2;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":224
+ * 
+ * 
+ * cdef class OctreePointCloudSearch_PointXYZI(OctreePointCloud_PointXYZI):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud search
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI __pyx_base;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZI_t *me2;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":305
+ *         self.me2.deleteVoxelAtPoint(to_point2_t(point))
+ * 
+ * cdef class OctreePointCloudSearch_PointXYZRGB(OctreePointCloud_PointXYZRGB):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud search
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB __pyx_base;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGB_t *me2;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":387
+ * 
+ * 
+ * cdef class OctreePointCloudSearch_PointXYZRGBA(OctreePointCloud_PointXYZRGBA):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud search
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA __pyx_base;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGBA_t *me2;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":5
+ * cimport pcl_octree_180 as pcloct
+ * 
+ * cdef class OctreePointCloudChangeDetector(OctreePointCloud2Buf):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud ChangeDetector
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf __pyx_base;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_t *me2;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":76
+ * 
+ * 
+ * cdef class OctreePointCloudChangeDetector_PointXYZI(OctreePointCloud2Buf_PointXYZI):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud ChangeDetector
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI __pyx_base;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZI_t *me2;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":145
+ * 
+ * 
+ * cdef class OctreePointCloudChangeDetector_PointXYZRGB(OctreePointCloud2Buf_PointXYZRGB):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud ChangeDetector
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB __pyx_base;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGB_t *me2;
+};
+
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":214
+ * 
+ * 
+ * cdef class OctreePointCloudChangeDetector_PointXYZRGBA(OctreePointCloud2Buf_PointXYZRGBA):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud ChangeDetector
+ */
+struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA __pyx_base;
+  __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGBA_t *me2;
+};
+
+
+/* "pcl/pxi/Filters/CropHull_180.pxi":10
+ * from boost_shared_ptr cimport shared_ptr
+ * 
+ * cdef class CropHull:             # <<<<<<<<<<<<<<
+ *     """
+ *     Must be constructed from the reference point cloud, which is copied,
+ */
+struct __pyx_obj_3pcl_4_pcl_CropHull {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_CropHull_t *me;
+};
+
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":12
+ * from boost_shared_ptr cimport shared_ptr
+ * 
+ * cdef class CropBox:             # <<<<<<<<<<<<<<
+ *     """
+ *     Must be constructed from the reference point cloud, which is copied, so
+ */
+struct __pyx_obj_3pcl_4_pcl_CropBox {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_CropBox_t *me;
+};
+
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":6
+ * cimport pcl_defs as cpp
+ * 
+ * cdef class ProjectInliers:             # <<<<<<<<<<<<<<
+ *     """
+ *     ProjectInliers class for ...
+ */
+struct __pyx_obj_3pcl_4_pcl_ProjectInliers {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_ProjectInliers_t *me;
+};
+
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":9
+ * cimport pcl_segmentation_180 as pclseg
+ * 
+ * cdef class RadiusOutlierRemoval:             # <<<<<<<<<<<<<<
+ *     """
+ *     RadiusOutlierRemoval class for ...
+ */
+struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_t *me;
+};
+
+
+/* "pcl/pxi/Filters/ConditionAnd.pxi":14
+ * 
+ * # cdef class ConditionAnd(ConditionBase):
+ * cdef class ConditionAnd:             # <<<<<<<<<<<<<<
+ *     """
+ *     Must be constructed from the reference point cloud, which is copied, so
+ */
+struct __pyx_obj_3pcl_4_pcl_ConditionAnd {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_ConditionAnd_t *me;
+};
+
+
+/* "pcl/pxi/Filters/ConditionalRemoval.pxi":12
+ * from boost_shared_ptr cimport shared_ptr
+ * 
+ * cdef class ConditionalRemoval:             # <<<<<<<<<<<<<<
+ *     """
+ *     Must be constructed from the reference point cloud, which is copied, so
+ */
+struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_t *me;
+};
+
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":5
+ * cimport pcl_defs as cpp
+ * 
+ * cdef class ConcaveHull:             # <<<<<<<<<<<<<<
+ *     """
+ *     ConcaveHull class for ...
+ */
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_surface_ConcaveHull_t *me;
+};
+
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":27
+ *         self.me.setAlpha (d)
+ * 
+ * cdef class ConcaveHull_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     ConcaveHull class for ...
+ */
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZI_t *me;
+};
+
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":50
+ * 
+ * 
+ * cdef class ConcaveHull_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     ConcaveHull class for ...
+ */
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZRGB_t *me;
+};
+
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":73
+ * 
+ * 
+ * cdef class ConcaveHull_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     ConcaveHull class for ...
+ */
+struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA {
+  PyObject_HEAD
+  __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZRGBA_t *me;
+};
+
+
+/* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":12
+ * np.import_array()
+ * 
+ * cdef class GeneralizedIterativeClosestPoint:             # <<<<<<<<<<<<<<
+ *     """
+ *     Registration class for GeneralizedIterativeClosestPoint
+ */
+struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_t *me;
+};
+
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":16
+ * np.import_array()
+ * 
+ * cdef class IterativeClosestPoint:             # <<<<<<<<<<<<<<
+ *     """
+ *     Registration class for IterativeClosestPoint
+ */
+struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPoint *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_t *me;
+};
+
+
+/* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":12
+ * np.import_array()
+ * 
+ * cdef class IterativeClosestPointNonLinear:             # <<<<<<<<<<<<<<
+ *     """
+ *     Registration class for IterativeClosestPointNonLinear
+ */
+struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear {
+  PyObject_HEAD
+  struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_vtab;
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_t *me;
+};
+
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":8
+ * 
+ * 
+ * cdef class RandomSampleConsensus:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_t *me;
+};
+
+
+/* "pcl/pxi/Features/NormalEstimation_180.pxi":10
+ * 
+ * 
+ * cdef class NormalEstimation:             # <<<<<<<<<<<<<<
+ *     """
+ *     NormalEstimation class for
+ */
+struct __pyx_obj_3pcl_4_pcl_NormalEstimation {
+  PyObject_HEAD
+  __pyx_t_3pcl_16pcl_features_180_NormalEstimation_t *me;
+};
+
+
+/* "pcl/pxi/Features/VFHEstimation_180.pxi":10
+ * 
+ * 
+ * cdef class VFHEstimation:             # <<<<<<<<<<<<<<
+ *     """
+ *     VFHEstimation class for
+ */
+struct __pyx_obj_3pcl_4_pcl_VFHEstimation {
+  PyObject_HEAD
+  __pyx_t_3pcl_16pcl_features_180_VFHEstimation_t *me;
+};
+
+
+/* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":9
+ * 
+ * 
+ * cdef class MomentOfInertiaEstimation:             # <<<<<<<<<<<<<<
+ *     """
+ *     MomentOfInertiaEstimation class for
+ */
+struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation {
+  PyObject_HEAD
+  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_t *me;
+};
+
+
+/* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":22
+ * ### base class ###
+ * 
+ * cdef class HarrisKeypoint3D:             # <<<<<<<<<<<<<<
+ *     """
+ *     HarrisKeypoint3D class for
+ */
+struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D {
+  PyObject_HEAD
+  __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_t *me;
+};
+
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":6
+ * cimport pcl_registration_180 as pclreg
+ * 
+ * cdef class NormalDistributionsTransform:             # <<<<<<<<<<<<<<
+ *     """
+ *     Registration class for NormalDistributionsTransform
+ */
+struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform {
+  PyObject_HEAD
+  __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_t *me;
+};
+
+
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":54
+ * _pc_tmp = None
+ * 
+ * cdef class PointCloud:             # <<<<<<<<<<<<<<
+ *     """Represents a cloud of points in 3-d space.
+ * 
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud {
+  pcl::PointCloud<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_PointCloud *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud *__pyx_vtabptr_3pcl_4_pcl_PointCloud;
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud *);
+
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":45
+ * _pc_xyzi_tmp4 = None
+ * 
+ * cdef class PointCloud_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """Represents a cloud of points in 3-d space.
+ * 
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZI {
+  pcl::PointCloud<struct pcl::PointXYZI>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZI;
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZI>  *__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *);
+
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":45
+ * _pc_xyzrgb_tmp3 = None
+ * 
+ * cdef class PointCloud_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """Represents a cloud of points in 3-d space.
+ * 
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGB {
+  pcl::PointCloud<struct pcl::PointXYZRGB>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGB;
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZRGB>  *__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *);
+
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":45
+ * _pc_xyzrgba_tmp2 = None
+ * 
+ * cdef class PointCloud_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """Represents a cloud of points in 3-d space.
+ * 
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGBA {
+  pcl::PointCloud<struct pcl::PointXYZRGBA>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGBA;
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZRGBA>  *__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *);
+
+
+/* "pcl/pxi/Vertices.pxi":6
+ * cimport numpy as cnp
+ * 
+ * cdef class Vertices:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_Vertices {
+  pcl::Vertices *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_Vertices *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_Vertices *__pyx_vtabptr_3pcl_4_pcl_Vertices;
+static CYTHON_INLINE pcl::Vertices *__pyx_f_3pcl_4_pcl_8Vertices_thisptr(struct __pyx_obj_3pcl_4_pcl_Vertices *);
+
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":9
+ * from boost_shared_ptr cimport sp_assign
+ * 
+ * cdef class PointCloud_PointWithViewpoint:             # <<<<<<<<<<<<<<
+ *     """
+ *     Represents a cloud of points in 6-d space.
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointWithViewpoint {
+  pcl::PointCloud<struct pcl::PointWithViewpoint>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_vtabptr_3pcl_4_pcl_PointCloud_PointWithViewpoint;
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointWithViewpoint>  *__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *);
+
+
+/* "pcl/_pcl.pxd":91
+ * 
+ * # class override(PointCloud_Normal)
+ * cdef class PointCloud_Normal:             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointCloud_Normal_Ptr_t thisptr_shared   # Normal
+ * 
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_Normal {
+  pcl::PointCloud<struct pcl::Normal>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_Normal *__pyx_vtabptr_3pcl_4_pcl_PointCloud_Normal;
+static CYTHON_INLINE pcl::PointCloud<struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_17PointCloud_Normal_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *);
+
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":13
+ * from _pcl cimport PointCloud_PointNormal
+ * 
+ * cdef class PointCloud_PointNormal:             # <<<<<<<<<<<<<<
+ *     """
+ *     Represents a cloud of points in 4-d space.
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointNormal {
+  pcl::PointCloud<struct pcl::PointNormal>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointNormal *__pyx_vtabptr_3pcl_4_pcl_PointCloud_PointNormal;
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointNormal>  *__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *);
+
+
+/* "pcl/_pcl.pxd":118
+ * ## KdTree
+ * # class override
+ * cdef class KdTree:             # <<<<<<<<<<<<<<
+ *     cdef pclkdt.KdTreePtr_t thisptr_shared   # KdTree
+ * 
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_KdTree {
+  pcl::search::KdTree<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_KdTree *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTree *__pyx_vtabptr_3pcl_4_pcl_KdTree;
+static CYTHON_INLINE pcl::search::KdTree<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_6KdTree_thisptr(struct __pyx_obj_3pcl_4_pcl_KdTree *);
+
+
+/* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":12
+ * from cython.operator cimport dereference as deref, preincrement as inc
+ * 
+ * cdef class RangeImages:             # <<<<<<<<<<<<<<
+ *     """
+ *     rangeImage
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_RangeImages {
+  pcl::RangeImage *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_RangeImages *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_RangeImages *__pyx_vtabptr_3pcl_4_pcl_RangeImages;
+static CYTHON_INLINE pcl::RangeImage *__pyx_f_3pcl_4_pcl_11RangeImages_thisptr(struct __pyx_obj_3pcl_4_pcl_RangeImages *);
+
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":17
+ *     void mpcl_features_NormalEstimationMethod_compute(pcl_ftr.IntegralImageNormalEstimation_t, cpp.PointCloud_Normal_t ) except +
+ * 
+ * cdef class IntegralImageNormalEstimation:             # <<<<<<<<<<<<<<
+ *     """
+ *     IntegralImageNormalEstimation class for
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_IntegralImageNormalEstimation {
+  pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_vtabptr_3pcl_4_pcl_IntegralImageNormalEstimation;
+static CYTHON_INLINE pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *);
+
+
+/* "pcl/_pcl.pxd":155
+ * ## SampleConsensus
+ * # class override
+ * cdef class SampleConsensusModel:             # <<<<<<<<<<<<<<
+ *     cdef pcl_sac.SampleConsensusModelPtr_t thisptr_shared     # SampleConsensusModel
+ * 
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModel {
+  pcl::SampleConsensusModel<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModel *__pyx_vtabptr_3pcl_4_pcl_SampleConsensusModel;
+static CYTHON_INLINE pcl::SampleConsensusModel<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_20SampleConsensusModel_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *);
+
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi":5
+ * cimport pcl_sample_consensus as pcl_sac
+ * 
+ * cdef class SampleConsensusModelPlane:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelPlane {
+  pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelPlane;
+static CYTHON_INLINE pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_25SampleConsensusModelPlane_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *);
+
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi":7
+ * from boost_shared_ptr cimport sp_assign
+ * 
+ * cdef class SampleConsensusModelSphere:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelSphere {
+  pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelSphere;
+static CYTHON_INLINE pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_26SampleConsensusModelSphere_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *);
+
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi":5
+ * cimport pcl_sample_consensus as pcl_sac
+ * 
+ * cdef class SampleConsensusModelCylinder:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelCylinder {
+  pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelCylinder *__pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelCylinder;
+static CYTHON_INLINE pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_28SampleConsensusModelCylinder_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *);
+
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi":5
+ * cimport pcl_sample_consensus as pcl_sac
+ * 
+ * cdef class SampleConsensusModelLine:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelLine {
+  pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelLine *__pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelLine;
+static CYTHON_INLINE pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_24SampleConsensusModelLine_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *);
+
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi":5
+ * cimport pcl_sample_consensus as pcl_sac
+ * 
+ * cdef class SampleConsensusModelRegistration:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelRegistration {
+  pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelRegistration *__pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelRegistration;
+static CYTHON_INLINE pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_32SampleConsensusModelRegistration_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *);
+
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi":5
+ * cimport pcl_sample_consensus as pcl_sac
+ * 
+ * cdef class SampleConsensusModelStick:             # <<<<<<<<<<<<<<
+ *     """
+ *     """
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelStick {
+  pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  *(*thisptr)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelStick *__pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelStick;
+static CYTHON_INLINE pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_25SampleConsensusModelStick_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *);
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":5
+ * cimport pcl_kdtree as pclkdt
+ * 
+ * cdef class KdTreeFLANN:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN {
+  void (*_nearest_k)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, int, int, PyArrayObject *, PyArrayObject *);
+  void (*_search_radius)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, int, int, double, PyArrayObject *, PyArrayObject *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN *__pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN;
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":101
+ *             ind[i] = radius_indices[i]
+ * 
+ * cdef class KdTreeFLANN_PointXYZI:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZI {
+  void (*_nearest_k)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *, int, int, PyArrayObject *, PyArrayObject *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZI;
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":165
+ * 
+ * 
+ * cdef class KdTreeFLANN_PointXYZRGB:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB {
+  void (*_nearest_k)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *, int, int, PyArrayObject *, PyArrayObject *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB;
+
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":229
+ * 
+ * 
+ * cdef class KdTreeFLANN_PointXYZRGBA:             # <<<<<<<<<<<<<<
+ *     """
+ *     Finds k nearest neighbours from points in another pointcloud to points in
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA {
+  void (*_nearest_k)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *, int, int, PyArrayObject *, PyArrayObject *);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA;
+
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":8
+ * # include "OctreePointCloud.pxi"
+ * 
+ * cdef class OctreePointCloudSearch(OctreePointCloud):             # <<<<<<<<<<<<<<
+ *     """
+ *     Octree pointcloud search
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_OctreePointCloudSearch {
+  void (*_nearest_k)(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, int, int, PyArrayObject *, PyArrayObject *);
+  void (*_VoxelSearch)(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *, struct pcl::PointXYZ, std::vector<int>  &);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_OctreePointCloudSearch *__pyx_vtabptr_3pcl_4_pcl_OctreePointCloudSearch;
+
+
+/* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":12
+ * np.import_array()
+ * 
+ * cdef class GeneralizedIterativeClosestPoint:             # <<<<<<<<<<<<<<
+ *     """
+ *     Registration class for GeneralizedIterativeClosestPoint
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_GeneralizedIterativeClosestPoint {
+  PyObject *(*run)(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_opt_args_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run *__pyx_optional_args);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_vtabptr_3pcl_4_pcl_GeneralizedIterativeClosestPoint;
+
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":16
+ * np.import_array()
+ * 
+ * cdef class IterativeClosestPoint:             # <<<<<<<<<<<<<<
+ *     """
+ *     Registration class for IterativeClosestPoint
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPoint {
+  PyObject *(*run)(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_opt_args_3pcl_4_pcl_21IterativeClosestPoint_run *__pyx_optional_args);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPoint *__pyx_vtabptr_3pcl_4_pcl_IterativeClosestPoint;
+
+
+/* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":12
+ * np.import_array()
+ * 
+ * cdef class IterativeClosestPointNonLinear:             # <<<<<<<<<<<<<<
+ *     """
+ *     Registration class for IterativeClosestPointNonLinear
+ */
+
+struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPointNonLinear {
+  PyObject *(*run)(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_opt_args_3pcl_4_pcl_30IterativeClosestPointNonLinear_run *__pyx_optional_args);
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_vtabptr_3pcl_4_pcl_IterativeClosestPointNonLinear;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+  #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+  typedef struct {
+    void (*INCREF)(void*, PyObject*, int);
+    void (*DECREF)(void*, PyObject*, int);
+    void (*GOTREF)(void*, PyObject*, int);
+    void (*GIVEREF)(void*, PyObject*, int);
+    void* (*SetupContext)(const char*, int, const char*);
+    void (*FinishContext)(void**);
+  } __Pyx_RefNannyAPIStruct;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          if (acquire_gil) {\
+              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+              PyGILState_Release(__pyx_gilstate_save);\
+          } else {\
+              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+          }
+#else
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+  #define __Pyx_RefNannyFinishContext()\
+          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
+  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
+  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
+  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+#else
+  #define __Pyx_RefNannyDeclarations
+  #define __Pyx_RefNannySetupContext(name, acquire_gil)
+  #define __Pyx_RefNannyFinishContext()
+  #define __Pyx_INCREF(r) Py_INCREF(r)
+  #define __Pyx_DECREF(r) Py_DECREF(r)
+  #define __Pyx_GOTREF(r)
+  #define __Pyx_GIVEREF(r)
+  #define __Pyx_XINCREF(r) Py_XINCREF(r)
+  #define __Pyx_XDECREF(r) Py_XDECREF(r)
+  #define __Pyx_XGOTREF(r)
+  #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_XDECREF(tmp);\
+    } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+        PyObject *tmp = (PyObject *) r;\
+        r = v; __Pyx_DECREF(tmp);\
+    } while (0)
+#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
+    PyTypeObject* tp = Py_TYPE(obj);
+    if (likely(tp->tp_getattro))
+        return tp->tp_getattro(obj, attr_name);
+#if PY_MAJOR_VERSION < 3
+    if (likely(tp->tp_getattr))
+        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
+#endif
+    return PyObject_GetAttr(obj, attr_name);
+}
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* KeywordStringCheck.proto */
+static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
+
+/* GetModuleGlobalName.proto */
+static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);
+
+/* GetItemInt.proto */
+#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
+    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
+               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
+#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              int wraparound, int boundscheck);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
+                                                     int is_list, int wraparound, int boundscheck);
+
+/* PyCFunctionFastCall.proto */
+#if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
+#else
+#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs);
+#else
+#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
+#endif
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign  __pyx_tstate = PyThreadState_GET();
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+/* WriteUnraisableException.proto */
+static void __Pyx_WriteUnraisable(const char *name, int clineno,
+                                  int lineno, const char *filename,
+                                  int full_traceback, int nogil);
+
+/* ListCompAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len)) {
+        Py_INCREF(x);
+        PyList_SET_ITEM(list, len, x);
+        Py_SIZE(list) = len+1;
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
+    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+    const char* function_name);
+
+/* ArgTypeTest.proto */
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact);
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* BufferFormatCheck.proto */
+static CYTHON_INLINE int  __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
+    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type); // PROTO
+
+#define __Pyx_BufPtrCContig1d(type, buf, i0, s0) ((type)buf + i0)
+/* BufferIndexError.proto */
+static void __Pyx_RaiseBufferIndexError(int axis);
+
+#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
+/* PyObjectCallNoArg.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+#else
+#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
+#endif
+
+/* BufferFallbackError.proto */
+static void __Pyx_RaiseBufferFallbackError(void);
+
+/* ForceInitThreads.proto */
+#ifndef __PYX_FORCE_INIT_THREADS
+  #define __PYX_FORCE_INIT_THREADS 0
+#endif
+
+#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1)
+#define __Pyx_BufPtrCContig2d(type, buf, i0, s0, i1, s1) ((type)((char*)buf + i0 * s0) + i1)
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
+#else
+#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\
+    (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
+#endif
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* IterFinish.proto */
+static CYTHON_INLINE int __Pyx_IterFinish(void);
+
+/* UnpackItemEndCheck.proto */
+static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
+
+/* DictGetItem.proto */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
+    PyObject *value;
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (!PyErr_Occurred()) {
+            PyObject* args = PyTuple_Pack(1, key);
+            if (likely(args))
+                PyErr_SetObject(PyExc_KeyError, args);
+            Py_XDECREF(args);
+        }
+        return NULL;
+    }
+    Py_INCREF(value);
+    return value;
+}
+#else
+    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
+#endif
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* SetVTable.proto */
+static int __Pyx_SetVtable(PyObject *dict, void *vtable);
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* ImportFrom.proto */
+static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
+
+/* CodeObjectCache.proto */
+typedef struct {
+    PyCodeObject* code_object;
+    int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+    int count;
+    int max_count;
+    __Pyx_CodeObjectCacheEntry* entries;
+};
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename);
+
+/* None.proto */
+#include <new>
+
+/* BufferStructDeclare.proto */
+typedef struct {
+  Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+typedef struct {
+  size_t refcount;
+  Py_buffer pybuffer;
+} __Pyx_Buffer;
+typedef struct {
+  __Pyx_Buffer *rcbuffer;
+  char *data;
+  __Pyx_Buf_DimInfo diminfo[8];
+} __Pyx_LocalBuf_ND;
+
+#if PY_MAJOR_VERSION < 3
+    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+    static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+    #define __Pyx_GetBuffer PyObject_GetBuffer
+    #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+
+/* None.proto */
+static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0};
+static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1};
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(enum pcl::SacModel value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CppExceptionConversion.proto */
+#ifndef __Pyx_CppExn2PyErr
+#include <new>
+#include <typeinfo>
+#include <stdexcept>
+#include <ios>
+static void __Pyx_CppExn2PyErr() {
+  try {
+    if (PyErr_Occurred())
+      ; // let the latest Python exn pass through and ignore the current one
+    else
+      throw;
+  } catch (const std::bad_alloc& exn) {
+    PyErr_SetString(PyExc_MemoryError, exn.what());
+  } catch (const std::bad_cast& exn) {
+    PyErr_SetString(PyExc_TypeError, exn.what());
+  } catch (const std::bad_typeid& exn) {
+    PyErr_SetString(PyExc_TypeError, exn.what());
+  } catch (const std::domain_error& exn) {
+    PyErr_SetString(PyExc_ValueError, exn.what());
+  } catch (const std::invalid_argument& exn) {
+    PyErr_SetString(PyExc_ValueError, exn.what());
+  } catch (const std::ios_base::failure& exn) {
+    PyErr_SetString(PyExc_IOError, exn.what());
+  } catch (const std::out_of_range& exn) {
+    PyErr_SetString(PyExc_IndexError, exn.what());
+  } catch (const std::overflow_error& exn) {
+    PyErr_SetString(PyExc_OverflowError, exn.what());
+  } catch (const std::range_error& exn) {
+    PyErr_SetString(PyExc_ArithmeticError, exn.what());
+  } catch (const std::underflow_error& exn) {
+    PyErr_SetString(PyExc_ArithmeticError, exn.what());
+  } catch (const std::exception& exn) {
+    PyErr_SetString(PyExc_RuntimeError, exn.what());
+  }
+  catch (...)
+  {
+    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
+  }
+}
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value);
+
+/* Print.proto */
+static int __Pyx_Print(PyObject*, PyObject *, int);
+#if CYTHON_COMPILING_IN_PYPY || PY_MAJOR_VERSION >= 3
+static PyObject* __pyx_print = 0;
+static PyObject* __pyx_print_kwargs = 0;
+#endif
+
+/* RealImag.proto */
+#if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    #define __Pyx_CREAL(z) ((z).real())
+    #define __Pyx_CIMAG(z) ((z).imag())
+  #else
+    #define __Pyx_CREAL(z) (__real__(z))
+    #define __Pyx_CIMAG(z) (__imag__(z))
+  #endif
+#else
+    #define __Pyx_CREAL(z) ((z).real)
+    #define __Pyx_CIMAG(z) ((z).imag)
+#endif
+#if defined(__cplusplus) && CYTHON_CCOMPLEX\
+        && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
+    #define __Pyx_SET_CREAL(z,x) ((z).real(x))
+    #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
+#else
+    #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
+    #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_float(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_float(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_float(a, b) ((a)-(b))
+    #define __Pyx_c_prod_float(a, b) ((a)*(b))
+    #define __Pyx_c_quot_float(a, b) ((a)/(b))
+    #define __Pyx_c_neg_float(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_float(z) ((z)==(float)0)
+    #define __Pyx_c_conj_float(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (::std::abs(z))
+        #define __Pyx_c_pow_float(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_float(z) ((z)==0)
+    #define __Pyx_c_conj_float(z)    (conjf(z))
+    #if 1
+        #define __Pyx_c_abs_float(z)     (cabsf(z))
+        #define __Pyx_c_pow_float(a, b)  (cpowf(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex);
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex);
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex);
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex);
+    #endif
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+    #define __Pyx_c_eq_double(a, b)   ((a)==(b))
+    #define __Pyx_c_sum_double(a, b)  ((a)+(b))
+    #define __Pyx_c_diff_double(a, b) ((a)-(b))
+    #define __Pyx_c_prod_double(a, b) ((a)*(b))
+    #define __Pyx_c_quot_double(a, b) ((a)/(b))
+    #define __Pyx_c_neg_double(a)     (-(a))
+  #ifdef __cplusplus
+    #define __Pyx_c_is_zero_double(z) ((z)==(double)0)
+    #define __Pyx_c_conj_double(z)    (::std::conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (::std::abs(z))
+        #define __Pyx_c_pow_double(a, b)  (::std::pow(a, b))
+    #endif
+  #else
+    #define __Pyx_c_is_zero_double(z) ((z)==0)
+    #define __Pyx_c_conj_double(z)    (conj(z))
+    #if 1
+        #define __Pyx_c_abs_double(z)     (cabs(z))
+        #define __Pyx_c_pow_double(a, b)  (cpow(a, b))
+    #endif
+ #endif
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex);
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex);
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex);
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex);
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex);
+    #endif
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE enum pcl::SacModel __Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE Py_intptr_t __Pyx_PyInt_As_Py_intptr_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE pcl::ComparisonOps::CompareOp __Pyx_PyInt_As_pcl_3a__3a_ComparisonOps_3a__3a_CompareOp(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE pcl::RangeImage::CoordinateFrame __Pyx_PyInt_As_pcl_3a__3a_RangeImage_3a__3a_CoordinateFrame(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* PrintOne.proto */
+static int __Pyx_PrintOne(PyObject* stream, PyObject *o);
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* PyIdentifierFromString.proto */
+#if !defined(__Pyx_PyIdentifier_FromString)
+#if PY_MAJOR_VERSION < 3
+  #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
+#else
+  #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
+#endif
+#endif
+
+/* ModuleImport.proto */
+static PyObject *__Pyx_ImportModule(const char *name);
+
+/* TypeImport.proto */
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+static void __pyx_f_3pcl_4_pcl_11KdTreeFLANN__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist); /* proto*/
+static void __pyx_f_3pcl_4_pcl_11KdTreeFLANN__search_radius(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, double __pyx_v_radius, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist); /* proto*/
+static void __pyx_f_3pcl_4_pcl_21KdTreeFLANN_PointXYZI__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist); /* proto*/
+static void __pyx_f_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist); /* proto*/
+static void __pyx_f_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist); /* proto*/
+static void __pyx_f_3pcl_4_pcl_22OctreePointCloudSearch__nearest_k(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist); /* proto*/
+static void __pyx_f_3pcl_4_pcl_22OctreePointCloudSearch__VoxelSearch(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct pcl::PointXYZ __pyx_v_point, std::vector<int>  &__pyx_v_v_indices); /* proto*/
+static PyObject *__pyx_f_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &__pyx_v_reg, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, struct __pyx_opt_args_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_3pcl_4_pcl_21IterativeClosestPoint_run(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &__pyx_v_reg, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, struct __pyx_opt_args_3pcl_4_pcl_21IterativeClosestPoint_run *__pyx_optional_args); /* proto*/
+static PyObject *__pyx_f_3pcl_4_pcl_30IterativeClosestPointNonLinear_run(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &__pyx_v_reg, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, struct __pyx_opt_args_3pcl_4_pcl_30IterativeClosestPointNonLinear_run *__pyx_optional_args); /* proto*/
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZI>  *__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZRGB>  *__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZRGBA>  *__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::Vertices *__pyx_f_3pcl_4_pcl_8Vertices_thisptr(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointWithViewpoint>  *__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::PointCloud<struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_17PointCloud_Normal_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointNormal>  *__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::search::KdTree<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_6KdTree_thisptr(struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::RangeImage *__pyx_f_3pcl_4_pcl_11RangeImages_thisptr(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::SampleConsensusModel<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_20SampleConsensusModel_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_25SampleConsensusModelPlane_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_26SampleConsensusModelSphere_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_28SampleConsensusModelCylinder_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_24SampleConsensusModelLine_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_32SampleConsensusModelRegistration_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *__pyx_v_self); /* proto*/
+static CYTHON_INLINE pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_25SampleConsensusModelStick_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *__pyx_v_self); /* proto*/
+
+/* Module declarations from 'libc.stddef' */
+
+/* Module declarations from 'libcpp.vector' */
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libcpp.string' */
+
+/* Module declarations from 'libcpp' */
+
+/* Module declarations from 'pcl.boost_shared_ptr' */
+
+/* Module declarations from 'pcl.vector' */
+
+/* Module declarations from 'pcl.eigen' */
+
+/* Module declarations from 'pcl.pcl_defs' */
+
+/* Module declarations from 'pcl.pcl_kdtree' */
+
+/* Module declarations from 'pcl.pcl_range_image' */
+
+/* Module declarations from 'pcl.pcl_features' */
+
+/* Module declarations from 'pcl.pcl_sample_consensus' */
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'cpython.version' */
+
+/* Module declarations from 'cpython.exc' */
+
+/* Module declarations from 'cpython.module' */
+
+/* Module declarations from 'cpython.mem' */
+
+/* Module declarations from 'cpython.tuple' */
+
+/* Module declarations from 'cpython.list' */
+
+/* Module declarations from 'cpython.sequence' */
+
+/* Module declarations from 'cpython.mapping' */
+
+/* Module declarations from 'cpython.iterator' */
+
+/* Module declarations from 'cpython.number' */
+
+/* Module declarations from 'cpython.int' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.bool' */
+static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0;
+
+/* Module declarations from 'cpython.long' */
+
+/* Module declarations from 'cpython.float' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.complex' */
+static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0;
+
+/* Module declarations from 'cpython.string' */
+
+/* Module declarations from 'cpython.unicode' */
+
+/* Module declarations from 'cpython.dict' */
+
+/* Module declarations from 'cpython.instance' */
+
+/* Module declarations from 'cpython.function' */
+
+/* Module declarations from 'cpython.method' */
+
+/* Module declarations from 'cpython.weakref' */
+
+/* Module declarations from 'cpython.getargs' */
+
+/* Module declarations from 'cpython.pythread' */
+
+/* Module declarations from 'cpython.pystate' */
+
+/* Module declarations from 'cpython.cobject' */
+
+/* Module declarations from 'cpython.oldbuffer' */
+
+/* Module declarations from 'cpython.set' */
+
+/* Module declarations from 'cpython.bytes' */
+
+/* Module declarations from 'cpython.pycapsule' */
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'libc.stdlib' */
+
+/* Module declarations from 'numpy' */
+
+/* Module declarations from 'numpy' */
+static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
+static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
+static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void); /*proto*/
+
+/* Module declarations from 'cython' */
+
+/* Module declarations from 'pcl.pcl_common' */
+
+/* Module declarations from 'pcl.pcl_sample_consensus_180' */
+
+/* Module declarations from 'libcpp.utility' */
+
+/* Module declarations from 'libcpp.pair' */
+
+/* Module declarations from 'pcl.pcl_filters_180' */
+
+/* Module declarations from 'pcl.pcl_range_image_180' */
+
+/* Module declarations from 'pcl.pcl_surface' */
+
+/* Module declarations from 'pcl.pcl_segmentation_180' */
+
+/* Module declarations from 'pcl.pcl_filters' */
+
+/* Module declarations from 'pcl.pcl_octree_180' */
+
+/* Module declarations from 'pcl.pcl_registration_180' */
+
+/* Module declarations from 'pcl.pcl_kdtree_180' */
+
+/* Module declarations from 'pcl.pcl_features_180' */
+
+/* Module declarations from 'pcl.pcl_kdtree_172' */
+
+/* Module declarations from 'pcl.pcl_range_image_172' */
+
+/* Module declarations from 'pcl.pcl_features_172' */
+
+/* Module declarations from 'pcl.pcl_keypoints_180' */
+
+/* Module declarations from 'pcl.pcl_io_180' */
+
+/* Module declarations from 'pcl.indexing' */
+
+/* Module declarations from 'pcl._pcl' */
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PointCloud = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Vertices = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PointCloud_PointWithViewpoint = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PointCloud_Normal = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PointCloud_PointNormal = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_KdTree = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_RangeImages = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_IntegralImageNormalEstimation = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SampleConsensusModel = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SampleConsensusModelPlane = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SampleConsensusModelSphere = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SampleConsensusModelCylinder = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SampleConsensusModelLine = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SampleConsensusModelRegistration = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SampleConsensusModelStick = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl__CythonCompareOp_Type = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl__CythonCoordinateFrame_Type = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Segmentation = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_SegmentationNormal = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZI_Normal = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_EuclideanClusterExtraction = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_VoxelGridFilter = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PassThroughFilter = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_MovingLeastSquares = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_KdTreeFLANN = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_CropHull = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_CropBox = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ProjectInliers = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_RadiusOutlierRemoval = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ConditionAnd = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ConditionalRemoval = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ConcaveHull = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ConcaveHull_PointXYZI = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ConcaveHull_PointXYZRGB = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_ConcaveHull_PointXYZRGBA = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_GeneralizedIterativeClosestPoint = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_IterativeClosestPoint = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_IterativeClosestPointNonLinear = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_RandomSampleConsensus = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_NormalEstimation = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_VFHEstimation = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_MomentOfInertiaEstimation = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_HarrisKeypoint3D = 0;
+static PyTypeObject *__pyx_ptype_3pcl_4_pcl_NormalDistributionsTransform = 0;
+static Py_ssize_t __pyx_v_3pcl_4_pcl__strides[2];
+static struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_3pcl_4_pcl__pc_tmp = 0;
+static pcl::PointCloud<struct pcl::PointXYZ>  *__pyx_v_3pcl_4_pcl_p;
+static Py_ssize_t __pyx_v_3pcl_4_pcl__strides_xyzi_4[2];
+static struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_3pcl_4_pcl__pc_xyzi_tmp4 = 0;
+static pcl::PointCloud<struct pcl::PointXYZI>  *__pyx_v_3pcl_4_pcl_p_xyzi_4;
+static Py_ssize_t __pyx_v_3pcl_4_pcl__strides_xyzrgb_3[2];
+static struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_3pcl_4_pcl__pc_xyzrgb_tmp3 = 0;
+static pcl::PointCloud<struct pcl::PointXYZRGB>  *__pyx_v_3pcl_4_pcl_p_xyzrgb_3;
+static Py_ssize_t __pyx_v_3pcl_4_pcl__strides_xyzrgba_2[2];
+static struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_3pcl_4_pcl__pc_xyzrgba_tmp2 = 0;
+static pcl::PointCloud<struct pcl::PointXYZRGBA>  *__pyx_v_3pcl_4_pcl_p_xyzrgba_2;
+static struct pcl::PointXYZ __pyx_f_3pcl_4_pcl_to_point_t(PyObject *); /*proto*/
+static struct pcl::PointXYZI __pyx_f_3pcl_4_pcl_to_point2_t(PyObject *); /*proto*/
+static struct pcl::PointXYZRGB __pyx_f_3pcl_4_pcl_to_point3_t(PyObject *); /*proto*/
+static struct pcl::PointXYZRGBA __pyx_f_3pcl_4_pcl_to_point4_t(PyObject *); /*proto*/
+static PyObject *__pyx_convert_vector_to_py_int(const std::vector<int>  &); /*proto*/
+static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___(const std::vector<std::vector<int> >  &); /*proto*/
+static std::vector<int>  __pyx_convert_vector_from_py_int(PyObject *); /*proto*/
+static PyObject *__pyx_convert_vector_to_py_float(const std::vector<float>  &); /*proto*/
+static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, IS_UNSIGNED(int) ? 'U' : 'I', IS_UNSIGNED(int), 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int_t = { "int_t", NULL, sizeof(__pyx_t_5numpy_int_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int_t), 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_object = { "int object", NULL, sizeof(PyObject *), { 0 }, 0, 'O', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { "float32_t", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 };
+#define __Pyx_MODULE_NAME "pcl._pcl"
+int __pyx_module_is_main_pcl___pcl = 0;
+
+/* Implementation of 'pcl._pcl' */
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin_TypeError;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_enumerate;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_ImportError;
+static const char __pyx_k_3[] = "3";
+static const char __pyx_k_4[] = "4";
+static const char __pyx_k_f[] = "f";
+static const char __pyx_k_k[] = "k";
+static const char __pyx_k_x[] = "x";
+static const char __pyx_k_y[] = "y";
+static const char __pyx_k_z[] = "z";
+static const char __pyx_k_3a[] = "3a";
+static const char __pyx_k_3b[] = "3b";
+static const char __pyx_k__8[] = " ";
+static const char __pyx_k__9[] = ")";
+static const char __pyx_k_f1[] = "f1";
+static const char __pyx_k_f2[] = "f2";
+static const char __pyx_k_np[] = "np";
+static const char __pyx_k_pc[] = "pc";
+static const char __pyx_k_rx[] = "rx";
+static const char __pyx_k_ry[] = "ry";
+static const char __pyx_k_rz[] = "rz";
+static const char __pyx_k_tx[] = "tx";
+static const char __pyx_k_ty[] = "ty";
+static const char __pyx_k_tz[] = "tz";
+static const char __pyx_k_vt[] = "vt";
+static const char __pyx_k_col[] = "col";
+static const char __pyx_k_end[] = "end";
+static const char __pyx_k_row[] = "row";
+static const char __pyx_k_cond[] = "cond";
+static const char __pyx_k_file[] = "file";
+static const char __pyx_k_init[] = "init";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_maxs[] = "maxs";
+static const char __pyx_k_maxx[] = "maxx";
+static const char __pyx_k_maxy[] = "maxy";
+static const char __pyx_k_maxz[] = "maxz";
+static const char __pyx_k_mins[] = "mins";
+static const char __pyx_k_minx[] = "minx";
+static const char __pyx_k_miny[] = "miny";
+static const char __pyx_k_minz[] = "minz";
+static const char __pyx_k_size[] = "size";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_alpha[] = "alpha";
+static const char __pyx_k_array[] = "array";
+static const char __pyx_k_ascii[] = "ascii";
+static const char __pyx_k_cloud[] = "cloud";
+static const char __pyx_k_dtype[] = "dtype";
+static const char __pyx_k_empty[] = "empty";
+static const char __pyx_k_float[] = "float";
+static const char __pyx_k_fname[] = "fname";
+static const char __pyx_k_index[] = "index";
+static const char __pyx_k_int32[] = "int32";
+static const char __pyx_k_model[] = "model";
+static const char __pyx_k_numpy[] = "numpy";
+static const char __pyx_k_order[] = "order";
+static const char __pyx_k_point[] = "point";
+static const char __pyx_k_print[] = "print";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_width[] = "width";
+static const char __pyx_k_zeros[] = "zeros";
+static const char __pyx_k_binary[] = "binary";
+static const char __pyx_k_compOp[] = "compOp";
+static const char __pyx_k_encode[] = "encode";
+static const char __pyx_k_height[] = "height";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_max_nn[] = "max_nn";
+static const char __pyx_k_points[] = "points";
+static const char __pyx_k_radius[] = "radius";
+static const char __pyx_k_resize[] = "resize";
+static const char __pyx_k_source[] = "source";
+static const char __pyx_k_target[] = "target";
+static const char __pyx_k_thresh[] = "thresh";
+static const char __pyx_k_tolist[] = "tolist";
+static const char __pyx_k_Compute[] = "Compute";
+static const char __pyx_k_deg2rad[] = "deg2rad";
+static const char __pyx_k_float32[] = "float32";
+static const char __pyx_k_fortran[] = "fortran";
+static const char __pyx_k_integer[] = "integer";
+static const char __pyx_k_ksearch[] = "ksearch";
+static const char __pyx_k_numbers[] = "numbers";
+static const char __pyx_k_rad2deg[] = "rad2deg";
+static const char __pyx_k_Integral[] = "Integral";
+static const char __pyx_k_SAC_MSAC[] = "SAC_MSAC";
+static const char __pyx_k_Sequence[] = "Sequence";
+static const char __pyx_k_max_iter[] = "max_iter";
+static const char __pyx_k_negative[] = "negative";
+static const char __pyx_k_pcl__pcl[] = "pcl._pcl";
+static const char __pyx_k_to_array[] = "to_array";
+static const char __pyx_k_vertices[] = "vertices";
+static const char __pyx_k_SAC_LMEDS[] = "SAC_LMEDS";
+static const char __pyx_k_SAC_RMSAC[] = "SAC_RMSAC";
+static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_enumerate[] = "enumerate";
+static const char __pyx_k_from_list[] = "from_list";
+static const char __pyx_k_max_angle[] = "max_angle";
+static const char __pyx_k_min_angle[] = "min_angle";
+static const char __pyx_k_min_range[] = "min_range";
+static const char __pyx_k_pyindices[] = "pyindices";
+static const char __pyx_k_SAC_MLESAC[] = "SAC_MLESAC";
+static const char __pyx_k_SAC_PROSAC[] = "SAC_PROSAC";
+static const char __pyx_k_SAC_RANSAC[] = "SAC_RANSAC";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_cloud_size[] = "cloud.size = ";
+static const char __pyx_k_field_name[] = "field_name";
+static const char __pyx_k_filter_max[] = "filter_max";
+static const char __pyx_k_filter_min[] = "filter_min";
+static const char __pyx_k_from_array[] = "from_array";
+static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
+static const char __pyx_k_resolution[] = "resolution";
+static const char __pyx_k_ImportError[] = "ImportError";
+static const char __pyx_k_SAC_RRANSAC[] = "SAC_RRANSAC";
+static const char __pyx_k_border_size[] = "border_size";
+static const char __pyx_k_cinit___end[] = "__cinit__ end";
+static const char __pyx_k_cloud_width[] = "cloud.width = ";
+static const char __pyx_k_collections[] = "collections";
+static const char __pyx_k_min_range_2[] = "min_range = ";
+static const char __pyx_k_noise_level[] = "noise_level";
+static const char __pyx_k_to_pcd_file[] = "_to_pcd_file";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_cloud_height[] = "cloud.height = ";
+static const char __pyx_k_searchRadius[] = "searchRadius";
+static const char __pyx_k_SACMODEL_CONE[] = "SACMODEL_CONE";
+static const char __pyx_k_SACMODEL_LINE[] = "SACMODEL_LINE";
+static const char __pyx_k_border_size_2[] = "border_size = ";
+static const char __pyx_k_cinit___start[] = "__cinit__ start";
+static const char __pyx_k_from_pcd_file[] = "_from_pcd_file";
+static const char __pyx_k_noise_level_2[] = "noise_level = ";
+static const char __pyx_k_SACMODEL_PLANE[] = "SACMODEL_PLANE";
+static const char __pyx_k_SACMODEL_STICK[] = "SACMODEL_STICK";
+static const char __pyx_k_SACMODEL_TORUS[] = "SACMODEL_TORUS";
+static const char __pyx_k_VoxelSearch_at[] = "VoxelSearch at (";
+static const char __pyx_k_filter_pc_size[] = "filter: pc size = ";
+static const char __pyx_k_SACMODEL_SPHERE[] = "SACMODEL_SPHERE";
+static const char __pyx_k_keypoints_count[] = "keypoints.count : ";
+static const char __pyx_k_max_angle_width[] = "max_angle_width";
+static const char __pyx_k_set_input_cloud[] = "set_input_cloud";
+static const char __pyx_k_coordinate_frame[] = "coordinate_frame";
+static const char __pyx_k_max_angle_height[] = "max_angle_height";
+static const char __pyx_k_SACMODEL_CIRCLE2D[] = "SACMODEL_CIRCLE2D";
+static const char __pyx_k_SACMODEL_CIRCLE3D[] = "SACMODEL_CIRCLE3D";
+static const char __pyx_k_SACMODEL_CYLINDER[] = "SACMODEL_CYLINDER";
+static const char __pyx_k_max_angle_width_2[] = "max_angle_width = ";
+static const char __pyx_k_angular_resolution[] = "angular_resolution";
+static const char __pyx_k_max_angle_height_2[] = "max_angle_height = ";
+static const char __pyx_k_CythonCompareOp_Type[] = "CythonCompareOp_Type";
+static const char __pyx_k_Vertices_of_d_points[] = "<Vertices of %d points>";
+static const char __pyx_k_angular_resolution_2[] = "angular_resolution = ";
+static const char __pyx_k_angular_resolution_x[] = "angular_resolution_x";
+static const char __pyx_k_angular_resolution_y[] = "angular_resolution_y";
+static const char __pyx_k_SACMODEL_NORMAL_PLANE[] = "SACMODEL_NORMAL_PLANE";
+static const char __pyx_k_SACMODEL_REGISTRATION[] = "SACMODEL_REGISTRATION";
+static const char __pyx_k_make_NormalEstimation[] = "make_NormalEstimation";
+static const char __pyx_k_PointCloud_of_d_points[] = "<PointCloud of %d points>";
+static const char __pyx_k_SACMODEL_NORMAL_SPHERE[] = "SACMODEL_NORMAL_SPHERE";
+static const char __pyx_k_SACMODEL_PARALLEL_LINE[] = "SACMODEL_PARALLEL_LINE";
+static const char __pyx_k_SACMODEL_PARALLEL_LINES[] = "SACMODEL_PARALLEL_LINES";
+static const char __pyx_k_SACMODEL_PARALLEL_PLANE[] = "SACMODEL_PARALLEL_PLANE";
+static const char __pyx_k_filter_outputCloud_size[] = "filter: outputCloud size = ";
+static const char __pyx_k_call_createFromPointCloud[] = "call createFromPointCloud";
+static const char __pyx_k_CreateFromPointCloud_enter[] = "CreateFromPointCloud enter";
+static const char __pyx_k_CythonCoordinateFrame_Type[] = "CythonCoordinateFrame_Type";
+static const char __pyx_k_Expected_resolution_0_got_r[] = "Expected resolution > 0., got %r";
+static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
+static const char __pyx_k_SACMODEL_PERPENDICULAR_PLANE[] = "SACMODEL_PERPENDICULAR_PLANE";
+static const char __pyx_k_SACMODEL_NORMAL_PARALLEL_PLANE[] = "SACMODEL_NORMAL_PARALLEL_PLANE";
+static const char __pyx_k_Users_T_O_python_pcl_pcl__pcl_1[] = "/Users/T_O/python-pcl/pcl/_pcl_180.pyx";
+static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
+static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
+static const char __pyx_k_Can_t_initialize_a_PointCloud_fr[] = "Can't initialize a PointCloud from a %s";
+static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
+static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
+static const char __pyx_k_can_t_resize_PointCloud_while_th[] = "can't resize PointCloud while there are arrays/memoryviews referencing it";
+static const char __pyx_k_can_t_resize_Vertices_while_ther[] = "can't resize Vertices while there are arrays/memoryviews referencing it";
+static const char __pyx_k_field_name_should_be_a_string_go[] = "field_name should be a string, got %r";
+static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
+static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
+static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
+static PyObject *__pyx_kp_s_3;
+static PyObject *__pyx_kp_s_3a;
+static PyObject *__pyx_kp_s_3b;
+static PyObject *__pyx_kp_s_4;
+static PyObject *__pyx_kp_s_Can_t_initialize_a_PointCloud_fr;
+static PyObject *__pyx_n_s_Compute;
+static PyObject *__pyx_kp_s_CreateFromPointCloud_enter;
+static PyObject *__pyx_n_s_CythonCompareOp_Type;
+static PyObject *__pyx_n_s_CythonCoordinateFrame_Type;
+static PyObject *__pyx_kp_s_Expected_resolution_0_got_r;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
+static PyObject *__pyx_n_s_ImportError;
+static PyObject *__pyx_n_s_Integral;
+static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
+static PyObject *__pyx_kp_s_PointCloud_of_d_points;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_n_s_SACMODEL_CIRCLE2D;
+static PyObject *__pyx_n_s_SACMODEL_CIRCLE3D;
+static PyObject *__pyx_n_s_SACMODEL_CONE;
+static PyObject *__pyx_n_s_SACMODEL_CYLINDER;
+static PyObject *__pyx_n_s_SACMODEL_LINE;
+static PyObject *__pyx_n_s_SACMODEL_NORMAL_PARALLEL_PLANE;
+static PyObject *__pyx_n_s_SACMODEL_NORMAL_PLANE;
+static PyObject *__pyx_n_s_SACMODEL_NORMAL_SPHERE;
+static PyObject *__pyx_n_s_SACMODEL_PARALLEL_LINE;
+static PyObject *__pyx_n_s_SACMODEL_PARALLEL_LINES;
+static PyObject *__pyx_n_s_SACMODEL_PARALLEL_PLANE;
+static PyObject *__pyx_n_s_SACMODEL_PERPENDICULAR_PLANE;
+static PyObject *__pyx_n_s_SACMODEL_PLANE;
+static PyObject *__pyx_n_s_SACMODEL_REGISTRATION;
+static PyObject *__pyx_n_s_SACMODEL_SPHERE;
+static PyObject *__pyx_n_s_SACMODEL_STICK;
+static PyObject *__pyx_n_s_SACMODEL_TORUS;
+static PyObject *__pyx_n_s_SAC_LMEDS;
+static PyObject *__pyx_n_s_SAC_MLESAC;
+static PyObject *__pyx_n_s_SAC_MSAC;
+static PyObject *__pyx_n_s_SAC_PROSAC;
+static PyObject *__pyx_n_s_SAC_RANSAC;
+static PyObject *__pyx_n_s_SAC_RMSAC;
+static PyObject *__pyx_n_s_SAC_RRANSAC;
+static PyObject *__pyx_n_s_Sequence;
+static PyObject *__pyx_n_s_TypeError;
+static PyObject *__pyx_kp_s_Users_T_O_python_pcl_pcl__pcl_1;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_kp_s_Vertices_of_d_points;
+static PyObject *__pyx_kp_s_VoxelSearch_at;
+static PyObject *__pyx_kp_s__8;
+static PyObject *__pyx_kp_s__9;
+static PyObject *__pyx_n_s_alpha;
+static PyObject *__pyx_n_s_angular_resolution;
+static PyObject *__pyx_kp_s_angular_resolution_2;
+static PyObject *__pyx_n_s_angular_resolution_x;
+static PyObject *__pyx_n_s_angular_resolution_y;
+static PyObject *__pyx_n_s_array;
+static PyObject *__pyx_n_s_ascii;
+static PyObject *__pyx_n_s_binary;
+static PyObject *__pyx_n_s_border_size;
+static PyObject *__pyx_kp_s_border_size_2;
+static PyObject *__pyx_kp_s_call_createFromPointCloud;
+static PyObject *__pyx_kp_s_can_t_resize_PointCloud_while_th;
+static PyObject *__pyx_kp_s_can_t_resize_Vertices_while_ther;
+static PyObject *__pyx_kp_s_cinit___end;
+static PyObject *__pyx_kp_s_cinit___start;
+static PyObject *__pyx_n_s_cloud;
+static PyObject *__pyx_kp_s_cloud_height;
+static PyObject *__pyx_kp_s_cloud_size;
+static PyObject *__pyx_kp_s_cloud_width;
+static PyObject *__pyx_n_s_col;
+static PyObject *__pyx_n_s_collections;
+static PyObject *__pyx_n_s_compOp;
+static PyObject *__pyx_n_s_cond;
+static PyObject *__pyx_n_s_coordinate_frame;
+static PyObject *__pyx_n_s_deg2rad;
+static PyObject *__pyx_n_s_dtype;
+static PyObject *__pyx_n_s_empty;
+static PyObject *__pyx_n_s_encode;
+static PyObject *__pyx_n_s_end;
+static PyObject *__pyx_n_s_enumerate;
+static PyObject *__pyx_n_s_f;
+static PyObject *__pyx_n_s_f1;
+static PyObject *__pyx_n_s_f2;
+static PyObject *__pyx_n_s_field_name;
+static PyObject *__pyx_kp_s_field_name_should_be_a_string_go;
+static PyObject *__pyx_n_s_file;
+static PyObject *__pyx_n_s_filter_max;
+static PyObject *__pyx_n_s_filter_min;
+static PyObject *__pyx_kp_s_filter_outputCloud_size;
+static PyObject *__pyx_kp_s_filter_pc_size;
+static PyObject *__pyx_n_s_float;
+static PyObject *__pyx_n_s_float32;
+static PyObject *__pyx_n_s_fname;
+static PyObject *__pyx_n_s_fortran;
+static PyObject *__pyx_n_s_from_array;
+static PyObject *__pyx_n_s_from_list;
+static PyObject *__pyx_n_s_from_pcd_file;
+static PyObject *__pyx_n_s_height;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_n_s_index;
+static PyObject *__pyx_n_s_init;
+static PyObject *__pyx_n_s_int32;
+static PyObject *__pyx_n_s_integer;
+static PyObject *__pyx_n_s_k;
+static PyObject *__pyx_kp_s_keypoints_count;
+static PyObject *__pyx_n_s_ksearch;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_n_s_make_NormalEstimation;
+static PyObject *__pyx_n_s_max_angle;
+static PyObject *__pyx_n_s_max_angle_height;
+static PyObject *__pyx_kp_s_max_angle_height_2;
+static PyObject *__pyx_n_s_max_angle_width;
+static PyObject *__pyx_kp_s_max_angle_width_2;
+static PyObject *__pyx_n_s_max_iter;
+static PyObject *__pyx_n_s_max_nn;
+static PyObject *__pyx_n_s_maxs;
+static PyObject *__pyx_n_s_maxx;
+static PyObject *__pyx_n_s_maxy;
+static PyObject *__pyx_n_s_maxz;
+static PyObject *__pyx_n_s_min_angle;
+static PyObject *__pyx_n_s_min_range;
+static PyObject *__pyx_kp_s_min_range_2;
+static PyObject *__pyx_n_s_mins;
+static PyObject *__pyx_n_s_minx;
+static PyObject *__pyx_n_s_miny;
+static PyObject *__pyx_n_s_minz;
+static PyObject *__pyx_n_s_model;
+static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
+static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
+static PyObject *__pyx_n_s_negative;
+static PyObject *__pyx_n_s_noise_level;
+static PyObject *__pyx_kp_s_noise_level_2;
+static PyObject *__pyx_n_s_np;
+static PyObject *__pyx_n_s_numbers;
+static PyObject *__pyx_n_s_numpy;
+static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to;
+static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor;
+static PyObject *__pyx_n_s_order;
+static PyObject *__pyx_n_s_pc;
+static PyObject *__pyx_n_s_pcl__pcl;
+static PyObject *__pyx_n_s_point;
+static PyObject *__pyx_n_s_points;
+static PyObject *__pyx_n_s_print;
+static PyObject *__pyx_n_s_pyindices;
+static PyObject *__pyx_n_s_pyx_vtable;
+static PyObject *__pyx_n_s_rad2deg;
+static PyObject *__pyx_n_s_radius;
+static PyObject *__pyx_n_s_range;
+static PyObject *__pyx_n_s_resize;
+static PyObject *__pyx_n_s_resolution;
+static PyObject *__pyx_n_s_row;
+static PyObject *__pyx_n_s_rx;
+static PyObject *__pyx_n_s_ry;
+static PyObject *__pyx_n_s_rz;
+static PyObject *__pyx_n_s_searchRadius;
+static PyObject *__pyx_n_s_set_input_cloud;
+static PyObject *__pyx_n_s_size;
+static PyObject *__pyx_n_s_source;
+static PyObject *__pyx_n_s_target;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_thresh;
+static PyObject *__pyx_n_s_to_array;
+static PyObject *__pyx_n_s_to_pcd_file;
+static PyObject *__pyx_n_s_tolist;
+static PyObject *__pyx_n_s_tx;
+static PyObject *__pyx_n_s_ty;
+static PyObject *__pyx_n_s_tz;
+static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_n_s_vertices;
+static PyObject *__pyx_n_s_vt;
+static PyObject *__pyx_n_s_width;
+static PyObject *__pyx_n_s_x;
+static PyObject *__pyx_n_s_y;
+static PyObject *__pyx_n_s_z;
+static PyObject *__pyx_n_s_zeros;
+static int __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type___cinit__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2GT___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2GE___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2LT___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2LE___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2EQ___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type___cinit__(struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type_12CAMERA_FRAME___get__(struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type_11LASER_FRAME___get__(struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_12Segmentation___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_12Segmentation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, float __pyx_v_d); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_14set_MaxIterations(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, int __pyx_v_count); /* proto */
+static int __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, float __pyx_v_d); /* proto */
+static int __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, float __pyx_v_d); /* proto */
+static int __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, float __pyx_v_d); /* proto */
+static int __pyx_pf_3pcl_4_pcl_18SegmentationNormal___cinit__(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_18SegmentationNormal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_4segment(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, float __pyx_v_d); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, float __pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, int __pyx_v_i); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, double __pyx_v_ea); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, float __pyx_v_d); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, float __pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, int __pyx_v_i); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, double __pyx_v_ea); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, float __pyx_v_d); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, float __pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, int __pyx_v_i); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, double __pyx_v_ea); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, int __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, float __pyx_v_d); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, bool __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, float __pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, int __pyx_v_i); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, double __pyx_v_ea); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction___cinit__(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_4set_ClusterTolerance(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, double __pyx_v_b); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_6set_MinClusterSize(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, int __pyx_v_min); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_8set_MaxClusterSize(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, int __pyx_v_max); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_10set_SearchMethod(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_12Extract(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, bool __pyx_v_neg); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, double __pyx_v_thresh); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, double __pyx_v_std_mul); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, bool __pyx_v_negative); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, bool __pyx_v_neg); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, double __pyx_v_thresh); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, double __pyx_v_std_mul); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, bool __pyx_v_negative); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, bool __pyx_v_neg); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, double __pyx_v_thresh); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, double __pyx_v_std_mul); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, bool __pyx_v_negative); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, bool __pyx_v_neg); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, double __pyx_v_thresh); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, double __pyx_v_std_mul); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, bool __pyx_v_negative); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_15VoxelGridFilter___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_15VoxelGridFilter_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_15VoxelGridFilter_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_15VoxelGridFilter_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_17PassThroughFilter___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_17PassThroughFilter_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_17PassThroughFilter_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self, PyObject *__pyx_v_field_name); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_17PassThroughFilter_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_17PassThroughFilter_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self, PyObject *__pyx_v_field_name); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_field_name); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_field_name); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_6set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_6set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_6set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_6set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_18MovingLeastSquares___cinit__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_4set_search_radius(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, double __pyx_v_radius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_6set_polynomial_order(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, bool __pyx_v_order); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_8set_polynomial_fit(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, bool __pyx_v_fit); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_10set_Compute_Normals(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, bool __pyx_v_flag); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_12set_Search_Method(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_14process(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_4set_search_radius(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self, double __pyx_v_radius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_6set_polynomial_order(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self, bool __pyx_v_order); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_8set_polynomial_fit(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self, int __pyx_v_fit); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_10process(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_4set_search_radius(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self, double __pyx_v_radius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_6set_polynomial_order(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self, bool __pyx_v_order); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_8set_polynomial_fit(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self, int __pyx_v_fit); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_10process(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_11KdTreeFLANN___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_11KdTreeFLANN_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11KdTreeFLANN_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11KdTreeFLANN_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11KdTreeFLANN_8radius_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, double __pyx_v_radius, unsigned int __pyx_v_max_nn); /* proto */
+static int __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k); /* proto */
+static int __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k); /* proto */
+static int __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16OctreePointCloud_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16OctreePointCloud_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_26OctreePointCloud_PointXYZI_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_26OctreePointCloud_PointXYZI_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20OctreePointCloud2Buf_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20OctreePointCloud2Buf_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static void __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_8radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_10VoxelSearch(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_12define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_14add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_16is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_18get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_20delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static void __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_4radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static void __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_4radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static void __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_4radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_4switchBuffers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_4define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_6add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_8is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_10get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_12delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_4define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_6add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_8is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_10get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_12delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_4define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_6add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_8is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_10get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_12delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point); /* proto */
+static int __pyx_pf_3pcl_4_pcl_8Vertices___cinit__(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, PyObject *__pyx_v_init); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_2__repr__(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_4from_array(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, PyArrayObject *__pyx_v_arr); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_6to_array(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_8from_list(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, PyObject *__pyx_v__list); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_10to_list(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_12resize(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, npy_intp __pyx_v_x); /* proto */
+static int __pyx_pf_3pcl_4_pcl_8CropHull___cinit__(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_8CropHull_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_6SetParameter(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_points, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_vt); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_8Filtering(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_outputCloud); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_10filter(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_7CropBox___cinit__(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_7CropBox_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_6set_Translation(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_tx, PyObject *__pyx_v_ty, PyObject *__pyx_v_tz); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_8set_Rotation(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_rx, PyObject *__pyx_v_ry, PyObject *__pyx_v_rz); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_10set_Min(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_minx, PyObject *__pyx_v_miny, PyObject *__pyx_v_minz, PyObject *__pyx_v_mins); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_12set_Max(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_maxx, PyObject *__pyx_v_maxy, PyObject *__pyx_v_maxz, PyObject *__pyx_v_maxs); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_14set_MinMax(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_minx, PyObject *__pyx_v_miny, PyObject *__pyx_v_minz, PyObject *__pyx_v_mins, PyObject *__pyx_v_maxx, PyObject *__pyx_v_maxy, PyObject *__pyx_v_maxz, PyObject *__pyx_v_maxs); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_16set_Negative(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, bool __pyx_v_flag); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_18get_Negative(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_20get_RemovedIndices(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_22filter(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_14ProjectInliers___cinit__(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_14ProjectInliers_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_4filter(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_6set_model_type(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self, enum pcl::SacModel __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_8get_model_type(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_10set_copy_all_data(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self, bool __pyx_v_m); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_12get_copy_all_data(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval___cinit__(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_4filter(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_6set_radius_search(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self, double __pyx_v_radius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_8get_radius_search(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_10set_MinNeighborsInRadius(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self, int __pyx_v_min_pts); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_12get_MinNeighborsInRadius(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_12ConditionAnd___cinit__(struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_12ConditionAnd_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_12ConditionAnd_4add_Comparison2(struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_self, PyObject *__pyx_v_field_name, pcl::ComparisonOps::CompareOp __pyx_v_compOp, double __pyx_v_thresh); /* proto */
+static int __pyx_pf_3pcl_4_pcl_18ConditionalRemoval___cinit__(struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_cond); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18ConditionalRemoval_2set_KeepOrganized(struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *__pyx_v_self, PyObject *__pyx_v_flag); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_18ConditionalRemoval_4filter(struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_11ConcaveHull___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_11ConcaveHull_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11ConcaveHull_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11ConcaveHull_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self, double __pyx_v_d); /* proto */
+static int __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self, double __pyx_v_d); /* proto */
+static int __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self, double __pyx_v_d); /* proto */
+static int __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self, double __pyx_v_d); /* proto */
+static int __pyx_pf_3pcl_4_pcl_11RangeImages___cinit__(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_2CreateFromPointCloud(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_cloud, float __pyx_v_angular_resolution, float __pyx_v_max_angle_width, float __pyx_v_max_angle_height, pcl::RangeImage::CoordinateFrame __pyx_v_coordinate_frame, float __pyx_v_noise_level, float __pyx_v_min_range, int __pyx_v_border_size); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_4SetAngularResolution(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self, float __pyx_v_angular_resolution_x, float __pyx_v_angular_resolution_y); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_6IntegrateFarRanges(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_viewpoint); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_8SetUnseenToMaxRange(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint___cinit__(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_4gicp(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, PyObject *__pyx_v_max_iter); /* proto */
+static int __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint___cinit__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_4set_InputTarget(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_cloud); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_6icp(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, PyObject *__pyx_v_max_iter); /* proto */
+static int __pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear___cinit__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear_4icp_nl(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, PyObject *__pyx_v_max_iter); /* proto */
+static int __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus___cinit__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *__pyx_v_model); /* proto */
+static int __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_2__cinit__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_v_model); /* proto */
+static int __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_4__cinit__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_v_model); /* proto */
+static void __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_6__dealloc__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_8computeModel(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_10set_DistanceThreshold(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, double __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_12get_Inliers(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_25SampleConsensusModelPlane___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static int __pyx_pf_3pcl_4_pcl_26SampleConsensusModelSphere___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static int __pyx_pf_3pcl_4_pcl_28SampleConsensusModelCylinder___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static int __pyx_pf_3pcl_4_pcl_24SampleConsensusModelLine___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static int __pyx_pf_3pcl_4_pcl_32SampleConsensusModelRegistration___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static int __pyx_pf_3pcl_4_pcl_25SampleConsensusModelStick___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static int __pyx_pf_3pcl_4_pcl_16NormalEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_16NormalEstimation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_4set_SearchMethod(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_6set_RadiusSearch(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self, double __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_8set_KSearch(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self, int __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_10compute(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_13VFHEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_13VFHEstimation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_13VFHEstimation_4set_SearchMethod(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_13VFHEstimation_6set_KSearch(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self, int __pyx_v_param); /* proto */
+static int __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_2set_NormalEstimation_Method_AVERAGE_3D_GRADIENT(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_4set_NormalEstimation_Method_COVARIANCE_MATRIX(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_6set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_8set_NormalEstimation_Method_SIMPLE_3D_GRADIENT(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_10set_MaxDepthChange_Factor(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, double __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_12set_NormalSmoothingSize(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, double __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_14compute(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_16compute2(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static int __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_4get_MomentOfInertia(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_6get_Eccentricity(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_8get_AABB(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_10get_EigenValues(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D___cinit__(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc); /* proto */
+static void __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_4set_NonMaxSupression(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, bool __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_6set_Radius(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, float __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_8set_RadiusSearch(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, double __pyx_v_param); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_10compute(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform___cinit__(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_4set_InputTarget(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_6set_Resolution(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self, float __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_8get_Resolution(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_10get_StepSize(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_12set_StepSize(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self, double __pyx_v_step_size); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_14get_OulierRatio(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_16set_OulierRatio(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self, double __pyx_v_outlier_ratio); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_18get_TransformationProbability(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_20get_FinalNumIteration(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_10PointCloud___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyObject *__pyx_v_init); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_10PointCloud_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags); /* proto */
+static void __pyx_pf_3pcl_4_pcl_10PointCloud_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyArrayObject *__pyx_v_arr); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyObject *__pyx_v__list); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, npy_intp __pyx_v_x); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, npy_intp __pyx_v_nmidx); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char *__pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_44make_ApproximateVoxelGrid(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_46make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_48make_moving_least_squares(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_50make_kdtree(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_52make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_54make_octree(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_56make_octreeSearch(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_58make_octreeChangeDetector(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, double __pyx_v_resolution); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_60make_crophull(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_62make_cropbox(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_64make_IntegralImageNormalEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_66extract(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_68make_ProjectInliers(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_70make_RadiusOutlierRemoval(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_72make_ConditionAnd(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_74make_ConditionalRemoval(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_range_conf); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_76make_ConcaveHull(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_78make_HarrisKeypoint3D(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_80make_NormalEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_82make_VFHEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_84make_RangeImage(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_86make_EuclideanClusterExtraction(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_88make_GeneralizedIterativeClosestPoint(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_90make_IterativeClosestPointNonLinear(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_92make_IterativeClosestPoint(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_94make_MomentOfInertiaEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyObject *__pyx_v_init); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags); /* proto */
+static void __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyArrayObject *__pyx_v_arr); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyObject *__pyx_v__list); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, npy_intp __pyx_v_x); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, npy_intp __pyx_v_nmidx); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char *__pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_44make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_46make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_48extract(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative); /* proto */
+static int __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_init); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags); /* proto */
+static void __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyArrayObject *__pyx_v_arr); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v__list); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, npy_intp __pyx_v_x); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, npy_intp __pyx_v_nmidx); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char *__pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_44make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_46make_moving_least_squares(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_48make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_50extract(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative); /* proto */
+static int __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_init); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static int __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags); /* proto */
+static void __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyArrayObject *__pyx_v_arr); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v__list); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, npy_intp __pyx_v_x); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, npy_intp __pyx_v_nmidx); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char *__pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_44make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_46make_moving_least_squares(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_48make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_50extract(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative); /* proto */
+static int __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, PyObject *__pyx_v_init); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, PyArrayObject *__pyx_v_arr); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_10to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_12from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, PyObject *__pyx_v__list); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_14to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_16resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, npy_intp __pyx_v_x); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_18get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_20__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, npy_intp __pyx_v_nmidx); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_22from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char *__pyx_v_f); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_24_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_26_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char const *__pyx_v_s); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_28to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii); /* proto */
+static int __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, PyObject *__pyx_v_init); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static void __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_4__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_6__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_8from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, PyArrayObject *__pyx_v_arr); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_10to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_12from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, PyObject *__pyx_v__list); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_14to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_16resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, npy_intp __pyx_v_x); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_18get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_20__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, npy_intp __pyx_v_nmidx); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_deg2rad(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha); /* proto */
+static PyObject *__pyx_pf_3pcl_4_pcl_2rad2deg(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha); /* proto */
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Vertices(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointWithViewpoint(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_Normal(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointNormal(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTree(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_RangeImages(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_IntegralImageNormalEstimation(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModel(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelPlane(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelSphere(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelCylinder(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelLine(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelRegistration(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelStick(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl__CythonCompareOp_Type(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl__CythonCoordinateFrame_Type(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SegmentationNormal(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZI_Normal(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_EuclideanClusterExtraction(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MovingLeastSquares(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_CropHull(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_CropBox(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ProjectInliers(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_RadiusOutlierRemoval(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConditionAnd(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConditionalRemoval(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_GeneralizedIterativeClosestPoint(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_IterativeClosestPoint(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_IterativeClosestPointNonLinear(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_RandomSampleConsensus(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_NormalEstimation(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VFHEstimation(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MomentOfInertiaEstimation(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_HarrisKeypoint3D(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_tp_new_3pcl_4_pcl_NormalDistributionsTransform(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
+static PyObject *__pyx_int_0;
+static PyObject *__pyx_int_1;
+static PyObject *__pyx_int_2;
+static PyObject *__pyx_int_3;
+static PyObject *__pyx_int_4;
+static PyObject *__pyx_int_5;
+static PyObject *__pyx_int_6;
+static PyObject *__pyx_int_7;
+static PyObject *__pyx_tuple_;
+static PyObject *__pyx_tuple__2;
+static PyObject *__pyx_tuple__3;
+static PyObject *__pyx_tuple__4;
+static PyObject *__pyx_tuple__5;
+static PyObject *__pyx_tuple__6;
+static PyObject *__pyx_tuple__7;
+static PyObject *__pyx_tuple__10;
+static PyObject *__pyx_tuple__11;
+static PyObject *__pyx_tuple__12;
+static PyObject *__pyx_tuple__13;
+static PyObject *__pyx_tuple__14;
+static PyObject *__pyx_tuple__15;
+static PyObject *__pyx_tuple__16;
+static PyObject *__pyx_tuple__17;
+static PyObject *__pyx_tuple__18;
+static PyObject *__pyx_tuple__19;
+static PyObject *__pyx_tuple__20;
+static PyObject *__pyx_tuple__21;
+static PyObject *__pyx_tuple__22;
+static PyObject *__pyx_tuple__23;
+static PyObject *__pyx_tuple__24;
+static PyObject *__pyx_tuple__25;
+static PyObject *__pyx_tuple__26;
+static PyObject *__pyx_tuple__27;
+static PyObject *__pyx_tuple__28;
+static PyObject *__pyx_tuple__29;
+static PyObject *__pyx_tuple__30;
+static PyObject *__pyx_tuple__31;
+static PyObject *__pyx_tuple__32;
+static PyObject *__pyx_tuple__33;
+static PyObject *__pyx_tuple__35;
+static PyObject *__pyx_codeobj__34;
+static PyObject *__pyx_codeobj__36;
+
+/* "pcl/_pcl_180.pyx":77
+ * 
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.GT = pcl_fil.COMPAREOP_GT
+ *         self.GE = pcl_fil.COMPAREOP_GE
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type___cinit__(((struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type___cinit__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/_pcl_180.pyx":78
+ * 
+ *     def __cinit__(self):
+ *         self.GT = pcl_fil.COMPAREOP_GT             # <<<<<<<<<<<<<<
+ *         self.GE = pcl_fil.COMPAREOP_GE
+ *         self.LT = pcl_fil.COMPAREOP_LT
+ */
+  __pyx_v_self->GT = pcl::ComparisonOps::GT;
+
+  /* "pcl/_pcl_180.pyx":79
+ *     def __cinit__(self):
+ *         self.GT = pcl_fil.COMPAREOP_GT
+ *         self.GE = pcl_fil.COMPAREOP_GE             # <<<<<<<<<<<<<<
+ *         self.LT = pcl_fil.COMPAREOP_LT
+ *         self.LE = pcl_fil.COMPAREOP_LE
+ */
+  __pyx_v_self->GE = pcl::ComparisonOps::GE;
+
+  /* "pcl/_pcl_180.pyx":80
+ *         self.GT = pcl_fil.COMPAREOP_GT
+ *         self.GE = pcl_fil.COMPAREOP_GE
+ *         self.LT = pcl_fil.COMPAREOP_LT             # <<<<<<<<<<<<<<
+ *         self.LE = pcl_fil.COMPAREOP_LE
+ *         self.EQ = pcl_fil.COMPAREOP_EQ
+ */
+  __pyx_v_self->LT = pcl::ComparisonOps::LT;
+
+  /* "pcl/_pcl_180.pyx":81
+ *         self.GE = pcl_fil.COMPAREOP_GE
+ *         self.LT = pcl_fil.COMPAREOP_LT
+ *         self.LE = pcl_fil.COMPAREOP_LE             # <<<<<<<<<<<<<<
+ *         self.EQ = pcl_fil.COMPAREOP_EQ
+ * 
+ */
+  __pyx_v_self->LE = pcl::ComparisonOps::LE;
+
+  /* "pcl/_pcl_180.pyx":82
+ *         self.LT = pcl_fil.COMPAREOP_LT
+ *         self.LE = pcl_fil.COMPAREOP_LE
+ *         self.EQ = pcl_fil.COMPAREOP_EQ             # <<<<<<<<<<<<<<
+ * 
+ * CythonCompareOp_Type = _CythonCompareOp_Type()
+ */
+  __pyx_v_self->EQ = pcl::ComparisonOps::EQ;
+
+  /* "pcl/_pcl_180.pyx":77
+ * 
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.GT = pcl_fil.COMPAREOP_GT
+ *         self.GE = pcl_fil.COMPAREOP_GE
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":70
+ * cdef class _CythonCompareOp_Type:
+ *     cdef:
+ *         readonly int GT             # <<<<<<<<<<<<<<
+ *         readonly int GE
+ *         readonly int LT
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2GT_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2GT_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2GT___get__(((struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2GT___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->GT); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl._CythonCompareOp_Type.GT.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":71
+ *     cdef:
+ *         readonly int GT
+ *         readonly int GE             # <<<<<<<<<<<<<<
+ *         readonly int LT
+ *         readonly int LE
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2GE_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2GE_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2GE___get__(((struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2GE___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->GE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl._CythonCompareOp_Type.GE.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":72
+ *         readonly int GT
+ *         readonly int GE
+ *         readonly int LT             # <<<<<<<<<<<<<<
+ *         readonly int LE
+ *         readonly int EQ
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2LT_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2LT_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2LT___get__(((struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2LT___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->LT); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl._CythonCompareOp_Type.LT.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":73
+ *         readonly int GE
+ *         readonly int LT
+ *         readonly int LE             # <<<<<<<<<<<<<<
+ *         readonly int EQ
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2LE_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2LE_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2LE___get__(((struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2LE___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->LE); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 73, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl._CythonCompareOp_Type.LE.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":74
+ *         readonly int LT
+ *         readonly int LE
+ *         readonly int EQ             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2EQ_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2EQ_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2EQ___get__(((struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21_CythonCompareOp_Type_2EQ___get__(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->EQ); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl._CythonCompareOp_Type.EQ.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":94
+ *         readonly int LASER_FRAME
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.CAMERA_FRAME = pcl_r_img.COORDINATEFRAME_CAMERA
+ *         self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type___cinit__(((struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type___cinit__(struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/_pcl_180.pyx":95
+ * 
+ *     def __cinit__(self):
+ *         self.CAMERA_FRAME = pcl_r_img.COORDINATEFRAME_CAMERA             # <<<<<<<<<<<<<<
+ *         self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER
+ * 
+ */
+  __pyx_v_self->CAMERA_FRAME = pcl::RangeImage::CAMERA_FRAME;
+
+  /* "pcl/_pcl_180.pyx":96
+ *     def __cinit__(self):
+ *         self.CAMERA_FRAME = pcl_r_img.COORDINATEFRAME_CAMERA
+ *         self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER             # <<<<<<<<<<<<<<
+ * 
+ * CythonCoordinateFrame_Type = _CythonCoordinateFrame_Type()
+ */
+  __pyx_v_self->LASER_FRAME = pcl::RangeImage::LASER_FRAME;
+
+  /* "pcl/_pcl_180.pyx":94
+ *         readonly int LASER_FRAME
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.CAMERA_FRAME = pcl_r_img.COORDINATEFRAME_CAMERA
+ *         self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":91
+ * cdef class _CythonCoordinateFrame_Type:
+ *     cdef:
+ *         readonly int CAMERA_FRAME             # <<<<<<<<<<<<<<
+ *         readonly int LASER_FRAME
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_12CAMERA_FRAME_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_12CAMERA_FRAME_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type_12CAMERA_FRAME___get__(((struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type_12CAMERA_FRAME___get__(struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->CAMERA_FRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl._CythonCoordinateFrame_Type.CAMERA_FRAME.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":92
+ *     cdef:
+ *         readonly int CAMERA_FRAME
+ *         readonly int LASER_FRAME             # <<<<<<<<<<<<<<
+ * 
+ *     def __cinit__(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_11LASER_FRAME_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_11LASER_FRAME_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type_11LASER_FRAME___get__(((struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_27_CythonCoordinateFrame_Type_11LASER_FRAME___get__(struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->LASER_FRAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl._CythonCoordinateFrame_Type.LASER_FRAME.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointXYZtoPointXYZ.pxi":5
+ * cimport numpy as np
+ * 
+ * cdef cpp.PointXYZ to_point_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZ p
+ *     # check point datasize
+ */
+
+static struct pcl::PointXYZ __pyx_f_3pcl_4_pcl_to_point_t(PyObject *__pyx_v_point) {
+  struct pcl::PointXYZ __pyx_v_p;
+  struct pcl::PointXYZ __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  float __pyx_t_6;
+  __Pyx_RefNannySetupContext("to_point_t", 0);
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":11
+ *     # http://stackoverflow.com/questions/15003403/typeerror-a-float-is-required
+ *     # TypeError: float() argument must be a string or a number, not 'tuple'
+ *     p.x = np.float(point[0])             # <<<<<<<<<<<<<<
+ *     p.y = np.float(point[1])
+ *     p.z = np.float(point[2])
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 11, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 11, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 11, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 11, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 11, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_2);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
+      __pyx_t_2 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 11, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 11, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.x = __pyx_t_6;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":12
+ *     # TypeError: float() argument must be a string or a number, not 'tuple'
+ *     p.x = np.float(point[0])
+ *     p.y = np.float(point[1])             # <<<<<<<<<<<<<<
+ *     p.z = np.float(point[2])
+ *     return p
+ */
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_float); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(5, 12, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_5, function);
+    }
+  }
+  if (!__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 12, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 12, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 12, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 12, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 12, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 12, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.y = __pyx_t_6;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":13
+ *     p.x = np.float(point[0])
+ *     p.y = np.float(point[1])
+ *     p.z = np.float(point[2])             # <<<<<<<<<<<<<<
+ *     return p
+ * 
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 13, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float); if (unlikely(!__pyx_t_4)) __PYX_ERR(5, 13, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(5, 13, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 13, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 13, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_5};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 13, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(5, 13, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_GIVEREF(__pyx_t_5);
+      PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_5);
+      __pyx_t_5 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 13, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 13, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.z = __pyx_t_6;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":14
+ *     p.y = np.float(point[1])
+ *     p.z = np.float(point[2])
+ *     return p             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_p;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":5
+ * cimport numpy as np
+ * 
+ * cdef cpp.PointXYZ to_point_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZ p
+ *     # check point datasize
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_WriteUnraisable("pcl._pcl.to_point_t", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointXYZtoPointXYZ.pxi":17
+ * 
+ * 
+ * cdef cpp.PointXYZI to_point2_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZI p
+ *     # check point datasize
+ */
+
+static struct pcl::PointXYZI __pyx_f_3pcl_4_pcl_to_point2_t(PyObject *__pyx_v_point) {
+  struct pcl::PointXYZI __pyx_v_p;
+  struct pcl::PointXYZI __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  float __pyx_t_2;
+  __Pyx_RefNannySetupContext("to_point2_t", 0);
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":20
+ *     cdef cpp.PointXYZI p
+ *     # check point datasize
+ *     p.x = point[0]             # <<<<<<<<<<<<<<
+ *     p.y = point[1]
+ *     p.z = point[2]
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 20, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.x = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":21
+ *     # check point datasize
+ *     p.x = point[0]
+ *     p.y = point[1]             # <<<<<<<<<<<<<<
+ *     p.z = point[2]
+ *     p.intensity = point[3]
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 21, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.y = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":22
+ *     p.x = point[0]
+ *     p.y = point[1]
+ *     p.z = point[2]             # <<<<<<<<<<<<<<
+ *     p.intensity = point[3]
+ *     return p
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 22, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.z = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":23
+ *     p.y = point[1]
+ *     p.z = point[2]
+ *     p.intensity = point[3]             # <<<<<<<<<<<<<<
+ *     return p
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 23, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 23, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.intensity = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":24
+ *     p.z = point[2]
+ *     p.intensity = point[3]
+ *     return p             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_p;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":17
+ * 
+ * 
+ * cdef cpp.PointXYZI to_point2_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZI p
+ *     # check point datasize
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_WriteUnraisable("pcl._pcl.to_point2_t", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointXYZtoPointXYZ.pxi":27
+ * 
+ * 
+ * cdef cpp.PointXYZRGB to_point3_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZRGB p
+ * 
+ */
+
+static struct pcl::PointXYZRGB __pyx_f_3pcl_4_pcl_to_point3_t(PyObject *__pyx_v_point) {
+  struct pcl::PointXYZRGB __pyx_v_p;
+  struct pcl::PointXYZRGB __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  float __pyx_t_2;
+  __Pyx_RefNannySetupContext("to_point3_t", 0);
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":31
+ * 
+ *     # check point datasize
+ *     p.x = point[0]             # <<<<<<<<<<<<<<
+ *     p.y = point[1]
+ *     p.z = point[2]
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 31, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.x = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":32
+ *     # check point datasize
+ *     p.x = point[0]
+ *     p.y = point[1]             # <<<<<<<<<<<<<<
+ *     p.z = point[2]
+ *     p.rgb = point[3]
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 32, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.y = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":33
+ *     p.x = point[0]
+ *     p.y = point[1]
+ *     p.z = point[2]             # <<<<<<<<<<<<<<
+ *     p.rgb = point[3]
+ *     return p
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 33, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 33, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.z = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":34
+ *     p.y = point[1]
+ *     p.z = point[2]
+ *     p.rgb = point[3]             # <<<<<<<<<<<<<<
+ *     return p
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 34, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.rgb = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":35
+ *     p.z = point[2]
+ *     p.rgb = point[3]
+ *     return p             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_p;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":27
+ * 
+ * 
+ * cdef cpp.PointXYZRGB to_point3_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZRGB p
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_WriteUnraisable("pcl._pcl.to_point3_t", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointXYZtoPointXYZ.pxi":38
+ * 
+ * 
+ * cdef cpp.PointXYZRGBA to_point4_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZRGBA p
+ * 
+ */
+
+static struct pcl::PointXYZRGBA __pyx_f_3pcl_4_pcl_to_point4_t(PyObject *__pyx_v_point) {
+  struct pcl::PointXYZRGBA __pyx_v_p;
+  struct pcl::PointXYZRGBA __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  float __pyx_t_2;
+  __Pyx_RefNannySetupContext("to_point4_t", 0);
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":42
+ * 
+ *     # check point datasize
+ *     p.x = point[0]             # <<<<<<<<<<<<<<
+ *     p.y = point[1]
+ *     p.z = point[2]
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 42, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.x = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":43
+ *     # check point datasize
+ *     p.x = point[0]
+ *     p.y = point[1]             # <<<<<<<<<<<<<<
+ *     p.z = point[2]
+ *     p.rgba = point[3]
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 43, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.y = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":44
+ *     p.x = point[0]
+ *     p.y = point[1]
+ *     p.z = point[2]             # <<<<<<<<<<<<<<
+ *     p.rgba = point[3]
+ *     return p
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.z = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":45
+ *     p.y = point[1]
+ *     p.z = point[2]
+ *     p.rgba = point[3]             # <<<<<<<<<<<<<<
+ *     return p
+ */
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(5, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(5, 45, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_p.rgba = __pyx_t_2;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":46
+ *     p.z = point[2]
+ *     p.rgba = point[3]
+ *     return p             # <<<<<<<<<<<<<<
+ */
+  __pyx_r = __pyx_v_p;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointXYZtoPointXYZ.pxi":38
+ * 
+ * 
+ * cdef cpp.PointXYZRGBA to_point4_t(point):             # <<<<<<<<<<<<<<
+ *     cdef cpp.PointXYZRGBA p
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_WriteUnraisable("pcl._pcl.to_point4_t", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":11
+ *     """
+ *     cdef pclseg.SACSegmentation_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_12Segmentation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_12Segmentation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12Segmentation___cinit__(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_12Segmentation___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":12
+ *     cdef pclseg.SACSegmentation_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_t();
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":11
+ *     """
+ *     cdef pclseg.SACSegmentation_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":13
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_12Segmentation_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_12Segmentation_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_12Segmentation_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_12Segmentation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":14
+ *         self.me = new pclseg.SACSegmentation_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":13
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":16
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_12Segmentation_4segment[] = "Segmentation.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12Segmentation_4segment(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":20
+ *         cdef cpp.ModelCoefficients coeffs
+ * 
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":21
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 21, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":22
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 22, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 22, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 22, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":21
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":16
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":24
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_12Segmentation_6set_optimize_coefficients[] = "Segmentation.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 24, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12Segmentation_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":25
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":24
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":26
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_12Segmentation_8set_model_type[] = "Segmentation.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12Segmentation_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":27
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":26
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":28
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_12Segmentation_10set_method_type[] = "Segmentation.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 28, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12Segmentation_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":29
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":28
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":30
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_MaxIterations(self, int count):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_12Segmentation_12set_distance_threshold[] = "Segmentation.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12Segmentation_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":31
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ *     def set_MaxIterations(self, int count):
+ *         self.me.setMaxIterations (count)
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":30
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_MaxIterations(self, int count):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":32
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_MaxIterations(self, int count):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (count)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_15set_MaxIterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_count); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_12Segmentation_14set_MaxIterations[] = "Segmentation.set_MaxIterations(self, int count)";
+static PyObject *__pyx_pw_3pcl_4_pcl_12Segmentation_15set_MaxIterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_count) {
+  int __pyx_v_count;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MaxIterations (wrapper)", 0);
+  assert(__pyx_arg_count); {
+    __pyx_v_count = __Pyx_PyInt_As_int(__pyx_arg_count); if (unlikely((__pyx_v_count == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 32, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation.set_MaxIterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12Segmentation_14set_MaxIterations(((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_v_self), ((int)__pyx_v_count));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_12Segmentation_14set_MaxIterations(struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_self, int __pyx_v_count) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MaxIterations", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":33
+ *         self.me.setDistanceThreshold (d)
+ *     def set_MaxIterations(self, int count):
+ *         self.me.setMaxIterations (count)             # <<<<<<<<<<<<<<
+ * 
+ * cdef class Segmentation_PointXYZI:
+ */
+  __pyx_v_self->me->setMaxIterations(__pyx_v_count);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":32
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_MaxIterations(self, int count):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (count)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":40
+ *     """
+ *     cdef pclseg.SACSegmentation_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":41
+ *     cdef pclseg.SACSegmentation_PointXYZI_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZI_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZI_t();
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":40
+ *     """
+ *     cdef pclseg.SACSegmentation_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":42
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":43
+ *         self.me = new pclseg.SACSegmentation_PointXYZI_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":42
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":45
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_4segment[] = "Segmentation_PointXYZI.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_4segment(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":49
+ *         cdef cpp.ModelCoefficients coeffs
+ * 
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":50
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 50, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":51
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 51, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":50
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":45
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":53
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_6set_optimize_coefficients[] = "Segmentation_PointXYZI.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":54
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":53
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":55
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_8set_model_type[] = "Segmentation_PointXYZI.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 55, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":56
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":55
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":57
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_10set_method_type[] = "Segmentation_PointXYZI.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 57, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":58
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":57
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":59
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_12set_distance_threshold[] = "Segmentation_PointXYZI.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 59, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22Segmentation_PointXYZI_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":60
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":59
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":68
+ *     """
+ *     cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":69
+ *     cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGB_t();
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":68
+ *     """
+ *     cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":70
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":71
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":70
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":73
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_4segment[] = "Segmentation_PointXYZRGB.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_4segment(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":77
+ *         cdef cpp.ModelCoefficients coeffs
+ * 
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":78
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 78, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 78, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":79
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 79, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 79, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":78
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":73
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":81
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_6set_optimize_coefficients[] = "Segmentation_PointXYZRGB.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 81, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":82
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":81
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":83
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_8set_model_type[] = "Segmentation_PointXYZRGB.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 83, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":84
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":83
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":85
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_10set_method_type[] = "Segmentation_PointXYZRGB.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":86
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":85
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":87
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_12set_distance_threshold[] = "Segmentation_PointXYZRGB.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24Segmentation_PointXYZRGB_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":88
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":87
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":96
+ *     """
+ *     cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":97
+ *     cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":96
+ *     """
+ *     cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":98
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":99
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":98
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":101
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_4segment[] = "Segmentation_PointXYZRGBA.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_4segment(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":105
+ *         cdef cpp.ModelCoefficients coeffs
+ * 
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":106
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 106, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 106, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":107
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 107, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 107, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":106
+ * 
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())], \             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":101
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":109
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_6set_optimize_coefficients[] = "Segmentation_PointXYZRGBA.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(0, 109, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":110
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":109
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":111
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_8set_model_type[] = "Segmentation_PointXYZRGBA.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":112
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":111
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":113
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_10set_method_type[] = "Segmentation_PointXYZRGBA.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":114
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":113
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/Segmentation.pxi":115
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_12set_distance_threshold[] = "Segmentation_PointXYZRGBA.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 115, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25Segmentation_PointXYZRGBA_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":116
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ * 
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/Segmentation.pxi":115
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":27
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_18SegmentationNormal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_18SegmentationNormal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal___cinit__(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_18SegmentationNormal___cinit__(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":28
+ *     cdef pclseg.SACSegmentationFromNormals_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentationFromNormals_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_t();
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":27
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":30
+ *         self.me = new pclseg.SACSegmentationFromNormals_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_18SegmentationNormal_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_18SegmentationNormal_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_18SegmentationNormal_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_18SegmentationNormal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":31
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":30
+ *         self.me = new pclseg.SACSegmentationFromNormals_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":33
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_4segment[] = "SegmentationNormal.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_4segment(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_4segment(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":36
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":37
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(6, 37, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":38
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 38, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(6, 38, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":37
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":33
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":40
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_6set_optimize_coefficients[] = "SegmentationNormal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 40, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":41
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":40
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":42
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_8set_model_type[] = "SegmentationNormal.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 42, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":43
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":42
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":44
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_10set_method_type[] = "SegmentationNormal.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 44, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":45
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":44
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":46
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_12set_distance_threshold[] = "SegmentationNormal.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 46, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":47
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":46
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":48
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_14set_optimize_coefficients[] = "SegmentationNormal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 48, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_14set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":49
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)             # <<<<<<<<<<<<<<
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":48
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":50
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_16set_normal_distance_weight[] = "SegmentationNormal.set_normal_distance_weight(self, float f)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  float __pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __pyx_PyFloat_AsFloat(__pyx_arg_f); if (unlikely((__pyx_v_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 50, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_normal_distance_weight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_16set_normal_distance_weight(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((float)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, float __pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":51
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)             # <<<<<<<<<<<<<<
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ */
+  __pyx_v_self->me->setNormalDistanceWeight(__pyx_v_f);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":50
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":52
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_18set_max_iterations[] = "SegmentationNormal.set_max_iterations(self, int i)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i) {
+  int __pyx_v_i;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations (wrapper)", 0);
+  assert(__pyx_arg_i); {
+    __pyx_v_i = __Pyx_PyInt_As_int(__pyx_arg_i); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 52, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_max_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_18set_max_iterations(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((int)__pyx_v_i));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, int __pyx_v_i) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":53
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)             # <<<<<<<<<<<<<<
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ */
+  __pyx_v_self->me->setMaxIterations(__pyx_v_i);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":52
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":54
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_20set_radius_limits[] = "SegmentationNormal.set_radius_limits(self, float f1, float f2)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_f1;
+  float __pyx_v_f2;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f1,&__pyx_n_s_f2,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f1)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f2)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, 1); __PYX_ERR(6, 54, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_radius_limits") < 0)) __PYX_ERR(6, 54, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_f1 = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_f1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 54, __pyx_L3_error)
+    __pyx_v_f2 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_f2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 54, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 54, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_radius_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_20set_radius_limits(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), __pyx_v_f1, __pyx_v_f2);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":55
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)             # <<<<<<<<<<<<<<
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)
+ */
+  __pyx_v_self->me->setRadiusLimits(__pyx_v_f1, __pyx_v_f2);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":54
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":56
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_22set_eps_angle[] = "SegmentationNormal.set_eps_angle(self, double ea)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea) {
+  double __pyx_v_ea;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle (wrapper)", 0);
+  assert(__pyx_arg_ea); {
+    __pyx_v_ea = __pyx_PyFloat_AsDouble(__pyx_arg_ea); if (unlikely((__pyx_v_ea == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 56, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_eps_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_22set_eps_angle(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), ((double)__pyx_v_ea));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, double __pyx_v_ea) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":57
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)             # <<<<<<<<<<<<<<
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ */
+  __pyx_v_self->me->setEpsAngle(__pyx_v_ea);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":56
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":60
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_24set_min_max_opening_angle[] = "SegmentationNormal.set_min_max_opening_angle(self, double min_angle, double max_angle)\n Set the minimum and maximum cone opening angles in radians for a cone model.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_min_angle,&__pyx_n_s_max_angle,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_min_angle)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_angle)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, 1); __PYX_ERR(6, 60, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_min_max_opening_angle") < 0)) __PYX_ERR(6, 60, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_min_angle = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_min_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 60, __pyx_L3_error)
+    __pyx_v_max_angle = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_max_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 60, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 60, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.set_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_24set_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self), __pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":63
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ */
+  __pyx_v_self->me->setMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":60
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":64
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18SegmentationNormal_26get_min_max_opening_angle[] = "SegmentationNormal.get_min_max_opening_angle(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18SegmentationNormal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18SegmentationNormal_26get_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18SegmentationNormal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_self) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":65
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0             # <<<<<<<<<<<<<<
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ */
+  __pyx_v_min_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":66
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ *         max_angle = 0.0             # <<<<<<<<<<<<<<
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle
+ */
+  __pyx_v_max_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":67
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *         return min_angle, max_angle
+ * 
+ */
+  __pyx_v_self->me->getMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":68
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_min_angle); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_max_angle); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":64
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.SegmentationNormal.get_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":80
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZI_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal___cinit__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":81
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZI_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZI_t();
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":80
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZI_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":83
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZI_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":84
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":83
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZI_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":86
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_4segment[] = "Segmentation_PointXYZI_Normal.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_4segment(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":89
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":90
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 90, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(6, 90, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":91
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 91, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(6, 91, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":90
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":86
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":93
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_6set_optimize_coefficients[] = "Segmentation_PointXYZI_Normal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 93, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":94
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":93
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":95
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_8set_model_type[] = "Segmentation_PointXYZI_Normal.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 95, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":96
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":95
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":97
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_10set_method_type[] = "Segmentation_PointXYZI_Normal.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 97, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":98
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":97
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":99
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_12set_distance_threshold[] = "Segmentation_PointXYZI_Normal.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 99, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":100
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":99
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":101
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_14set_optimize_coefficients[] = "Segmentation_PointXYZI_Normal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 101, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_14set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":102
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)             # <<<<<<<<<<<<<<
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":101
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":103
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_16set_normal_distance_weight[] = "Segmentation_PointXYZI_Normal.set_normal_distance_weight(self, float f)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  float __pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __pyx_PyFloat_AsFloat(__pyx_arg_f); if (unlikely((__pyx_v_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 103, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_normal_distance_weight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_16set_normal_distance_weight(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((float)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, float __pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":104
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)             # <<<<<<<<<<<<<<
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ */
+  __pyx_v_self->me->setNormalDistanceWeight(__pyx_v_f);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":103
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":105
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_18set_max_iterations[] = "Segmentation_PointXYZI_Normal.set_max_iterations(self, int i)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i) {
+  int __pyx_v_i;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations (wrapper)", 0);
+  assert(__pyx_arg_i); {
+    __pyx_v_i = __Pyx_PyInt_As_int(__pyx_arg_i); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 105, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_max_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_18set_max_iterations(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((int)__pyx_v_i));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, int __pyx_v_i) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":106
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)             # <<<<<<<<<<<<<<
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ */
+  __pyx_v_self->me->setMaxIterations(__pyx_v_i);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":105
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":107
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_20set_radius_limits[] = "Segmentation_PointXYZI_Normal.set_radius_limits(self, float f1, float f2)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_f1;
+  float __pyx_v_f2;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f1,&__pyx_n_s_f2,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f1)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f2)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, 1); __PYX_ERR(6, 107, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_radius_limits") < 0)) __PYX_ERR(6, 107, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_f1 = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_f1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 107, __pyx_L3_error)
+    __pyx_v_f2 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_f2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 107, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 107, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_radius_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_20set_radius_limits(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), __pyx_v_f1, __pyx_v_f2);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":108
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)             # <<<<<<<<<<<<<<
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)
+ */
+  __pyx_v_self->me->setRadiusLimits(__pyx_v_f1, __pyx_v_f2);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":107
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":109
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_22set_eps_angle[] = "Segmentation_PointXYZI_Normal.set_eps_angle(self, double ea)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea) {
+  double __pyx_v_ea;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle (wrapper)", 0);
+  assert(__pyx_arg_ea); {
+    __pyx_v_ea = __pyx_PyFloat_AsDouble(__pyx_arg_ea); if (unlikely((__pyx_v_ea == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 109, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_eps_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_22set_eps_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), ((double)__pyx_v_ea));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, double __pyx_v_ea) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":110
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)             # <<<<<<<<<<<<<<
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ */
+  __pyx_v_self->me->setEpsAngle(__pyx_v_ea);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":109
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":113
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_24set_min_max_opening_angle[] = "Segmentation_PointXYZI_Normal.set_min_max_opening_angle(self, double min_angle, double max_angle)\n Set the minimum and maximum cone opening angles in radians for a cone model.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_min_angle,&__pyx_n_s_max_angle,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_min_angle)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_angle)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, 1); __PYX_ERR(6, 113, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_min_max_opening_angle") < 0)) __PYX_ERR(6, 113, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_min_angle = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_min_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 113, __pyx_L3_error)
+    __pyx_v_max_angle = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_max_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 113, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 113, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.set_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_24set_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self), __pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":116
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ */
+  __pyx_v_self->me->setMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":113
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":117
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_26get_min_max_opening_angle[] = "Segmentation_PointXYZI_Normal.get_min_max_opening_angle(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_26get_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_self) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":118
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0             # <<<<<<<<<<<<<<
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ */
+  __pyx_v_min_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":119
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ *         max_angle = 0.0             # <<<<<<<<<<<<<<
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle
+ */
+  __pyx_v_max_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":120
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *         return min_angle, max_angle
+ * 
+ */
+  __pyx_v_self->me->getMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":121
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_min_angle); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_max_angle); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 121, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":117
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZI_Normal.get_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":133
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGB_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal___cinit__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":134
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGB_t();
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":133
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGB_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":136
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGB_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":137
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":136
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGB_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":139
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_4segment[] = "Segmentation_PointXYZRGB_Normal.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_4segment(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":142
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":143
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 143, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(6, 143, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":144
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 144, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(6, 144, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":143
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":139
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":146
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_6set_optimize_coefficients[] = "Segmentation_PointXYZRGB_Normal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 146, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":147
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":146
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":148
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_8set_model_type[] = "Segmentation_PointXYZRGB_Normal.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 148, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":149
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":148
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":150
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_10set_method_type[] = "Segmentation_PointXYZRGB_Normal.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 150, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":151
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":150
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":152
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_12set_distance_threshold[] = "Segmentation_PointXYZRGB_Normal.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 152, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":153
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":152
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":154
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_14set_optimize_coefficients[] = "Segmentation_PointXYZRGB_Normal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 154, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_14set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":155
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)             # <<<<<<<<<<<<<<
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":154
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":156
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_16set_normal_distance_weight[] = "Segmentation_PointXYZRGB_Normal.set_normal_distance_weight(self, float f)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  float __pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __pyx_PyFloat_AsFloat(__pyx_arg_f); if (unlikely((__pyx_v_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 156, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_normal_distance_weight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_16set_normal_distance_weight(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((float)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, float __pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":157
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)             # <<<<<<<<<<<<<<
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ */
+  __pyx_v_self->me->setNormalDistanceWeight(__pyx_v_f);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":156
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":158
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_18set_max_iterations[] = "Segmentation_PointXYZRGB_Normal.set_max_iterations(self, int i)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i) {
+  int __pyx_v_i;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations (wrapper)", 0);
+  assert(__pyx_arg_i); {
+    __pyx_v_i = __Pyx_PyInt_As_int(__pyx_arg_i); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 158, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_max_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_18set_max_iterations(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((int)__pyx_v_i));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, int __pyx_v_i) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":159
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)             # <<<<<<<<<<<<<<
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ */
+  __pyx_v_self->me->setMaxIterations(__pyx_v_i);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":158
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":160
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_20set_radius_limits[] = "Segmentation_PointXYZRGB_Normal.set_radius_limits(self, float f1, float f2)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_f1;
+  float __pyx_v_f2;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f1,&__pyx_n_s_f2,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f1)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f2)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, 1); __PYX_ERR(6, 160, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_radius_limits") < 0)) __PYX_ERR(6, 160, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_f1 = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_f1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 160, __pyx_L3_error)
+    __pyx_v_f2 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_f2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 160, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 160, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_radius_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_20set_radius_limits(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), __pyx_v_f1, __pyx_v_f2);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":161
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)             # <<<<<<<<<<<<<<
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)
+ */
+  __pyx_v_self->me->setRadiusLimits(__pyx_v_f1, __pyx_v_f2);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":160
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":162
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_22set_eps_angle[] = "Segmentation_PointXYZRGB_Normal.set_eps_angle(self, double ea)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea) {
+  double __pyx_v_ea;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle (wrapper)", 0);
+  assert(__pyx_arg_ea); {
+    __pyx_v_ea = __pyx_PyFloat_AsDouble(__pyx_arg_ea); if (unlikely((__pyx_v_ea == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 162, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_eps_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_22set_eps_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), ((double)__pyx_v_ea));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, double __pyx_v_ea) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":163
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)             # <<<<<<<<<<<<<<
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ */
+  __pyx_v_self->me->setEpsAngle(__pyx_v_ea);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":162
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":166
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_24set_min_max_opening_angle[] = "Segmentation_PointXYZRGB_Normal.set_min_max_opening_angle(self, double min_angle, double max_angle)\n Set the minimum and maximum cone opening angles in radians for a cone model.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_min_angle,&__pyx_n_s_max_angle,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_min_angle)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_angle)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, 1); __PYX_ERR(6, 166, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_min_max_opening_angle") < 0)) __PYX_ERR(6, 166, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_min_angle = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_min_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 166, __pyx_L3_error)
+    __pyx_v_max_angle = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_max_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 166, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 166, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.set_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_24set_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self), __pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":169
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ */
+  __pyx_v_self->me->setMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":166
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":170
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_26get_min_max_opening_angle[] = "Segmentation_PointXYZRGB_Normal.get_min_max_opening_angle(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_26get_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_self) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":171
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0             # <<<<<<<<<<<<<<
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ */
+  __pyx_v_min_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":172
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ *         max_angle = 0.0             # <<<<<<<<<<<<<<
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle
+ */
+  __pyx_v_max_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":173
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *         return min_angle, max_angle
+ * 
+ */
+  __pyx_v_self->me->getMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":174
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_min_angle); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_max_angle); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 174, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":170
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGB_Normal.get_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":186
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGBA_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal___cinit__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal___cinit__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":187
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":186
+ *     """
+ *     cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGBA_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":189
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGBA_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":190
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def segment(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":189
+ *         self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGBA_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":192
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_4segment[] = "Segmentation_PointXYZRGBA_Normal.segment(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_5segment(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("segment (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_4segment(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_4segment(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self) {
+  pcl::PointIndices __pyx_v_ind;
+  struct pcl::ModelCoefficients __pyx_v_coeffs;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("segment", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":195
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)             # <<<<<<<<<<<<<<
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ */
+  __pyx_v_self->me->segment(__pyx_v_ind, __pyx_v_coeffs);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":196
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_ind.indices.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_ind.indices[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 196, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(6, 196, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":197
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]             # <<<<<<<<<<<<<<
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ */
+  __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(6, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = __pyx_v_coeffs.values.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_coeffs.values[__pyx_v_i])); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 197, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(6, 197, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":196
+ *         cdef cpp.ModelCoefficients coeffs
+ *         self.me.segment (ind, coeffs)
+ *         return [ind.indices[i] for i in range(ind.indices.size())],\             # <<<<<<<<<<<<<<
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ */
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(6, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":192
+ *         del self.me
+ * 
+ *     def segment(self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointIndices ind
+ *         cdef cpp.ModelCoefficients coeffs
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.segment", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":199
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_6set_optimize_coefficients[] = "Segmentation_PointXYZRGBA_Normal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_7set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 199, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_6set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_6set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":200
+ * 
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)             # <<<<<<<<<<<<<<
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":199
+ *                [coeffs.values[i] for i in range(coeffs.values.size())]
+ * 
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":201
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_8set_model_type[] = "Segmentation_PointXYZRGBA_Normal.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_9set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(6, 201, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_8set_model_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_8set_model_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":202
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ */
+  __pyx_v_self->me->setModelType(((enum pcl::SacModel)__pyx_v_m));
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":201
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients(b)
+ *     def set_model_type(self, pcl_sc.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":203
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_10set_method_type[] = "Segmentation_PointXYZRGBA_Normal.set_method_type(self, int m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_11set_method_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  int __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyInt_As_int(__pyx_arg_m); if (unlikely((__pyx_v_m == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 203, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_method_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_10set_method_type(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((int)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_10set_method_type(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, int __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_method_type", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":204
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)             # <<<<<<<<<<<<<<
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ */
+  __pyx_v_self->me->setMethodType(__pyx_v_m);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":203
+ *     def set_model_type(self, pcl_sc.SacModel m):
+ *         self.me.setModelType(m)
+ *     def set_method_type(self, int m):             # <<<<<<<<<<<<<<
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":205
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_12set_distance_threshold[] = "Segmentation_PointXYZRGBA_Normal.set_distance_threshold(self, float d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_13set_distance_threshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  float __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsFloat(__pyx_arg_d); if (unlikely((__pyx_v_d == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 205, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_distance_threshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_12set_distance_threshold(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((float)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_12set_distance_threshold(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, float __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_distance_threshold", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":206
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)             # <<<<<<<<<<<<<<
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_d);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":205
+ *     def set_method_type(self, int m):
+ *         self.me.setMethodType (m)
+ *     def set_distance_threshold(self, float d):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":207
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_14set_optimize_coefficients[] = "Segmentation_PointXYZRGBA_Normal.set_optimize_coefficients(self, bool b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_15set_optimize_coefficients(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  bool __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __Pyx_PyObject_IsTrue(__pyx_arg_b); if (unlikely((__pyx_v_b == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(6, 207, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_optimize_coefficients", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_14set_optimize_coefficients(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((bool)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_14set_optimize_coefficients(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, bool __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_optimize_coefficients", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":208
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)             # <<<<<<<<<<<<<<
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ */
+  __pyx_v_self->me->setOptimizeCoefficients(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":207
+ *     def set_distance_threshold(self, float d):
+ *         self.me.setDistanceThreshold (d)
+ *     def set_optimize_coefficients(self, bool b):             # <<<<<<<<<<<<<<
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":209
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_16set_normal_distance_weight[] = "Segmentation_PointXYZRGBA_Normal.set_normal_distance_weight(self, float f)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_17set_normal_distance_weight(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  float __pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __pyx_PyFloat_AsFloat(__pyx_arg_f); if (unlikely((__pyx_v_f == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 209, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_normal_distance_weight", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_16set_normal_distance_weight(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((float)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_16set_normal_distance_weight(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, float __pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_normal_distance_weight", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":210
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)             # <<<<<<<<<<<<<<
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ */
+  __pyx_v_self->me->setNormalDistanceWeight(__pyx_v_f);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":209
+ *     def set_optimize_coefficients(self, bool b):
+ *         self.me.setOptimizeCoefficients (b)
+ *     def set_normal_distance_weight(self, float f):             # <<<<<<<<<<<<<<
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":211
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_18set_max_iterations[] = "Segmentation_PointXYZRGBA_Normal.set_max_iterations(self, int i)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_19set_max_iterations(PyObject *__pyx_v_self, PyObject *__pyx_arg_i) {
+  int __pyx_v_i;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations (wrapper)", 0);
+  assert(__pyx_arg_i); {
+    __pyx_v_i = __Pyx_PyInt_As_int(__pyx_arg_i); if (unlikely((__pyx_v_i == (int)-1) && PyErr_Occurred())) __PYX_ERR(6, 211, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_max_iterations", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_18set_max_iterations(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((int)__pyx_v_i));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_18set_max_iterations(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, int __pyx_v_i) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_max_iterations", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":212
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)             # <<<<<<<<<<<<<<
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ */
+  __pyx_v_self->me->setMaxIterations(__pyx_v_i);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":211
+ *     def set_normal_distance_weight(self, float f):
+ *         self.me.setNormalDistanceWeight (f)
+ *     def set_max_iterations(self, int i):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":213
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_20set_radius_limits[] = "Segmentation_PointXYZRGBA_Normal.set_radius_limits(self, float f1, float f2)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_21set_radius_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_f1;
+  float __pyx_v_f2;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f1,&__pyx_n_s_f2,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f1)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f2)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, 1); __PYX_ERR(6, 213, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_radius_limits") < 0)) __PYX_ERR(6, 213, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_f1 = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_f1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 213, __pyx_L3_error)
+    __pyx_v_f2 = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_f2 == (float)-1) && PyErr_Occurred())) __PYX_ERR(6, 213, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_radius_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 213, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_radius_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_20set_radius_limits(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), __pyx_v_f1, __pyx_v_f2);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_20set_radius_limits(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, float __pyx_v_f1, float __pyx_v_f2) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_limits", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":214
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)             # <<<<<<<<<<<<<<
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)
+ */
+  __pyx_v_self->me->setRadiusLimits(__pyx_v_f1, __pyx_v_f2);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":213
+ *     def set_max_iterations(self, int i):
+ *         self.me.setMaxIterations (i)
+ *     def set_radius_limits(self, float f1, float f2):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":215
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_22set_eps_angle[] = "Segmentation_PointXYZRGBA_Normal.set_eps_angle(self, double ea)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_23set_eps_angle(PyObject *__pyx_v_self, PyObject *__pyx_arg_ea) {
+  double __pyx_v_ea;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle (wrapper)", 0);
+  assert(__pyx_arg_ea); {
+    __pyx_v_ea = __pyx_PyFloat_AsDouble(__pyx_arg_ea); if (unlikely((__pyx_v_ea == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 215, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_eps_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_22set_eps_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), ((double)__pyx_v_ea));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_22set_eps_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, double __pyx_v_ea) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_eps_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":216
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):
+ *         self.me.setEpsAngle (ea)             # <<<<<<<<<<<<<<
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ */
+  __pyx_v_self->me->setEpsAngle(__pyx_v_ea);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":215
+ *     def set_radius_limits(self, float f1, float f2):
+ *         self.me.setRadiusLimits (f1, f2)
+ *     def set_eps_angle(self, double ea):             # <<<<<<<<<<<<<<
+ *         self.me.setEpsAngle (ea)
+ * #     def set_axis(self, double ax, double ay, double az):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":219
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_24set_min_max_opening_angle[] = "Segmentation_PointXYZRGBA_Normal.set_min_max_opening_angle(self, double min_angle, double max_angle)\n Set the minimum and maximum cone opening angles in radians for a cone model.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_25set_min_max_opening_angle(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_min_angle,&__pyx_n_s_max_angle,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_min_angle)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_angle)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, 1); __PYX_ERR(6, 219, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_min_max_opening_angle") < 0)) __PYX_ERR(6, 219, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_min_angle = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_min_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 219, __pyx_L3_error)
+    __pyx_v_max_angle = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_max_angle == (double)-1) && PyErr_Occurred())) __PYX_ERR(6, 219, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_min_max_opening_angle", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(6, 219, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.set_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_24set_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self), __pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_24set_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self, double __pyx_v_min_angle, double __pyx_v_max_angle) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":222
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ */
+  __pyx_v_self->me->setMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":219
+ * #     def set_axis(self, double ax, double ay, double az):
+ * #         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+ *     def set_min_max_opening_angle(self, double min_angle, double max_angle):             # <<<<<<<<<<<<<<
+ *         """ Set the minimum and maximum cone opening angles in radians for a cone model.
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/SegmentationNormal.pxi":223
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_26get_min_max_opening_angle[] = "Segmentation_PointXYZRGBA_Normal.get_min_max_opening_angle(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_27get_min_max_opening_angle(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_26get_min_max_opening_angle(((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_26get_min_max_opening_angle(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_self) {
+  double __pyx_v_min_angle;
+  double __pyx_v_max_angle;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("get_min_max_opening_angle", 0);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":224
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0             # <<<<<<<<<<<<<<
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ */
+  __pyx_v_min_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":225
+ *     def get_min_max_opening_angle(self):
+ *         min_angle = 0.0
+ *         max_angle = 0.0             # <<<<<<<<<<<<<<
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle
+ */
+  __pyx_v_max_angle = 0.0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":226
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)             # <<<<<<<<<<<<<<
+ *         return min_angle, max_angle
+ * 
+ */
+  __pyx_v_self->me->getMinMaxOpeningAngle(__pyx_v_min_angle, __pyx_v_max_angle);
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":227
+ *         max_angle = 0.0
+ *         self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+ *         return min_angle, max_angle             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_min_angle); if (unlikely(!__pyx_t_1)) __PYX_ERR(6, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_max_angle); if (unlikely(!__pyx_t_2)) __PYX_ERR(6, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(6, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/SegmentationNormal.pxi":223
+ *         """
+ *         self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+ *     def get_min_max_opening_angle(self):             # <<<<<<<<<<<<<<
+ *         min_angle = 0.0
+ *         max_angle = 0.0
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.Segmentation_PointXYZRGBA_Normal.get_min_max_opening_angle", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":12
+ *     """
+ *     cdef pclseg.EuclideanClusterExtraction_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.EuclideanClusterExtraction_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction___cinit__(((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction___cinit__(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":13
+ *     cdef pclseg.EuclideanClusterExtraction_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclseg.EuclideanClusterExtraction_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_t();
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":12
+ *     """
+ *     cdef pclseg.EuclideanClusterExtraction_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclseg.EuclideanClusterExtraction_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":14
+ *     def __cinit__(self):
+ *         self.me = new pclseg.EuclideanClusterExtraction_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":15
+ *         self.me = new pclseg.EuclideanClusterExtraction_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_ClusterTolerance(self, double b):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":14
+ *     def __cinit__(self):
+ *         self.me = new pclseg.EuclideanClusterExtraction_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":17
+ *         del self.me
+ * 
+ *     def set_ClusterTolerance(self, double b):             # <<<<<<<<<<<<<<
+ *         self.me.setClusterTolerance(b)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_5set_ClusterTolerance(PyObject *__pyx_v_self, PyObject *__pyx_arg_b); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_4set_ClusterTolerance[] = "EuclideanClusterExtraction.set_ClusterTolerance(self, double b)";
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_5set_ClusterTolerance(PyObject *__pyx_v_self, PyObject *__pyx_arg_b) {
+  double __pyx_v_b;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_ClusterTolerance (wrapper)", 0);
+  assert(__pyx_arg_b); {
+    __pyx_v_b = __pyx_PyFloat_AsDouble(__pyx_arg_b); if (unlikely((__pyx_v_b == (double)-1) && PyErr_Occurred())) __PYX_ERR(7, 17, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.EuclideanClusterExtraction.set_ClusterTolerance", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_4set_ClusterTolerance(((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_v_self), ((double)__pyx_v_b));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_4set_ClusterTolerance(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, double __pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_ClusterTolerance", 0);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":18
+ * 
+ *     def set_ClusterTolerance(self, double b):
+ *         self.me.setClusterTolerance(b)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_MinClusterSize(self, int min):
+ */
+  __pyx_v_self->me->setClusterTolerance(__pyx_v_b);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":17
+ *         del self.me
+ * 
+ *     def set_ClusterTolerance(self, double b):             # <<<<<<<<<<<<<<
+ *         self.me.setClusterTolerance(b)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":20
+ *         self.me.setClusterTolerance(b)
+ * 
+ *     def set_MinClusterSize(self, int min):             # <<<<<<<<<<<<<<
+ *         self.me.setMinClusterSize(min)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_7set_MinClusterSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_min); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_6set_MinClusterSize[] = "EuclideanClusterExtraction.set_MinClusterSize(self, int min)";
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_7set_MinClusterSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_min) {
+  int __pyx_v_min;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MinClusterSize (wrapper)", 0);
+  assert(__pyx_arg_min); {
+    __pyx_v_min = __Pyx_PyInt_As_int(__pyx_arg_min); if (unlikely((__pyx_v_min == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 20, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.EuclideanClusterExtraction.set_MinClusterSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_6set_MinClusterSize(((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_v_self), ((int)__pyx_v_min));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_6set_MinClusterSize(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, int __pyx_v_min) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MinClusterSize", 0);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":21
+ * 
+ *     def set_MinClusterSize(self, int min):
+ *         self.me.setMinClusterSize(min)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_MaxClusterSize(self, int max):
+ */
+  __pyx_v_self->me->setMinClusterSize(__pyx_v_min);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":20
+ *         self.me.setClusterTolerance(b)
+ * 
+ *     def set_MinClusterSize(self, int min):             # <<<<<<<<<<<<<<
+ *         self.me.setMinClusterSize(min)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":23
+ *         self.me.setMinClusterSize(min)
+ * 
+ *     def set_MaxClusterSize(self, int max):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxClusterSize(max)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_9set_MaxClusterSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_max); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_8set_MaxClusterSize[] = "EuclideanClusterExtraction.set_MaxClusterSize(self, int max)";
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_9set_MaxClusterSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_max) {
+  int __pyx_v_max;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MaxClusterSize (wrapper)", 0);
+  assert(__pyx_arg_max); {
+    __pyx_v_max = __Pyx_PyInt_As_int(__pyx_arg_max); if (unlikely((__pyx_v_max == (int)-1) && PyErr_Occurred())) __PYX_ERR(7, 23, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.EuclideanClusterExtraction.set_MaxClusterSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_8set_MaxClusterSize(((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_v_self), ((int)__pyx_v_max));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_8set_MaxClusterSize(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, int __pyx_v_max) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MaxClusterSize", 0);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":24
+ * 
+ *     def set_MaxClusterSize(self, int max):
+ *         self.me.setMaxClusterSize(max)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):
+ */
+  __pyx_v_self->me->setMaxClusterSize(__pyx_v_max);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":23
+ *         self.me.setMinClusterSize(min)
+ * 
+ *     def set_MaxClusterSize(self, int max):             # <<<<<<<<<<<<<<
+ *         self.me.setMaxClusterSize(max)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":26
+ *         self.me.setMaxClusterSize(max)
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_11set_SearchMethod(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_10set_SearchMethod[] = "EuclideanClusterExtraction.set_SearchMethod(self, KdTree kdtree)";
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_11set_SearchMethod(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_SearchMethod (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kdtree), __pyx_ptype_3pcl_4_pcl_KdTree, 1, "kdtree", 0))) __PYX_ERR(7, 26, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_10set_SearchMethod(((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_KdTree *)__pyx_v_kdtree));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_10set_SearchMethod(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_SearchMethod", 0);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":27
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def set_Search_Method(self, _pcl.KdTreeFLANN kdtree):
+ */
+  __pyx_v_self->me->setSearchMethod(__pyx_v_kdtree->thisptr_shared);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":26
+ *         self.me.setMaxClusterSize(max)
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":35
+ *     # def set_
+ *     #   self.me.setInputCloud (cloud_filtered)
+ *     def Extract(self):             # <<<<<<<<<<<<<<
+ *         cdef vector[cpp.PointIndices] inds
+ *         self.me.extract (inds)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_13Extract(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_12Extract[] = "EuclideanClusterExtraction.Extract(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_13Extract(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Extract (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_12Extract(((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_26EuclideanClusterExtraction_12Extract(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_self) {
+  std::vector<pcl::PointIndices>  __pyx_v_inds;
+  std::vector<std::vector<int> >  __pyx_v_result;
+  std::vector<int>  __pyx_v_dim;
+  std::vector<pcl::PointIndices> ::iterator __pyx_v_it;
+  pcl::PointIndices __pyx_v_idx;
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("Extract", 0);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":37
+ *     def Extract(self):
+ *         cdef vector[cpp.PointIndices] inds
+ *         self.me.extract (inds)             # <<<<<<<<<<<<<<
+ *         # NG(not use Python)
+ *         # return inds
+ */
+  __pyx_v_self->me->extract(__pyx_v_inds);
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":60
+ *         # set numpy?
+ *         # http://kesin.hatenablog.com/entry/20120314/1331689014
+ *         cdef vector[cpp.PointIndices].iterator it = inds.begin()             # <<<<<<<<<<<<<<
+ *         while it != inds.end():
+ *             idx = deref(it)
+ */
+  __pyx_v_it = __pyx_v_inds.begin();
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":61
+ *         # http://kesin.hatenablog.com/entry/20120314/1331689014
+ *         cdef vector[cpp.PointIndices].iterator it = inds.begin()
+ *         while it != inds.end():             # <<<<<<<<<<<<<<
+ *             idx = deref(it)
+ *             # for i in range(it.indices.size()):
+ */
+  while (1) {
+    __pyx_t_1 = ((__pyx_v_it != __pyx_v_inds.end()) != 0);
+    if (!__pyx_t_1) break;
+
+    /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":62
+ *         cdef vector[cpp.PointIndices].iterator it = inds.begin()
+ *         while it != inds.end():
+ *             idx = deref(it)             # <<<<<<<<<<<<<<
+ *             # for i in range(it.indices.size()):
+ *             for i in range(idx.indices.size()):
+ */
+    __pyx_v_idx = (*__pyx_v_it);
+
+    /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":64
+ *             idx = deref(it)
+ *             # for i in range(it.indices.size()):
+ *             for i in range(idx.indices.size()):             # <<<<<<<<<<<<<<
+ *                 dim.push_back(idx.indices[i])
+ *             result.push_back(dim)
+ */
+    __pyx_t_2 = __pyx_v_idx.indices.size();
+    for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+      __pyx_v_i = __pyx_t_3;
+
+      /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":65
+ *             # for i in range(it.indices.size()):
+ *             for i in range(idx.indices.size()):
+ *                 dim.push_back(idx.indices[i])             # <<<<<<<<<<<<<<
+ *             result.push_back(dim)
+ *             inc(it)
+ */
+      try {
+        __pyx_v_dim.push_back((__pyx_v_idx.indices[__pyx_v_i]));
+      } catch(...) {
+        __Pyx_CppExn2PyErr();
+        __PYX_ERR(7, 65, __pyx_L1_error)
+      }
+    }
+
+    /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":66
+ *             for i in range(idx.indices.size()):
+ *                 dim.push_back(idx.indices[i])
+ *             result.push_back(dim)             # <<<<<<<<<<<<<<
+ *             inc(it)
+ *             dim.clear()
+ */
+    try {
+      __pyx_v_result.push_back(__pyx_v_dim);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(7, 66, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":67
+ *                 dim.push_back(idx.indices[i])
+ *             result.push_back(dim)
+ *             inc(it)             # <<<<<<<<<<<<<<
+ *             dim.clear()
+ * 
+ */
+    (++__pyx_v_it);
+
+    /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":68
+ *             result.push_back(dim)
+ *             inc(it)
+ *             dim.clear()             # <<<<<<<<<<<<<<
+ * 
+ *         return result
+ */
+    __pyx_v_dim.clear();
+  }
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":70
+ *             dim.clear()
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = __pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(7, 70, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi":35
+ *     # def set_
+ *     #   self.me.setInputCloud (cloud_filtered)
+ *     def Extract(self):             # <<<<<<<<<<<<<<
+ *         cdef vector[cpp.PointIndices] inds
+ *         self.me.extract (inds)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.EuclideanClusterExtraction.Extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":11
+ *     cdef pclfil.StatisticalOutlierRemoval_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(8, 11, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(8, 11, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(8, 11, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter___cinit__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":12
+ * 
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_t()             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_t();
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":13
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":11
+ *     cdef pclfil.StatisticalOutlierRemoval_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":15
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":16
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     property mean_k:
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":15
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":19
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":20
+ *     property mean_k:
+ *         def __get__(self):
+ *             return self.me.getMeanK()             # <<<<<<<<<<<<<<
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->me->getMeanK()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":19
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.mean_k.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":21
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 21, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.mean_k.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, int __pyx_v_k) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":22
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     property negative:
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":21
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":25
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":26
+ *     property negative:
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()             # <<<<<<<<<<<<<<
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(neg)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(((pcl::FilterIndices<struct pcl::PointXYZ>  *)__pyx_v_self->me)->getNegative()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":25
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.negative.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":27
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(neg)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg) {
+  bool __pyx_v_neg;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_neg); {
+    __pyx_v_neg = __Pyx_PyObject_IsTrue(__pyx_arg_neg); if (unlikely((__pyx_v_neg == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 27, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.negative.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), ((bool)__pyx_v_neg));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, bool __pyx_v_neg) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":28
+ *             return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(neg)             # <<<<<<<<<<<<<<
+ * 
+ *     property stddev_mul_thresh:
+ */
+  ((pcl::FilterIndices<struct pcl::PointXYZ>  *)__pyx_v_self->me)->setNegative(__pyx_v_neg);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":27
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(neg)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":31
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":32
+ *     property stddev_mul_thresh:
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()             # <<<<<<<<<<<<<<
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getStddevMulThresh()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":31
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.stddev_mul_thresh.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":33
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh) {
+  double __pyx_v_thresh;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_thresh); {
+    __pyx_v_thresh = __pyx_PyFloat_AsDouble(__pyx_arg_thresh); if (unlikely((__pyx_v_thresh == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 33, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.stddev_mul_thresh.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), ((double)__pyx_v_thresh));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, double __pyx_v_thresh) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":34
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_thresh);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":33
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":36
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_4set_InputCloud[] = "StatisticalOutlierRemovalFilter.set_InputCloud(self, PointCloud pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(8, 36, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":37
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_mean_k(self, int k):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":36
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":39
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6set_mean_k[] = "StatisticalOutlierRemovalFilter.set_mean_k(self, int k)\n\n        Set the number of points (k) to use for mean distance estimation. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 39, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.set_mean_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6set_mean_k(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, int __pyx_v_k) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":43
+ *         Set the number of points (k) to use for mean distance estimation.
+ *         """
+ *         self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":39
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":45
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8set_std_dev_mul_thresh[] = "StatisticalOutlierRemovalFilter.set_std_dev_mul_thresh(self, double std_mul)\n\n        Set the standard deviation multiplier threshold.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul) {
+  double __pyx_v_std_mul;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh (wrapper)", 0);
+  assert(__pyx_arg_std_mul); {
+    __pyx_v_std_mul = __pyx_PyFloat_AsDouble(__pyx_arg_std_mul); if (unlikely((__pyx_v_std_mul == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 45, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.set_std_dev_mul_thresh", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8set_std_dev_mul_thresh(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), ((double)__pyx_v_std_mul));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, double __pyx_v_std_mul) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":49
+ *         Set the standard deviation multiplier threshold.
+ *         """
+ *         self.me.setStddevMulThresh(std_mul)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_negative(self, bool negative):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_std_mul);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":45
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":51
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_10set_negative[] = "StatisticalOutlierRemovalFilter.set_negative(self, bool negative)\n\n        Set whether the indices should be returned, or all points except the indices. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative) {
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative (wrapper)", 0);
+  assert(__pyx_arg_negative); {
+    __pyx_v_negative = __Pyx_PyObject_IsTrue(__pyx_arg_negative); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 51, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.set_negative", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_10set_negative(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self), ((bool)__pyx_v_negative));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self, bool __pyx_v_negative) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":55
+ *         Set whether the indices should be returned, or all points except the indices.
+ *         """
+ *         (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  ((pcl::FilterIndices<struct pcl::PointXYZ>  *)__pyx_v_self->me)->setNegative(__pyx_v_negative);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":51
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":57
+ *         (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_12filter[] = "StatisticalOutlierRemovalFilter.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_12filter(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":62
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":63
+ *         """
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":64
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":57
+ *         (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":73
+ *     cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZI_t()
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(8, 73, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(8, 73, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 0, "pc", 0))) __PYX_ERR(8, 73, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":74
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZI_t()             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZI_t();
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":75
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZI_t()
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZI_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":73
+ *     cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZI_t()
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":77
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":78
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     property mean_k:
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":77
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":81
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":82
+ *     property mean_k:
+ *         def __get__(self):
+ *             return self.me.getMeanK()             # <<<<<<<<<<<<<<
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->me->getMeanK()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":81
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.mean_k.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":83
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 83, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.mean_k.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, int __pyx_v_k) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":84
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     property negative:
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":83
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":87
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":88
+ *     property negative:
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()             # <<<<<<<<<<<<<<
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).setNegative(neg)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(((pcl::FilterIndices<struct pcl::PointXYZI>  *)__pyx_v_self->me)->getNegative()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":87
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.negative.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":89
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).setNegative(neg)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg) {
+  bool __pyx_v_neg;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_neg); {
+    __pyx_v_neg = __Pyx_PyObject_IsTrue(__pyx_arg_neg); if (unlikely((__pyx_v_neg == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 89, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.negative.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), ((bool)__pyx_v_neg));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, bool __pyx_v_neg) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":90
+ *             return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).setNegative(neg)             # <<<<<<<<<<<<<<
+ * 
+ *     property stddev_mul_thresh:
+ */
+  ((pcl::FilterIndices<struct pcl::PointXYZI>  *)__pyx_v_self->me)->setNegative(__pyx_v_neg);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":89
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).setNegative(neg)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":93
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":94
+ *     property stddev_mul_thresh:
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()             # <<<<<<<<<<<<<<
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getStddevMulThresh()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":93
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.stddev_mul_thresh.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":95
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh) {
+  double __pyx_v_thresh;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_thresh); {
+    __pyx_v_thresh = __pyx_PyFloat_AsDouble(__pyx_arg_thresh); if (unlikely((__pyx_v_thresh == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 95, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.stddev_mul_thresh.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), ((double)__pyx_v_thresh));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, double __pyx_v_thresh) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":96
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_thresh);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":95
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":98
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_4set_InputCloud[] = "StatisticalOutlierRemovalFilter_PointXYZI.set_InputCloud(self, PointCloud_PointXYZI pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 0, "pc", 0))) __PYX_ERR(8, 98, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":99
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_mean_k(self, int k):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZI_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":98
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":101
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6set_mean_k[] = "StatisticalOutlierRemovalFilter_PointXYZI.set_mean_k(self, int k)\n\n        Set the number of points (k) to use for mean distance estimation. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 101, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.set_mean_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6set_mean_k(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, int __pyx_v_k) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":105
+ *         Set the number of points (k) to use for mean distance estimation.
+ *         """
+ *         self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":101
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":107
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8set_std_dev_mul_thresh[] = "StatisticalOutlierRemovalFilter_PointXYZI.set_std_dev_mul_thresh(self, double std_mul)\n\n        Set the standard deviation multiplier threshold.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul) {
+  double __pyx_v_std_mul;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh (wrapper)", 0);
+  assert(__pyx_arg_std_mul); {
+    __pyx_v_std_mul = __pyx_PyFloat_AsDouble(__pyx_arg_std_mul); if (unlikely((__pyx_v_std_mul == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 107, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.set_std_dev_mul_thresh", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8set_std_dev_mul_thresh(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), ((double)__pyx_v_std_mul));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, double __pyx_v_std_mul) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":111
+ *         Set the standard deviation multiplier threshold.
+ *         """
+ *         self.me.setStddevMulThresh(std_mul)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_negative(self, bool negative):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_std_mul);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":107
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":113
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_10set_negative[] = "StatisticalOutlierRemovalFilter_PointXYZI.set_negative(self, bool negative)\n\n        Set whether the indices should be returned, or all points except the indices. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative) {
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative (wrapper)", 0);
+  assert(__pyx_arg_negative); {
+    __pyx_v_negative = __Pyx_PyObject_IsTrue(__pyx_arg_negative); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 113, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.set_negative", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_10set_negative(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self), ((bool)__pyx_v_negative));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self, bool __pyx_v_negative) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":117
+ *         Set whether the indices should be returned, or all points except the indices.
+ *         """
+ *         (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  ((pcl::FilterIndices<struct pcl::PointXYZ>  *)__pyx_v_self->me)->setNegative(__pyx_v_negative);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":113
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":119
+ *         (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_12filter[] = "StatisticalOutlierRemovalFilter_PointXYZI.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_12filter(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":124
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":125
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":126
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":119
+ *         (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":135
+ *     cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGB_t()
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(8, 135, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(8, 135, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 0, "pc", 0))) __PYX_ERR(8, 135, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":136
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGB_t();
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":137
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGB_t()
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGB_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":135
+ *     cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGB_t()
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":139
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":140
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     property mean_k:
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":139
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":143
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":144
+ *     property mean_k:
+ *         def __get__(self):
+ *             return self.me.getMeanK()             # <<<<<<<<<<<<<<
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->me->getMeanK()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 144, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":143
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.mean_k.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":145
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 145, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.mean_k.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, int __pyx_v_k) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":146
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     property negative:
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":145
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":149
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":150
+ *     property negative:
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()             # <<<<<<<<<<<<<<
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(neg)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(((pcl::FilterIndices<struct pcl::PointXYZRGB>  *)__pyx_v_self->me)->getNegative()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":149
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.negative.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":151
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(neg)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg) {
+  bool __pyx_v_neg;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_neg); {
+    __pyx_v_neg = __Pyx_PyObject_IsTrue(__pyx_arg_neg); if (unlikely((__pyx_v_neg == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 151, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.negative.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), ((bool)__pyx_v_neg));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, bool __pyx_v_neg) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":152
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(neg)             # <<<<<<<<<<<<<<
+ * 
+ *     property stddev_mul_thresh:
+ */
+  ((pcl::FilterIndices<struct pcl::PointXYZRGB>  *)__pyx_v_self->me)->setNegative(__pyx_v_neg);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":151
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(neg)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":155
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":156
+ *     property stddev_mul_thresh:
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()             # <<<<<<<<<<<<<<
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getStddevMulThresh()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":155
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.stddev_mul_thresh.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":157
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh) {
+  double __pyx_v_thresh;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_thresh); {
+    __pyx_v_thresh = __pyx_PyFloat_AsDouble(__pyx_arg_thresh); if (unlikely((__pyx_v_thresh == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 157, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.stddev_mul_thresh.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), ((double)__pyx_v_thresh));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, double __pyx_v_thresh) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":158
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_thresh);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":157
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":160
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_4set_InputCloud[] = "StatisticalOutlierRemovalFilter_PointXYZRGB.set_InputCloud(self, PointCloud_PointXYZRGB pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 0, "pc", 0))) __PYX_ERR(8, 160, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":161
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_mean_k(self, int k):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGB_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":160
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":163
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6set_mean_k[] = "StatisticalOutlierRemovalFilter_PointXYZRGB.set_mean_k(self, int k)\n\n        Set the number of points (k) to use for mean distance estimation. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 163, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.set_mean_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6set_mean_k(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, int __pyx_v_k) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":167
+ *         Set the number of points (k) to use for mean distance estimation.
+ *         """
+ *         self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":163
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":169
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8set_std_dev_mul_thresh[] = "StatisticalOutlierRemovalFilter_PointXYZRGB.set_std_dev_mul_thresh(self, double std_mul)\n\n        Set the standard deviation multiplier threshold.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul) {
+  double __pyx_v_std_mul;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh (wrapper)", 0);
+  assert(__pyx_arg_std_mul); {
+    __pyx_v_std_mul = __pyx_PyFloat_AsDouble(__pyx_arg_std_mul); if (unlikely((__pyx_v_std_mul == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 169, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.set_std_dev_mul_thresh", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8set_std_dev_mul_thresh(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), ((double)__pyx_v_std_mul));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, double __pyx_v_std_mul) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":173
+ *         Set the standard deviation multiplier threshold.
+ *         """
+ *         self.me.setStddevMulThresh(std_mul)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_negative(self, bool negative):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_std_mul);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":169
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":175
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_10set_negative[] = "StatisticalOutlierRemovalFilter_PointXYZRGB.set_negative(self, bool negative)\n\n        Set whether the indices should be returned, or all points except the indices. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative) {
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative (wrapper)", 0);
+  assert(__pyx_arg_negative); {
+    __pyx_v_negative = __Pyx_PyObject_IsTrue(__pyx_arg_negative); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 175, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.set_negative", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_10set_negative(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self), ((bool)__pyx_v_negative));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self, bool __pyx_v_negative) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":179
+ *         Set whether the indices should be returned, or all points except the indices.
+ *         """
+ *         (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(negative)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  ((pcl::FilterIndices<struct pcl::PointXYZRGB>  *)__pyx_v_self->me)->setNegative(__pyx_v_negative);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":175
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":181
+ *         (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_12filter[] = "StatisticalOutlierRemovalFilter_PointXYZRGB.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_12filter(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":186
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":187
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":188
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":181
+ *         (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":197
+ *     cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t()
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(8, 197, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(8, 197, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 0, "pc", 0))) __PYX_ERR(8, 197, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":198
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":199
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t()
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGBA_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":197
+ *     cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t()
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":201
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":202
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     property mean_k:
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":201
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":205
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":206
+ *     property mean_k:
+ *         def __get__(self):
+ *             return self.me.getMeanK()             # <<<<<<<<<<<<<<
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->me->getMeanK()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":205
+ * 
+ *     property mean_k:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.mean_k.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":207
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 207, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.mean_k.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, int __pyx_v_k) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":208
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):
+ *             self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     property negative:
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":207
+ *         def __get__(self):
+ *             return self.me.getMeanK()
+ *         def __set__(self, int k):             # <<<<<<<<<<<<<<
+ *             self.me.setMeanK(k)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":211
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":212
+ *     property negative:
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()             # <<<<<<<<<<<<<<
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).setNegative(neg)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(((pcl::FilterIndices<struct pcl::PointXYZRGBA>  *)__pyx_v_self->me)->getNegative()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 212, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":211
+ * 
+ *     property negative:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.negative.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":213
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).setNegative(neg)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_neg) {
+  bool __pyx_v_neg;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_neg); {
+    __pyx_v_neg = __Pyx_PyObject_IsTrue(__pyx_arg_neg); if (unlikely((__pyx_v_neg == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 213, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.negative.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), ((bool)__pyx_v_neg));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, bool __pyx_v_neg) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":214
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+ *         def __set__(self, bool neg):
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).setNegative(neg)             # <<<<<<<<<<<<<<
+ * 
+ *     property stddev_mul_thresh:
+ */
+  ((pcl::FilterIndices<struct pcl::PointXYZRGBA>  *)__pyx_v_self->me)->setNegative(__pyx_v_neg);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":213
+ *         def __get__(self):
+ *             return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+ *         def __set__(self, bool neg):             # <<<<<<<<<<<<<<
+ *             (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).setNegative(neg)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":217
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh___get__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh___get__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":218
+ *     property stddev_mul_thresh:
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()             # <<<<<<<<<<<<<<
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getStddevMulThresh()); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":217
+ * 
+ *     property stddev_mul_thresh:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.stddev_mul_thresh.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":219
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_thresh) {
+  double __pyx_v_thresh;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
+  assert(__pyx_arg_thresh); {
+    __pyx_v_thresh = __pyx_PyFloat_AsDouble(__pyx_arg_thresh); if (unlikely((__pyx_v_thresh == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 219, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.stddev_mul_thresh.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_2__set__(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), ((double)__pyx_v_thresh));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_2__set__(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, double __pyx_v_thresh) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__set__", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":220
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):
+ *             self.me.setStddevMulThresh(thresh)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_thresh);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":219
+ *         def __get__(self):
+ *             return self.me.getStddevMulThresh()
+ *         def __set__(self, double thresh):             # <<<<<<<<<<<<<<
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":222
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_4set_InputCloud[] = "StatisticalOutlierRemovalFilter_PointXYZRGBA.set_InputCloud(self, PointCloud_PointXYZRGBA pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 0, "pc", 0))) __PYX_ERR(8, 222, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":223
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_mean_k(self, int k):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGBA_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":222
+ *             self.me.setStddevMulThresh(thresh)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":225
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6set_mean_k[] = "StatisticalOutlierRemovalFilter_PointXYZRGBA.set_mean_k(self, int k)\n\n        Set the number of points (k) to use for mean distance estimation. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_7set_mean_k(PyObject *__pyx_v_self, PyObject *__pyx_arg_k) {
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k (wrapper)", 0);
+  assert(__pyx_arg_k); {
+    __pyx_v_k = __Pyx_PyInt_As_int(__pyx_arg_k); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(8, 225, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.set_mean_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6set_mean_k(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), ((int)__pyx_v_k));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6set_mean_k(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, int __pyx_v_k) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_mean_k", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":229
+ *         Set the number of points (k) to use for mean distance estimation.
+ *         """
+ *         self.me.setMeanK(k)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):
+ */
+  __pyx_v_self->me->setMeanK(__pyx_v_k);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":225
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_mean_k(self, int k):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the number of points (k) to use for mean distance estimation.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":231
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8set_std_dev_mul_thresh[] = "StatisticalOutlierRemovalFilter_PointXYZRGBA.set_std_dev_mul_thresh(self, double std_mul)\n\n        Set the standard deviation multiplier threshold.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_9set_std_dev_mul_thresh(PyObject *__pyx_v_self, PyObject *__pyx_arg_std_mul) {
+  double __pyx_v_std_mul;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh (wrapper)", 0);
+  assert(__pyx_arg_std_mul); {
+    __pyx_v_std_mul = __pyx_PyFloat_AsDouble(__pyx_arg_std_mul); if (unlikely((__pyx_v_std_mul == (double)-1) && PyErr_Occurred())) __PYX_ERR(8, 231, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.set_std_dev_mul_thresh", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8set_std_dev_mul_thresh(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), ((double)__pyx_v_std_mul));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8set_std_dev_mul_thresh(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, double __pyx_v_std_mul) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_std_dev_mul_thresh", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":235
+ *         Set the standard deviation multiplier threshold.
+ *         """
+ *         self.me.setStddevMulThresh(std_mul)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_negative(self, bool negative):
+ */
+  __pyx_v_self->me->setStddevMulThresh(__pyx_v_std_mul);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":231
+ *         self.me.setMeanK(k)
+ * 
+ *     def set_std_dev_mul_thresh(self, double std_mul):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the standard deviation multiplier threshold.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":237
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_10set_negative[] = "StatisticalOutlierRemovalFilter_PointXYZRGBA.set_negative(self, bool negative)\n\n        Set whether the indices should be returned, or all points except the indices. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_11set_negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_negative) {
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative (wrapper)", 0);
+  assert(__pyx_arg_negative); {
+    __pyx_v_negative = __Pyx_PyObject_IsTrue(__pyx_arg_negative); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(8, 237, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.set_negative", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_10set_negative(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self), ((bool)__pyx_v_negative));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_10set_negative(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self, bool __pyx_v_negative) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_negative", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":241
+ *         Set whether the indices should be returned, or all points except the indices.
+ *         """
+ *         self.me.setNegative(negative)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setNegative(__pyx_v_negative);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":237
+ *         self.me.setStddevMulThresh(std_mul)
+ * 
+ *     def set_negative(self, bool negative):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set whether the indices should be returned, or all points except the indices.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":243
+ *         self.me.setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_12filter[] = "StatisticalOutlierRemovalFilter_PointXYZRGBA.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_13filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_12filter(((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_12filter(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":248
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 248, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":249
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":250
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi":243
+ *         self.me.setNegative(negative)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":10
+ *     """
+ *     cdef pclfil.VoxelGrid_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_15VoxelGridFilter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_15VoxelGridFilter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_15VoxelGridFilter___cinit__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_15VoxelGridFilter___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":11
+ *     cdef pclfil.VoxelGrid_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_VoxelGrid_t();
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":10
+ *     """
+ *     cdef pclfil.VoxelGrid_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":12
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_15VoxelGridFilter_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_15VoxelGridFilter_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_15VoxelGridFilter_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_15VoxelGridFilter_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":13
+ *         self.me = new pclfil.VoxelGrid_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":12
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":15
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_15VoxelGridFilter_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_15VoxelGridFilter_4set_leaf_size[] = "VoxelGridFilter.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_15VoxelGridFilter_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(9, 15, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(9, 15, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(9, 15, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 15, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 15, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 15, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(9, 15, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_15VoxelGridFilter_4set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_15VoxelGridFilter_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":19
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":15
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":21
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_15VoxelGridFilter_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_15VoxelGridFilter_6filter[] = "VoxelGridFilter.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_15VoxelGridFilter_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_15VoxelGridFilter_6filter(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_15VoxelGridFilter_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":26
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 26, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":27
+ *         """
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":28
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * cdef class VoxelGridFilter_PointXYZI:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":21
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":35
+ *     """
+ *     cdef pclfil.VoxelGrid_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":36
+ *     cdef pclfil.VoxelGrid_PointXYZI_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZI_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZI_t();
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":35
+ *     """
+ *     cdef pclfil.VoxelGrid_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":37
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":38
+ *         self.me = new pclfil.VoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":37
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":40
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_4set_leaf_size[] = "VoxelGridFilter_PointXYZI.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(9, 40, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(9, 40, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(9, 40, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 40, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 40, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 40, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(9, 40, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter_PointXYZI.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_4set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":44
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":40
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":46
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_6filter[] = "VoxelGridFilter_PointXYZI.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_6filter(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":51
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":52
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":53
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * cdef class VoxelGridFilter_PointXYZRGB:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":46
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter_PointXYZI.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":60
+ *     """
+ *     cdef pclfil.VoxelGrid_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":61
+ *     cdef pclfil.VoxelGrid_PointXYZRGB_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGB_t();
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":60
+ *     """
+ *     cdef pclfil.VoxelGrid_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":62
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":63
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":62
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":65
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_4set_leaf_size[] = "VoxelGridFilter_PointXYZRGB.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(9, 65, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(9, 65, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(9, 65, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 65, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 65, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 65, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(9, 65, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter_PointXYZRGB.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_4set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":69
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":65
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":71
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_6filter[] = "VoxelGridFilter_PointXYZRGB.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_6filter(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":76
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":77
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":78
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * cdef class VoxelGridFilter_PointXYZRGBA:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":71
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter_PointXYZRGB.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":85
+ *     """
+ *     cdef pclfil.VoxelGrid_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":86
+ *     cdef pclfil.VoxelGrid_PointXYZRGBA_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":85
+ *     """
+ *     cdef pclfil.VoxelGrid_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":87
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":88
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":87
+ *     def __cinit__(self):
+ *         self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":90
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_4set_leaf_size[] = "VoxelGridFilter_PointXYZRGBA.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(9, 90, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(9, 90, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(9, 90, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 90, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 90, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(9, 90, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(9, 90, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter_PointXYZRGBA.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_4set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":94
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":90
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":96
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_6filter[] = "VoxelGridFilter_PointXYZRGBA.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_7filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_6filter(((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_6filter(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":101
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(9, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":102
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":103
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/VoxelGridFilter_180.pxi":96
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.VoxelGridFilter_PointXYZRGBA.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":10
+ *     """
+ *     cdef pclfil.PassThrough_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_17PassThroughFilter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_17PassThroughFilter_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_17PassThroughFilter___cinit__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_17PassThroughFilter___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":11
+ *     cdef pclfil.PassThrough_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_PassThrough_t();
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":10
+ *     """
+ *     cdef pclfil.PassThrough_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":12
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_17PassThroughFilter_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_17PassThroughFilter_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_17PassThroughFilter_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_17PassThroughFilter_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":13
+ *         self.me = new pclfil.PassThrough_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_field_name(self, field_name):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":12
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":15
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_17PassThroughFilter_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_17PassThroughFilter_4set_filter_field_name[] = "PassThroughFilter.set_filter_field_name(self, field_name)";
+static PyObject *__pyx_pw_3pcl_4_pcl_17PassThroughFilter_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_field_name (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_17PassThroughFilter_4set_filter_field_name(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *)__pyx_v_self), ((PyObject *)__pyx_v_field_name));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_17PassThroughFilter_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_v_fname_ascii = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  char *__pyx_t_5;
+  std::string __pyx_t_6;
+  __Pyx_RefNannySetupContext("set_filter_field_name", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":17
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+  __pyx_t_1 = PyUnicode_Check(__pyx_v_field_name); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":18
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_field_name, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 18, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 18, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 18, __pyx_L1_error)
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":17
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":19
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  __pyx_t_2 = PyBytes_Check(__pyx_v_field_name); 
+  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":21
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fname_ascii = field_name
+ */
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_field_name_should_be_a_string_go, __pyx_v_field_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":20
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"             # <<<<<<<<<<<<<<
+ *                             % field_name)
+ *         else:
+ */
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(1, 20, __pyx_L1_error)
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":19
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":23
+ *                             % field_name)
+ *         else:
+ *             fname_ascii = field_name             # <<<<<<<<<<<<<<
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ */
+  /*else*/ {
+    if (!(likely(PyBytes_CheckExact(__pyx_v_field_name))||((__pyx_v_field_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_field_name)->tp_name), 0))) __PYX_ERR(1, 23, __pyx_L1_error)
+    __pyx_t_4 = __pyx_v_field_name;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":24
+ *         else:
+ *             fname_ascii = field_name
+ *         self.me.setFilterFieldName(string(fname_ascii))             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ */
+  __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_fname_ascii); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(1, 24, __pyx_L1_error)
+  try {
+    __pyx_t_6 = std::string(__pyx_t_5);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(1, 24, __pyx_L1_error)
+  }
+  __pyx_v_self->me->setFilterFieldName(__pyx_t_6);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":15
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter.set_filter_field_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fname_ascii);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":26
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_17PassThroughFilter_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_17PassThroughFilter_6set_filter_limits[] = "PassThroughFilter.set_filter_limits(self, float filter_min, float filter_max)";
+static PyObject *__pyx_pw_3pcl_4_pcl_17PassThroughFilter_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_filter_min;
+  float __pyx_v_filter_max;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filter_min,&__pyx_n_s_filter_max,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_min)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_max)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, 1); __PYX_ERR(1, 26, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_filter_limits") < 0)) __PYX_ERR(1, 26, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_filter_min = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_filter_min == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 26, __pyx_L3_error)
+    __pyx_v_filter_max = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_filter_max == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 26, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 26, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter.set_filter_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_17PassThroughFilter_6set_filter_limits(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *)__pyx_v_self), __pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_17PassThroughFilter_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":27
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ *         self.me.setFilterLimits (filter_min, filter_max)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setFilterLimits(__pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":26
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":29
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_17PassThroughFilter_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_17PassThroughFilter_8filter[] = "PassThroughFilter.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_17PassThroughFilter_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_17PassThroughFilter_8filter(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_17PassThroughFilter_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":34
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         # cdef cpp.PointCloud_t *cCondAnd = <cpp.PointCloud_t *>pc.thisptr()[0]
+ *         # self.me.filter(<cpp.PointCloud_t*> pc.thisptr()[0])
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 34, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":38
+ *         # self.me.filter(<cpp.PointCloud_t*> pc.thisptr()[0])
+ *         # self.me.filter (<cpp.PointCloud_t*> pc.thisptr())
+ *         self.me.c_filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":39
+ *         # self.me.filter (<cpp.PointCloud_t*> pc.thisptr())
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":29
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":47
+ *     """
+ *     cdef pclfil.PassThrough_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":48
+ *     cdef pclfil.PassThrough_PointXYZI_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZI_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZI_t();
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":47
+ *     """
+ *     cdef pclfil.PassThrough_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":49
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":50
+ *         self.me = new pclfil.PassThrough_PointXYZI_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_field_name(self, field_name):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":49
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":52
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_27PassThroughFilter_PointXYZI_4set_filter_field_name[] = "PassThroughFilter_PointXYZI.set_filter_field_name(self, field_name)";
+static PyObject *__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_field_name (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_4set_filter_field_name(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *)__pyx_v_self), ((PyObject *)__pyx_v_field_name));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_v_fname_ascii = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  char *__pyx_t_5;
+  std::string __pyx_t_6;
+  __Pyx_RefNannySetupContext("set_filter_field_name", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":54
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+  __pyx_t_1 = PyUnicode_Check(__pyx_v_field_name); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":55
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_field_name, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 55, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 55, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 55, __pyx_L1_error)
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":54
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":56
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  __pyx_t_2 = PyBytes_Check(__pyx_v_field_name); 
+  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":58
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fname_ascii = field_name
+ */
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_field_name_should_be_a_string_go, __pyx_v_field_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 58, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":57
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"             # <<<<<<<<<<<<<<
+ *                             % field_name)
+ *         else:
+ */
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 57, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 57, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(1, 57, __pyx_L1_error)
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":56
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":60
+ *                             % field_name)
+ *         else:
+ *             fname_ascii = field_name             # <<<<<<<<<<<<<<
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ */
+  /*else*/ {
+    if (!(likely(PyBytes_CheckExact(__pyx_v_field_name))||((__pyx_v_field_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_field_name)->tp_name), 0))) __PYX_ERR(1, 60, __pyx_L1_error)
+    __pyx_t_4 = __pyx_v_field_name;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":61
+ *         else:
+ *             fname_ascii = field_name
+ *         self.me.setFilterFieldName(string(fname_ascii))             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ */
+  __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_fname_ascii); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(1, 61, __pyx_L1_error)
+  try {
+    __pyx_t_6 = std::string(__pyx_t_5);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(1, 61, __pyx_L1_error)
+  }
+  __pyx_v_self->me->setFilterFieldName(__pyx_t_6);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":52
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZI.set_filter_field_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fname_ascii);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":63
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_27PassThroughFilter_PointXYZI_6set_filter_limits[] = "PassThroughFilter_PointXYZI.set_filter_limits(self, float filter_min, float filter_max)";
+static PyObject *__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_filter_min;
+  float __pyx_v_filter_max;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filter_min,&__pyx_n_s_filter_max,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_min)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_max)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, 1); __PYX_ERR(1, 63, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_filter_limits") < 0)) __PYX_ERR(1, 63, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_filter_min = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_filter_min == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 63, __pyx_L3_error)
+    __pyx_v_filter_max = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_filter_max == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 63, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 63, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZI.set_filter_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_6set_filter_limits(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *)__pyx_v_self), __pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":64
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ *         self.me.setFilterLimits (filter_min, filter_max)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setFilterLimits(__pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":63
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":66
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_27PassThroughFilter_PointXYZI_8filter[] = "PassThroughFilter_PointXYZI.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new PointCloud_PointXYZI\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_8filter(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_27PassThroughFilter_PointXYZI_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":71
+ *         a new PointCloud_PointXYZI
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()             # <<<<<<<<<<<<<<
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":72
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.c_filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":73
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":66
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZI.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":81
+ *     """
+ *     cdef pclfil.PassThrough_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":82
+ *     cdef pclfil.PassThrough_PointXYZRGB_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGB_t();
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":81
+ *     """
+ *     cdef pclfil.PassThrough_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":83
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":84
+ *         self.me = new pclfil.PassThrough_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_field_name(self, field_name):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":83
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":86
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_4set_filter_field_name[] = "PassThroughFilter_PointXYZRGB.set_filter_field_name(self, field_name)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_field_name (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_4set_filter_field_name(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *)__pyx_v_self), ((PyObject *)__pyx_v_field_name));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_v_fname_ascii = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  char *__pyx_t_5;
+  std::string __pyx_t_6;
+  __Pyx_RefNannySetupContext("set_filter_field_name", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":88
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+  __pyx_t_1 = PyUnicode_Check(__pyx_v_field_name); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":89
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_field_name, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 89, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 89, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 89, __pyx_L1_error)
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":88
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":90
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  __pyx_t_2 = PyBytes_Check(__pyx_v_field_name); 
+  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":92
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fname_ascii = field_name
+ */
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_field_name_should_be_a_string_go, __pyx_v_field_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 92, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":91
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"             # <<<<<<<<<<<<<<
+ *                             % field_name)
+ *         else:
+ */
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 91, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 91, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(1, 91, __pyx_L1_error)
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":90
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":94
+ *                             % field_name)
+ *         else:
+ *             fname_ascii = field_name             # <<<<<<<<<<<<<<
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ */
+  /*else*/ {
+    if (!(likely(PyBytes_CheckExact(__pyx_v_field_name))||((__pyx_v_field_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_field_name)->tp_name), 0))) __PYX_ERR(1, 94, __pyx_L1_error)
+    __pyx_t_4 = __pyx_v_field_name;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":95
+ *         else:
+ *             fname_ascii = field_name
+ *         self.me.setFilterFieldName(string(fname_ascii))             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ */
+  __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_fname_ascii); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(1, 95, __pyx_L1_error)
+  try {
+    __pyx_t_6 = std::string(__pyx_t_5);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(1, 95, __pyx_L1_error)
+  }
+  __pyx_v_self->me->setFilterFieldName(__pyx_t_6);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":86
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZRGB.set_filter_field_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fname_ascii);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":97
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_6set_filter_limits[] = "PassThroughFilter_PointXYZRGB.set_filter_limits(self, float filter_min, float filter_max)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_filter_min;
+  float __pyx_v_filter_max;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filter_min,&__pyx_n_s_filter_max,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_min)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_max)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, 1); __PYX_ERR(1, 97, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_filter_limits") < 0)) __PYX_ERR(1, 97, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_filter_min = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_filter_min == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 97, __pyx_L3_error)
+    __pyx_v_filter_max = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_filter_max == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 97, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 97, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZRGB.set_filter_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_6set_filter_limits(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *)__pyx_v_self), __pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":98
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ *         self.me.setFilterLimits (filter_min, filter_max)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setFilterLimits(__pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":97
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":100
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_8filter[] = "PassThroughFilter_PointXYZRGB.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new PointCloud_PointXYZRGB\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_8filter(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":105
+ *         a new PointCloud_PointXYZRGB
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":106
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.c_filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":107
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":100
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZRGB.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":115
+ *     """
+ *     cdef pclfil.PassThrough_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":116
+ *     cdef pclfil.PassThrough_PointXYZRGBA_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":115
+ *     """
+ *     cdef pclfil.PassThrough_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":117
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":118
+ *         self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_field_name(self, field_name):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":117
+ *     def __cinit__(self):
+ *         self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":120
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_4set_filter_field_name[] = "PassThroughFilter_PointXYZRGBA.set_filter_field_name(self, field_name)";
+static PyObject *__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_5set_filter_field_name(PyObject *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_field_name (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_4set_filter_field_name(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *)__pyx_v_self), ((PyObject *)__pyx_v_field_name));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_4set_filter_field_name(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_field_name) {
+  PyObject *__pyx_v_fname_ascii = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  char *__pyx_t_5;
+  std::string __pyx_t_6;
+  __Pyx_RefNannySetupContext("set_filter_field_name", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":122
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+  __pyx_t_1 = PyUnicode_Check(__pyx_v_field_name); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":123
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_field_name, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 123, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 123, __pyx_L1_error)
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":122
+ *     def set_filter_field_name(self, field_name):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":124
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  __pyx_t_2 = PyBytes_Check(__pyx_v_field_name); 
+  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":126
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fname_ascii = field_name
+ */
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_field_name_should_be_a_string_go, __pyx_v_field_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 126, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":125
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"             # <<<<<<<<<<<<<<
+ *                             % field_name)
+ *         else:
+ */
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 125, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 125, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(1, 125, __pyx_L1_error)
+
+    /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":124
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r"
+ *                             % field_name)
+ */
+  }
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":128
+ *                             % field_name)
+ *         else:
+ *             fname_ascii = field_name             # <<<<<<<<<<<<<<
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ */
+  /*else*/ {
+    if (!(likely(PyBytes_CheckExact(__pyx_v_field_name))||((__pyx_v_field_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_field_name)->tp_name), 0))) __PYX_ERR(1, 128, __pyx_L1_error)
+    __pyx_t_4 = __pyx_v_field_name;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":129
+ *         else:
+ *             fname_ascii = field_name
+ *         self.me.setFilterFieldName(string(fname_ascii))             # <<<<<<<<<<<<<<
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ */
+  __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_fname_ascii); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(1, 129, __pyx_L1_error)
+  try {
+    __pyx_t_6 = std::string(__pyx_t_5);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(1, 129, __pyx_L1_error)
+  }
+  __pyx_v_self->me->setFilterFieldName(__pyx_t_6);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":120
+ *         del self.me
+ * 
+ *     def set_filter_field_name(self, field_name):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZRGBA.set_filter_field_name", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fname_ascii);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":131
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_6set_filter_limits[] = "PassThroughFilter_PointXYZRGBA.set_filter_limits(self, float filter_min, float filter_max)";
+static PyObject *__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_7set_filter_limits(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_filter_min;
+  float __pyx_v_filter_max;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_filter_min,&__pyx_n_s_filter_max,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_min)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_filter_max)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, 1); __PYX_ERR(1, 131, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_filter_limits") < 0)) __PYX_ERR(1, 131, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_filter_min = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_filter_min == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+    __pyx_v_filter_max = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_filter_max == (float)-1) && PyErr_Occurred())) __PYX_ERR(1, 131, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_filter_limits", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 131, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZRGBA.set_filter_limits", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_6set_filter_limits(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *)__pyx_v_self), __pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_6set_filter_limits(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self, float __pyx_v_filter_min, float __pyx_v_filter_max) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_filter_limits", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":132
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):
+ *         self.me.setFilterLimits (filter_min, filter_max)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setFilterLimits(__pyx_v_filter_min, __pyx_v_filter_max);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":131
+ *         self.me.setFilterFieldName(string(fname_ascii))
+ * 
+ *     def set_filter_limits(self, float filter_min, float filter_max):             # <<<<<<<<<<<<<<
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/PassThroughFilter_180.pxi":134
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_8filter[] = "PassThroughFilter_PointXYZRGBA.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new PointCloud_PointXYZRGBA\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_8filter(((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_8filter(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":139
+ *         a new PointCloud_PointXYZRGBA
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":140
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.c_filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":141
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":134
+ *         self.me.setFilterLimits (filter_min, filter_max)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PassThroughFilter_PointXYZRGBA.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":11
+ *     cdef pclfil.ApproximateVoxelGrid_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid___cinit__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":12
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_t();
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":11
+ *     cdef pclfil.ApproximateVoxelGrid_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":14
+ *         self.me = new pclfil.ApproximateVoxelGrid_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":15
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":14
+ *         self.me = new pclfil.ApproximateVoxelGrid_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":17
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20ApproximateVoxelGrid_4set_InputCloud[] = "ApproximateVoxelGrid.set_InputCloud(self, PointCloud pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(10, 17, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":18
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":17
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":20
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_7set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20ApproximateVoxelGrid_6set_leaf_size[] = "ApproximateVoxelGrid.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_7set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(10, 20, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(10, 20, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(10, 20, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 20, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 20, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 20, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(10, 20, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_6set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_6set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":24
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":20
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":26
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20ApproximateVoxelGrid_8filter[] = "ApproximateVoxelGrid.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_8filter(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20ApproximateVoxelGrid_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":31
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":32
+ *         """
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":33
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * cdef class ApproximateVoxelGrid_PointXYZI:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":26
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":41
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZI_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":42
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZI_t();
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":41
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZI_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":43
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":44
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":43
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":46
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_4set_leaf_size[] = "ApproximateVoxelGrid_PointXYZI.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_5set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(10, 46, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(10, 46, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(10, 46, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 46, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 46, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 46, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(10, 46, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid_PointXYZI.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_4set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_4set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":50
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":46
+ *         del self.me
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":52
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_7set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_6set_InputCloud[] = "ApproximateVoxelGrid_PointXYZI.set_InputCloud(self, PointCloud_PointXYZI pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_7set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 0, "pc", 0))) __PYX_ERR(10, 52, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_6set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_6set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":53
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZI_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":52
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":55
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_8filter[] = "ApproximateVoxelGrid_PointXYZI.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_8filter(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":60
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":61
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":62
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * cdef class ApproximateVoxelGrid_PointXYZRGB:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":55
+ *         (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid_PointXYZI.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":69
+ *     """
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":70
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZRGB_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGB_t();
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":69
+ *     """
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":71
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":72
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":71
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":74
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_4set_InputCloud[] = "ApproximateVoxelGrid_PointXYZRGB.set_InputCloud(self, PointCloud_PointXYZRGB pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 0, "pc", 0))) __PYX_ERR(10, 74, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":75
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGB_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":74
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":77
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_7set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_6set_leaf_size[] = "ApproximateVoxelGrid_PointXYZRGB.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_7set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(10, 77, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(10, 77, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(10, 77, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 77, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 77, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 77, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(10, 77, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid_PointXYZRGB.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_6set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_6set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":81
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":77
+ *         (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":83
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_8filter[] = "ApproximateVoxelGrid_PointXYZRGB.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_8filter(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":88
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":89
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":90
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * cdef class ApproximateVoxelGrid_PointXYZRGBA:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":83
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid_PointXYZRGB.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":97
+ *     """
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":98
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZRGBA_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":97
+ *     """
+ *     cdef pclfil.ApproximateVoxelGrid_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":99
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":100
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":99
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":102
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_4set_InputCloud[] = "ApproximateVoxelGrid_PointXYZRGBA.set_InputCloud(self, PointCloud_PointXYZRGBA pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 0, "pc", 0))) __PYX_ERR(10, 102, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":103
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_PointXYZRGBA_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":102
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":105
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_7set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_6set_leaf_size[] = "ApproximateVoxelGrid_PointXYZRGBA.set_leaf_size(self, float x, float y, float z)\n\n        Set the voxel grid leaf size.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_7set_leaf_size(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_x;
+  float __pyx_v_y;
+  float __pyx_v_z;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_x,&__pyx_n_s_y,&__pyx_n_s_z,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 1); __PYX_ERR(10, 105, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_z)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, 2); __PYX_ERR(10, 105, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_leaf_size") < 0)) __PYX_ERR(10, 105, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 105, __pyx_L3_error)
+    __pyx_v_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 105, __pyx_L3_error)
+    __pyx_v_z = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_z == (float)-1) && PyErr_Occurred())) __PYX_ERR(10, 105, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_leaf_size", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(10, 105, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid_PointXYZRGBA.set_leaf_size", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_6set_leaf_size(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *)__pyx_v_self), __pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_6set_leaf_size(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self, float __pyx_v_x, float __pyx_v_y, float __pyx_v_z) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_leaf_size", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":109
+ *         Set the voxel grid leaf size.
+ *         """
+ *         self.me.setLeafSize(x,y,z)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->setLeafSize(__pyx_v_x, __pyx_v_y, __pyx_v_z);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":105
+ *         (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_leaf_size (self, float x, float y, float z):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the voxel grid leaf size.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":111
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_8filter[] = "ApproximateVoxelGrid_PointXYZRGBA.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_9filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_8filter(((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_8filter(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":116
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(10, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":117
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":118
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ApproximateVoxelGrid.pxi":111
+ *         self.me.setLeafSize(x,y,z)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ApproximateVoxelGrid_PointXYZRGBA.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":14
+ *     cdef pclsf.MovingLeastSquares_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.MovingLeastSquares_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_18MovingLeastSquares_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_18MovingLeastSquares_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18MovingLeastSquares___cinit__(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_18MovingLeastSquares___cinit__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":15
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclsf.MovingLeastSquares_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_t();
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":14
+ *     cdef pclsf.MovingLeastSquares_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.MovingLeastSquares_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":17
+ *         self.me = new pclsf.MovingLeastSquares_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_18MovingLeastSquares_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_18MovingLeastSquares_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":18
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_search_radius(self, double radius):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":17
+ *         self.me = new pclsf.MovingLeastSquares_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":20
+ *         del self.me
+ * 
+ *     def set_search_radius(self, double radius):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_5set_search_radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_4set_search_radius[] = "MovingLeastSquares.set_search_radius(self, double radius)\n\n        Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_5set_search_radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius) {
+  double __pyx_v_radius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_search_radius (wrapper)", 0);
+  assert(__pyx_arg_radius); {
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(__pyx_arg_radius); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 20, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares.set_search_radius", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_4set_search_radius(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self), ((double)__pyx_v_radius));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_4set_search_radius(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, double __pyx_v_radius) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_search_radius", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":24
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ *         """
+ *         self.me.setSearchRadius (radius)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_polynomial_order(self, bool order):
+ */
+  __pyx_v_self->me->setSearchRadius(__pyx_v_radius);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":20
+ *         del self.me
+ * 
+ *     def set_search_radius(self, double radius):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":26
+ *         self.me.setSearchRadius (radius)
+ * 
+ *     def set_polynomial_order(self, bool order):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the order of the polynomial to be fit.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_7set_polynomial_order(PyObject *__pyx_v_self, PyObject *__pyx_arg_order); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_6set_polynomial_order[] = "MovingLeastSquares.set_polynomial_order(self, bool order)\n\n        Set the order of the polynomial to be fit. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_7set_polynomial_order(PyObject *__pyx_v_self, PyObject *__pyx_arg_order) {
+  bool __pyx_v_order;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_order (wrapper)", 0);
+  assert(__pyx_arg_order); {
+    __pyx_v_order = __Pyx_PyObject_IsTrue(__pyx_arg_order); if (unlikely((__pyx_v_order == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(11, 26, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares.set_polynomial_order", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_6set_polynomial_order(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self), ((bool)__pyx_v_order));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_6set_polynomial_order(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, bool __pyx_v_order) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_order", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":30
+ *         Set the order of the polynomial to be fit.
+ *         """
+ *         self.me.setPolynomialOrder(order)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_polynomial_fit(self, bool fit):
+ */
+  __pyx_v_self->me->setPolynomialOrder(__pyx_v_order);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":26
+ *         self.me.setSearchRadius (radius)
+ * 
+ *     def set_polynomial_order(self, bool order):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the order of the polynomial to be fit.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":32
+ *         self.me.setPolynomialOrder(order)
+ * 
+ *     def set_polynomial_fit(self, bool fit):             # <<<<<<<<<<<<<<
+ *         """
+ *         Sets whether the surface and normal are approximated using a polynomial,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_9set_polynomial_fit(PyObject *__pyx_v_self, PyObject *__pyx_arg_fit); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_8set_polynomial_fit[] = "MovingLeastSquares.set_polynomial_fit(self, bool fit)\n\n        Sets whether the surface and normal are approximated using a polynomial,\n        or only via tangent estimation.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_9set_polynomial_fit(PyObject *__pyx_v_self, PyObject *__pyx_arg_fit) {
+  bool __pyx_v_fit;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_fit (wrapper)", 0);
+  assert(__pyx_arg_fit); {
+    __pyx_v_fit = __Pyx_PyObject_IsTrue(__pyx_arg_fit); if (unlikely((__pyx_v_fit == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(11, 32, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares.set_polynomial_fit", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_8set_polynomial_fit(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self), ((bool)__pyx_v_fit));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_8set_polynomial_fit(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, bool __pyx_v_fit) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_fit", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":37
+ *         or only via tangent estimation.
+ *         """
+ *         self.me.setPolynomialFit(fit)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Compute_Normals(self, bool flag):
+ */
+  __pyx_v_self->me->setPolynomialFit(__pyx_v_fit);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":32
+ *         self.me.setPolynomialOrder(order)
+ * 
+ *     def set_polynomial_fit(self, bool fit):             # <<<<<<<<<<<<<<
+ *         """
+ *         Sets whether the surface and normal are approximated using a polynomial,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":39
+ *         self.me.setPolynomialFit(fit)
+ * 
+ *     def set_Compute_Normals(self, bool flag):             # <<<<<<<<<<<<<<
+ *         self.me.setComputeNormals(flag)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_11set_Compute_Normals(PyObject *__pyx_v_self, PyObject *__pyx_arg_flag); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_10set_Compute_Normals[] = "MovingLeastSquares.set_Compute_Normals(self, bool flag)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_11set_Compute_Normals(PyObject *__pyx_v_self, PyObject *__pyx_arg_flag) {
+  bool __pyx_v_flag;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Compute_Normals (wrapper)", 0);
+  assert(__pyx_arg_flag); {
+    __pyx_v_flag = __Pyx_PyObject_IsTrue(__pyx_arg_flag); if (unlikely((__pyx_v_flag == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(11, 39, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares.set_Compute_Normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_10set_Compute_Normals(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self), ((bool)__pyx_v_flag));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_10set_Compute_Normals(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, bool __pyx_v_flag) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Compute_Normals", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":40
+ * 
+ *     def set_Compute_Normals(self, bool flag):
+ *         self.me.setComputeNormals(flag)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Search_Method(self, _pcl.KdTree kdtree):
+ */
+  __pyx_v_self->me->setComputeNormals(__pyx_v_flag);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":39
+ *         self.me.setPolynomialFit(fit)
+ * 
+ *     def set_Compute_Normals(self, bool flag):             # <<<<<<<<<<<<<<
+ *         self.me.setComputeNormals(flag)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":42
+ *         self.me.setComputeNormals(flag)
+ * 
+ *     def set_Search_Method(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *        # self.me.setSearchMethod(kdtree.thisptr()[0])
+ *        # self.me.setSearchMethod(kdtree.thisptr())
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_13set_Search_Method(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_12set_Search_Method[] = "MovingLeastSquares.set_Search_Method(self, KdTree kdtree)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_13set_Search_Method(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Search_Method (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kdtree), __pyx_ptype_3pcl_4_pcl_KdTree, 1, "kdtree", 0))) __PYX_ERR(11, 42, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_12set_Search_Method(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_KdTree *)__pyx_v_kdtree));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_12set_Search_Method(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Search_Method", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":45
+ *        # self.me.setSearchMethod(kdtree.thisptr()[0])
+ *        # self.me.setSearchMethod(kdtree.thisptr())
+ *        self.me.setSearchMethod(kdtree.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def set_Search_Method(self, _pcl.KdTreeFLANN kdtree):
+ */
+  __pyx_v_self->me->setSearchMethod(__pyx_v_kdtree->thisptr_shared);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":42
+ *         self.me.setComputeNormals(flag)
+ * 
+ *     def set_Search_Method(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *        # self.me.setSearchMethod(kdtree.thisptr()[0])
+ *        # self.me.setSearchMethod(kdtree.thisptr())
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":51
+ *     #    self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ *     def process(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the smoothing according to the previously set values and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_15process(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_14process[] = "MovingLeastSquares.process(self)\n\n        Apply the smoothing according to the previously set values and return\n        a new PointCloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_15process(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("process (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18MovingLeastSquares_14process(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18MovingLeastSquares_14process(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("process", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":56
+ *         a new PointCloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.process(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":57
+ *         """
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.process(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ *         # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+ */
+  try {
+    __pyx_v_self->me->process((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(11, 57, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":58
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.process(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ *         # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+ *         # self.me.process(pcNormal.thisptr()[0])
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":51
+ *     #    self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ *     def process(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the smoothing according to the previously set values and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares.process", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":112
+ *     cdef pclsf.MovingLeastSquares_PointXYZRGB_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGB_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":113
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGB_t();
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":112
+ *     cdef pclsf.MovingLeastSquares_PointXYZRGB_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGB_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":115
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGB_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":116
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_search_radius(self, double radius):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":115
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGB_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":118
+ *         del self.me
+ * 
+ *     def set_search_radius(self, double radius):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_5set_search_radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_4set_search_radius[] = "MovingLeastSquares_PointXYZRGB.set_search_radius(self, double radius)\n\n        Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_5set_search_radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius) {
+  double __pyx_v_radius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_search_radius (wrapper)", 0);
+  assert(__pyx_arg_radius); {
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(__pyx_arg_radius); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 118, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGB.set_search_radius", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_4set_search_radius(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *)__pyx_v_self), ((double)__pyx_v_radius));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_4set_search_radius(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self, double __pyx_v_radius) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_search_radius", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":122
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ *         """
+ *         self.me.setSearchRadius (radius)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_polynomial_order(self, bool order):
+ */
+  __pyx_v_self->me->setSearchRadius(__pyx_v_radius);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":118
+ *         del self.me
+ * 
+ *     def set_search_radius(self, double radius):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":124
+ *         self.me.setSearchRadius (radius)
+ * 
+ *     def set_polynomial_order(self, bool order):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the order of the polynomial to be fit.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_7set_polynomial_order(PyObject *__pyx_v_self, PyObject *__pyx_arg_order); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_6set_polynomial_order[] = "MovingLeastSquares_PointXYZRGB.set_polynomial_order(self, bool order)\n\n        Set the order of the polynomial to be fit. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_7set_polynomial_order(PyObject *__pyx_v_self, PyObject *__pyx_arg_order) {
+  bool __pyx_v_order;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_order (wrapper)", 0);
+  assert(__pyx_arg_order); {
+    __pyx_v_order = __Pyx_PyObject_IsTrue(__pyx_arg_order); if (unlikely((__pyx_v_order == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(11, 124, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGB.set_polynomial_order", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_6set_polynomial_order(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *)__pyx_v_self), ((bool)__pyx_v_order));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_6set_polynomial_order(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self, bool __pyx_v_order) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_order", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":128
+ *         Set the order of the polynomial to be fit.
+ *         """
+ *         self.me.setPolynomialOrder(order)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_polynomial_fit(self, bint fit):
+ */
+  __pyx_v_self->me->setPolynomialOrder(__pyx_v_order);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":124
+ *         self.me.setSearchRadius (radius)
+ * 
+ *     def set_polynomial_order(self, bool order):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the order of the polynomial to be fit.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":130
+ *         self.me.setPolynomialOrder(order)
+ * 
+ *     def set_polynomial_fit(self, bint fit):             # <<<<<<<<<<<<<<
+ *         """
+ *         Sets whether the surface and normal are approximated using a polynomial,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_9set_polynomial_fit(PyObject *__pyx_v_self, PyObject *__pyx_arg_fit); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_8set_polynomial_fit[] = "MovingLeastSquares_PointXYZRGB.set_polynomial_fit(self, bool fit)\n\n        Sets whether the surface and normal are approximated using a polynomial,\n        or only via tangent estimation.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_9set_polynomial_fit(PyObject *__pyx_v_self, PyObject *__pyx_arg_fit) {
+  int __pyx_v_fit;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_fit (wrapper)", 0);
+  assert(__pyx_arg_fit); {
+    __pyx_v_fit = __Pyx_PyObject_IsTrue(__pyx_arg_fit); if (unlikely((__pyx_v_fit == (int)-1) && PyErr_Occurred())) __PYX_ERR(11, 130, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGB.set_polynomial_fit", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_8set_polynomial_fit(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *)__pyx_v_self), ((int)__pyx_v_fit));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_8set_polynomial_fit(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self, int __pyx_v_fit) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_fit", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":135
+ *         or only via tangent estimation.
+ *         """
+ *         self.me.setPolynomialFit(fit)             # <<<<<<<<<<<<<<
+ * 
+ *     def process(self):
+ */
+  __pyx_v_self->me->setPolynomialFit(__pyx_v_fit);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":130
+ *         self.me.setPolynomialOrder(order)
+ * 
+ *     def set_polynomial_fit(self, bint fit):             # <<<<<<<<<<<<<<
+ *         """
+ *         Sets whether the surface and normal are approximated using a polynomial,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":137
+ *         self.me.setPolynomialFit(fit)
+ * 
+ *     def process(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the smoothing according to the previously set values and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_11process(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_10process[] = "MovingLeastSquares_PointXYZRGB.process(self)\n\n        Apply the smoothing according to the previously set values and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_11process(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("process (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_10process(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_10process(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("process", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":142
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         self.me.process(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":143
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.process(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ *         # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+ */
+  try {
+    __pyx_v_self->me->process((__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_pc)[0]));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(11, 143, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":144
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.process(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ *         # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+ *         # self.me.process(pcNormal.thisptr()[0])
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":137
+ *         self.me.setPolynomialFit(fit)
+ * 
+ *     def process(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the smoothing according to the previously set values and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGB.process", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":156
+ *     cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGBA_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":157
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":156
+ *     cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGBA_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":159
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGBA_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":160
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_search_radius(self, double radius):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":159
+ *         self.me = new pclsf.MovingLeastSquares_PointXYZRGBA_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":162
+ *         del self.me
+ * 
+ *     def set_search_radius(self, double radius):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_5set_search_radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_4set_search_radius[] = "MovingLeastSquares_PointXYZRGBA.set_search_radius(self, double radius)\n\n        Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_5set_search_radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius) {
+  double __pyx_v_radius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_search_radius (wrapper)", 0);
+  assert(__pyx_arg_radius); {
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(__pyx_arg_radius); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(11, 162, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGBA.set_search_radius", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_4set_search_radius(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *)__pyx_v_self), ((double)__pyx_v_radius));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_4set_search_radius(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self, double __pyx_v_radius) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_search_radius", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":166
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ *         """
+ *         self.me.setSearchRadius (radius)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_polynomial_order(self, bool order):
+ */
+  __pyx_v_self->me->setSearchRadius(__pyx_v_radius);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":162
+ *         del self.me
+ * 
+ *     def set_search_radius(self, double radius):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":168
+ *         self.me.setSearchRadius (radius)
+ * 
+ *     def set_polynomial_order(self, bool order):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the order of the polynomial to be fit.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_7set_polynomial_order(PyObject *__pyx_v_self, PyObject *__pyx_arg_order); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_6set_polynomial_order[] = "MovingLeastSquares_PointXYZRGBA.set_polynomial_order(self, bool order)\n\n        Set the order of the polynomial to be fit. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_7set_polynomial_order(PyObject *__pyx_v_self, PyObject *__pyx_arg_order) {
+  bool __pyx_v_order;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_order (wrapper)", 0);
+  assert(__pyx_arg_order); {
+    __pyx_v_order = __Pyx_PyObject_IsTrue(__pyx_arg_order); if (unlikely((__pyx_v_order == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(11, 168, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGBA.set_polynomial_order", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_6set_polynomial_order(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *)__pyx_v_self), ((bool)__pyx_v_order));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_6set_polynomial_order(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self, bool __pyx_v_order) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_order", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":172
+ *         Set the order of the polynomial to be fit.
+ *         """
+ *         self.me.setPolynomialOrder(order)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_polynomial_fit(self, bint fit):
+ */
+  __pyx_v_self->me->setPolynomialOrder(__pyx_v_order);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":168
+ *         self.me.setSearchRadius (radius)
+ * 
+ *     def set_polynomial_order(self, bool order):             # <<<<<<<<<<<<<<
+ *         """
+ *         Set the order of the polynomial to be fit.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":174
+ *         self.me.setPolynomialOrder(order)
+ * 
+ *     def set_polynomial_fit(self, bint fit):             # <<<<<<<<<<<<<<
+ *         """
+ *         Sets whether the surface and normal are approximated using a polynomial,
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_9set_polynomial_fit(PyObject *__pyx_v_self, PyObject *__pyx_arg_fit); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_8set_polynomial_fit[] = "MovingLeastSquares_PointXYZRGBA.set_polynomial_fit(self, bool fit)\n\n        Sets whether the surface and normal are approximated using a polynomial,\n        or only via tangent estimation.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_9set_polynomial_fit(PyObject *__pyx_v_self, PyObject *__pyx_arg_fit) {
+  int __pyx_v_fit;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_fit (wrapper)", 0);
+  assert(__pyx_arg_fit); {
+    __pyx_v_fit = __Pyx_PyObject_IsTrue(__pyx_arg_fit); if (unlikely((__pyx_v_fit == (int)-1) && PyErr_Occurred())) __PYX_ERR(11, 174, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGBA.set_polynomial_fit", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_8set_polynomial_fit(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *)__pyx_v_self), ((int)__pyx_v_fit));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_8set_polynomial_fit(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self, int __pyx_v_fit) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_polynomial_fit", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":179
+ *         or only via tangent estimation.
+ *         """
+ *         self.me.setPolynomialFit(fit)             # <<<<<<<<<<<<<<
+ * 
+ *     def process(self):
+ */
+  __pyx_v_self->me->setPolynomialFit(__pyx_v_fit);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":174
+ *         self.me.setPolynomialOrder(order)
+ * 
+ *     def set_polynomial_fit(self, bint fit):             # <<<<<<<<<<<<<<
+ *         """
+ *         Sets whether the surface and normal are approximated using a polynomial,
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/MovingLeastSquares.pxi":181
+ *         self.me.setPolynomialFit(fit)
+ * 
+ *     def process(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the smoothing according to the previously set values and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_11process(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_10process[] = "MovingLeastSquares_PointXYZRGBA.process(self)\n\n        Apply the smoothing according to the previously set values and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_11process(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("process (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_10process(((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_10process(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("process", 0);
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":186
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         self.me.process(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(11, 186, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":187
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.process(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ *         # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+ */
+  try {
+    __pyx_v_self->me->process((__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_pc)[0]));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(11, 187, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":188
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.process(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ *         # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+ *         # self.me.process(pcNormal.thisptr()[0])
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Surface/MovingLeastSquares.pxi":181
+ *         self.me.setPolynomialFit(fit)
+ * 
+ *     def process(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the smoothing according to the previously set values and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.MovingLeastSquares_PointXYZRGBA.process", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":15
+ *     cdef pclkdt.KdTreeFLANN_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_11KdTreeFLANN_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_11KdTreeFLANN_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(12, 15, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 15, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(12, 15, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11KdTreeFLANN___cinit__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_11KdTreeFLANN___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":16
+ * 
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_t()             # <<<<<<<<<<<<<<
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_t();
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":17
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":15
+ *     cdef pclkdt.KdTreeFLANN_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":19
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_11KdTreeFLANN_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_11KdTreeFLANN_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_11KdTreeFLANN_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_11KdTreeFLANN_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":20
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":19
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":22
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11KdTreeFLANN_4nearest_k_search_for_cloud[] = "KdTreeFLANN.nearest_k_search_for_cloud(self, PointCloud pc, int k=1)\n\n        Find the k nearest neighbours and squared distances for all points\n        in the pointcloud. Results are in ndarrays, size (pc.size, k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_k,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_cloud") < 0)) __PYX_ERR(12, 22, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    if (values[1]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 22, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_cloud", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 22, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(12, 22, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11KdTreeFLANN_4nearest_k_search_for_cloud(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self), __pyx_v_pc, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11KdTreeFLANN_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_k) {
+  npy_intp __pyx_v_n_points;
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  npy_intp __pyx_t_9;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":28
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_Py_intptr_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(12, 28, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n_points = __pyx_t_2;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":29
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":30
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 30, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(12, 30, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":29
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 29, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 29, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 29, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sqdist.diminfo[1].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sqdist.diminfo[1].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":31
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":32
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n_points):
+ */
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(12, 32, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":31
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 31, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 31, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ind.diminfo[1].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ind.diminfo[1].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":34
+ *                                                      dtype=np.int32)
+ * 
+ *         for i in range(n_points):             # <<<<<<<<<<<<<<
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist
+ */
+  __pyx_t_2 = __pyx_v_n_points;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_2; __pyx_t_9+=1) {
+    __pyx_v_i = __pyx_t_9;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":35
+ * 
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_ind), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 35, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_sqdist), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 35, __pyx_L1_error)
+    try {
+      ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_i, __pyx_v_k, ((PyArrayObject *)__pyx_t_1), ((PyArrayObject *)__pyx_t_3));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(12, 35, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":36
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud pc not None, int index,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":22
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":38
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11KdTreeFLANN_6nearest_k_search_for_point[] = "KdTreeFLANN.nearest_k_search_for_point(self, PointCloud pc, int index, int k=1)\n\n        Find the k nearest neighbours and squared distances for the point\n        at pc[index]. Results are in ndarrays, size (k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_v_index;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_index,&__pyx_n_s_k,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_index)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, 1); __PYX_ERR(12, 38, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_point") < 0)) __PYX_ERR(12, 38, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_index = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_index == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 38, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 39, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 38, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(12, 38, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11KdTreeFLANN_6nearest_k_search_for_point(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self), __pyx_v_pc, __pyx_v_index, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11KdTreeFLANN_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k) {
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":45
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 45, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 45, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":46
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_int32); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 46, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_4);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 46, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":48
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+  try {
+    ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_index, __pyx_v_k, ((PyArrayObject *)__pyx_v_ind), ((PyArrayObject *)__pyx_v_sqdist));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 48, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":49
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":38
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":52
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+static void __pyx_f_3pcl_4_pcl_11KdTreeFLANN__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  __Pyx_RefNannySetupContext("_nearest_k", 0);
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_v_ind, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 52, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_v_sqdist, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 52, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":59
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)             # <<<<<<<<<<<<<<
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ */
+  try {
+    __pyx_v_k_indices.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 59, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":60
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)             # <<<<<<<<<<<<<<
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ *                                k_sqr_distances)
+ */
+  try {
+    __pyx_v_k_sqr_distances.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 60, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":61
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,             # <<<<<<<<<<<<<<
+ *                                k_sqr_distances)
+ * 
+ */
+  __pyx_v_self->me->nearestKSearch((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]), __pyx_v_index, __pyx_v_k, __pyx_v_k_indices, __pyx_v_k_sqr_distances);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":64
+ *                                k_sqr_distances)
+ * 
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]
+ */
+  __pyx_t_1 = __pyx_v_k;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":65
+ * 
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             ind[i] = k_indices[i]
+ * 
+ */
+    __pyx_t_3 = __pyx_v_i;
+    if (__pyx_t_3 < 0) __pyx_t_3 += __pyx_pybuffernd_sqdist.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(float *, __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_sqdist.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":66
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ * 
+ *     def radius_search_for_cloud(self, PointCloud pc not None, double radius, unsigned int max_nn = 0):
+ */
+    __pyx_t_4 = __pyx_v_i;
+    if (__pyx_t_4 < 0) __pyx_t_4 += __pyx_pybuffernd_ind.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(int *, __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_ind.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":52
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN._nearest_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":68
+ *             ind[i] = k_indices[i]
+ * 
+ *     def radius_search_for_cloud(self, PointCloud pc not None, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the radius and squared distances for all points
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_9radius_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11KdTreeFLANN_8radius_search_for_cloud[] = "KdTreeFLANN.radius_search_for_cloud(self, PointCloud pc, double radius, unsigned int max_nn=0)\n\n        Find the radius and squared distances for all points\n        in the pointcloud. Results are in ndarrays, size (pc.size, k)\n        Returns: (radius_indices, radius_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_9radius_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  double __pyx_v_radius;
+  unsigned int __pyx_v_max_nn;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("radius_search_for_cloud (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_radius,&__pyx_n_s_max_nn,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("radius_search_for_cloud", 0, 2, 3, 1); __PYX_ERR(12, 68, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_nn);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "radius_search_for_cloud") < 0)) __PYX_ERR(12, 68, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(12, 68, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_max_nn = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_max_nn == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(12, 68, __pyx_L3_error)
+    } else {
+      __pyx_v_max_nn = ((unsigned int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("radius_search_for_cloud", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 68, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN.radius_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(12, 68, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11KdTreeFLANN_8radius_search_for_cloud(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self), __pyx_v_pc, __pyx_v_radius, __pyx_v_max_nn);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11KdTreeFLANN_8radius_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, double __pyx_v_radius, unsigned int __pyx_v_max_nn) {
+  unsigned int __pyx_v_k;
+  npy_intp __pyx_v_n_points;
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  npy_intp __pyx_t_9;
+  __Pyx_RefNannySetupContext("radius_search_for_cloud", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":74
+ *         Returns: (radius_indices, radius_distances)
+ *         """
+ *         k = max_nn             # <<<<<<<<<<<<<<
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ */
+  __pyx_v_k = __pyx_v_max_nn;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":75
+ *         """
+ *         k = max_nn
+ *         cdef cnp.npy_intp n_points = pc.size             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 75, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_Py_intptr_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(12, 75, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n_points = __pyx_t_2;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":76
+ *         k = max_nn
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":77
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 77, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(12, 77, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":76
+ *         k = max_nn
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 76, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 76, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 76, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sqdist.diminfo[1].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sqdist.diminfo[1].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":78
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyInt_From_unsigned_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":79
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n_points):
+ */
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(12, 79, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":78
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 78, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 78, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ind.diminfo[1].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ind.diminfo[1].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":81
+ *                                                      dtype=np.int32)
+ * 
+ *         for i in range(n_points):             # <<<<<<<<<<<<<<
+ *             self._search_radius(pc, i, k, radius, ind[i], sqdist[i])
+ *         return ind, sqdist
+ */
+  __pyx_t_2 = __pyx_v_n_points;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_2; __pyx_t_9+=1) {
+    __pyx_v_i = __pyx_t_9;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":82
+ * 
+ *         for i in range(n_points):
+ *             self._search_radius(pc, i, k, radius, ind[i], sqdist[i])             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_ind), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 82, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 82, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_sqdist), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 82, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 82, __pyx_L1_error)
+    try {
+      ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN *)__pyx_v_self->__pyx_vtab)->_search_radius(__pyx_v_self, __pyx_v_pc, __pyx_v_i, __pyx_v_k, __pyx_v_radius, ((PyArrayObject *)__pyx_t_1), ((PyArrayObject *)__pyx_t_3));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(12, 82, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":83
+ *         for i in range(n_points):
+ *             self._search_radius(pc, i, k, radius, ind[i], sqdist[i])
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 83, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":68
+ *             ind[i] = k_indices[i]
+ * 
+ *     def radius_search_for_cloud(self, PointCloud pc not None, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the radius and squared distances for all points
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN.radius_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":86
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _search_radius(self, PointCloud pc, int index, int k, double radius,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+static void __pyx_f_3pcl_4_pcl_11KdTreeFLANN__search_radius(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, double __pyx_v_radius, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist) {
+  std::vector<int>  __pyx_v_radius_indices;
+  std::vector<float>  __pyx_v_radius_distances;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  __Pyx_RefNannySetupContext("_search_radius", 0);
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_v_ind, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 86, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_v_sqdist, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 86, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":93
+ *         cdef vector[int] radius_indices
+ *         cdef vector[float] radius_distances
+ *         radius_indices.resize(k)             # <<<<<<<<<<<<<<
+ *         radius_distances.resize(k)
+ *         self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)
+ */
+  try {
+    __pyx_v_radius_indices.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 93, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":94
+ *         cdef vector[float] radius_distances
+ *         radius_indices.resize(k)
+ *         radius_distances.resize(k)             # <<<<<<<<<<<<<<
+ *         self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)
+ * 
+ */
+  try {
+    __pyx_v_radius_distances.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 94, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":95
+ *         radius_indices.resize(k)
+ *         radius_distances.resize(k)
+ *         self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(k):
+ */
+  __pyx_v_self->me->radiusSearch((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]), __pyx_v_index, __pyx_v_radius, __pyx_v_radius_indices, __pyx_v_radius_distances);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":97
+ *         self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)
+ * 
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             sqdist[i] = radius_distances[i]
+ *             ind[i] = radius_indices[i]
+ */
+  __pyx_t_1 = __pyx_v_k;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":98
+ * 
+ *         for i in range(k):
+ *             sqdist[i] = radius_distances[i]             # <<<<<<<<<<<<<<
+ *             ind[i] = radius_indices[i]
+ * 
+ */
+    __pyx_t_3 = __pyx_v_i;
+    if (__pyx_t_3 < 0) __pyx_t_3 += __pyx_pybuffernd_sqdist.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(float *, __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_sqdist.diminfo[0].strides) = (__pyx_v_radius_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":99
+ *         for i in range(k):
+ *             sqdist[i] = radius_distances[i]
+ *             ind[i] = radius_indices[i]             # <<<<<<<<<<<<<<
+ * 
+ * cdef class KdTreeFLANN_PointXYZI:
+ */
+    __pyx_t_4 = __pyx_v_i;
+    if (__pyx_t_4 < 0) __pyx_t_4 += __pyx_pybuffernd_ind.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(int *, __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_ind.diminfo[0].strides) = (__pyx_v_radius_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":86
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _search_radius(self, PointCloud pc, int index, int k, double radius,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN._search_radius", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":111
+ *     cdef pclkdt.KdTreeFLANN_PointXYZI_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZI_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(12, 111, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 111, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 0, "pc", 0))) __PYX_ERR(12, 111, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":112
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZI_t()             # <<<<<<<<<<<<<<
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZI_t();
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":113
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZI_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":111
+ *     cdef pclkdt.KdTreeFLANN_PointXYZI_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZI pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZI_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":115
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":116
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZI pc not None, int k=1):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":115
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":118
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZI pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_4nearest_k_search_for_cloud[] = "KdTreeFLANN_PointXYZI.nearest_k_search_for_cloud(self, PointCloud_PointXYZI pc, int k=1)\n\n        Find the k nearest neighbours and squared distances for all points\n        in the pointcloud. Results are in ndarrays, size (pc.size, k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_k,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_cloud") < 0)) __PYX_ERR(12, 118, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)values[0]);
+    if (values[1]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 118, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_cloud", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 118, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZI.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 0, "pc", 0))) __PYX_ERR(12, 118, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_4nearest_k_search_for_cloud(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *)__pyx_v_self), __pyx_v_pc, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc, int __pyx_v_k) {
+  npy_intp __pyx_v_n_points;
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  npy_intp __pyx_t_9;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":124
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_Py_intptr_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(12, 124, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n_points = __pyx_t_2;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":125
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":126
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 126, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(12, 126, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":125
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 125, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 125, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sqdist.diminfo[1].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sqdist.diminfo[1].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":127
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":128
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n_points):
+ */
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(12, 128, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":127
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 127, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 127, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ind.diminfo[1].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ind.diminfo[1].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":130
+ *                                                      dtype=np.int32)
+ * 
+ *         for i in range(n_points):             # <<<<<<<<<<<<<<
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist
+ */
+  __pyx_t_2 = __pyx_v_n_points;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_2; __pyx_t_9+=1) {
+    __pyx_v_i = __pyx_t_9;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":131
+ * 
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_ind), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 131, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 131, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_sqdist), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 131, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 131, __pyx_L1_error)
+    try {
+      ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZI *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_i, __pyx_v_k, ((PyArrayObject *)__pyx_t_1), ((PyArrayObject *)__pyx_t_3));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(12, 131, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":132
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZI pc not None, int index,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 132, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":118
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZI pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZI.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":134
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZI pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_6nearest_k_search_for_point[] = "KdTreeFLANN_PointXYZI.nearest_k_search_for_point(self, PointCloud_PointXYZI pc, int index, int k=1)\n\n        Find the k nearest neighbours and squared distances for the point\n        at pc[index]. Results are in ndarrays, size (k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  int __pyx_v_index;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_index,&__pyx_n_s_k,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_index)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, 1); __PYX_ERR(12, 134, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_point") < 0)) __PYX_ERR(12, 134, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)values[0]);
+    __pyx_v_index = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_index == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 134, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 135, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 134, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZI.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 0, "pc", 0))) __PYX_ERR(12, 134, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_6nearest_k_search_for_point(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *)__pyx_v_self), __pyx_v_pc, __pyx_v_index, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k) {
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":141
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 141, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 141, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 141, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":142
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_int32); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 142, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_4);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 142, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":144
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+  try {
+    ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZI *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_index, __pyx_v_k, ((PyArrayObject *)__pyx_v_ind), ((PyArrayObject *)__pyx_v_sqdist));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 144, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":145
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 145, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":134
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZI pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZI.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":148
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud_PointXYZI pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+static void __pyx_f_3pcl_4_pcl_21KdTreeFLANN_PointXYZI__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  __Pyx_RefNannySetupContext("_nearest_k", 0);
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_v_ind, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 148, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_v_sqdist, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 148, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":155
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)             # <<<<<<<<<<<<<<
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ */
+  try {
+    __pyx_v_k_indices.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 155, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":156
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)             # <<<<<<<<<<<<<<
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ *                                k_sqr_distances)
+ */
+  try {
+    __pyx_v_k_sqr_distances.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 156, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":157
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,             # <<<<<<<<<<<<<<
+ *                                k_sqr_distances)
+ * 
+ */
+  __pyx_v_self->me->nearestKSearch((__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_pc)[0]), __pyx_v_index, __pyx_v_k, __pyx_v_k_indices, __pyx_v_k_sqr_distances);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":160
+ *                                k_sqr_distances)
+ * 
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]
+ */
+  __pyx_t_1 = __pyx_v_k;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":161
+ * 
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             ind[i] = k_indices[i]
+ * 
+ */
+    __pyx_t_3 = __pyx_v_i;
+    if (__pyx_t_3 < 0) __pyx_t_3 += __pyx_pybuffernd_sqdist.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(float *, __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_sqdist.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":162
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_4 = __pyx_v_i;
+    if (__pyx_t_4 < 0) __pyx_t_4 += __pyx_pybuffernd_ind.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(int *, __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_ind.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":148
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud_PointXYZI pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZI._nearest_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":175
+ *     cdef pclkdt.KdTreeFLANN_PointXYZRGB_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGB_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(12, 175, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 175, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 0, "pc", 0))) __PYX_ERR(12, 175, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":176
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGB_t();
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":177
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGB_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":175
+ *     cdef pclkdt.KdTreeFLANN_PointXYZRGB_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGB_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":179
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":180
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGB pc not None, int k=1):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":179
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":182
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGB pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_4nearest_k_search_for_cloud[] = "KdTreeFLANN_PointXYZRGB.nearest_k_search_for_cloud(self, PointCloud_PointXYZRGB pc, int k=1)\n\n        Find the k nearest neighbours and squared distances for all points\n        in the pointcloud. Results are in ndarrays, size (pc.size, k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_k,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_cloud") < 0)) __PYX_ERR(12, 182, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)values[0]);
+    if (values[1]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 182, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_cloud", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 182, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGB.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 0, "pc", 0))) __PYX_ERR(12, 182, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_4nearest_k_search_for_cloud(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *)__pyx_v_self), __pyx_v_pc, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc, int __pyx_v_k) {
+  npy_intp __pyx_v_n_points;
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  npy_intp __pyx_t_9;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":188
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 188, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_Py_intptr_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(12, 188, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n_points = __pyx_t_2;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":189
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":190
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 190, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(12, 190, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":189
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 189, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 189, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sqdist.diminfo[1].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sqdist.diminfo[1].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":191
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":192
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n_points):
+ */
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 192, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(12, 192, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":191
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 191, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 191, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 191, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ind.diminfo[1].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ind.diminfo[1].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":194
+ *                                                      dtype=np.int32)
+ * 
+ *         for i in range(n_points):             # <<<<<<<<<<<<<<
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist
+ */
+  __pyx_t_2 = __pyx_v_n_points;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_2; __pyx_t_9+=1) {
+    __pyx_v_i = __pyx_t_9;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":195
+ * 
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_ind), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 195, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 195, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_sqdist), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 195, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 195, __pyx_L1_error)
+    try {
+      ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_i, __pyx_v_k, ((PyArrayObject *)__pyx_t_1), ((PyArrayObject *)__pyx_t_3));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(12, 195, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":196
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZRGB pc not None, int index,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":182
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGB pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGB.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":198
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZRGB pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_6nearest_k_search_for_point[] = "KdTreeFLANN_PointXYZRGB.nearest_k_search_for_point(self, PointCloud_PointXYZRGB pc, int index, int k=1)\n\n        Find the k nearest neighbours and squared distances for the point\n        at pc[index]. Results are in ndarrays, size (k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  int __pyx_v_index;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_index,&__pyx_n_s_k,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_index)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, 1); __PYX_ERR(12, 198, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_point") < 0)) __PYX_ERR(12, 198, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)values[0]);
+    __pyx_v_index = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_index == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 198, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 199, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 198, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGB.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 0, "pc", 0))) __PYX_ERR(12, 198, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_6nearest_k_search_for_point(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *)__pyx_v_self), __pyx_v_pc, __pyx_v_index, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k) {
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":205
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 205, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 205, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":206
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_int32); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 206, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_4);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 206, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":208
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+  try {
+    ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_index, __pyx_v_k, ((PyArrayObject *)__pyx_v_ind), ((PyArrayObject *)__pyx_v_sqdist));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 208, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":209
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":198
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZRGB pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGB.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":212
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud_PointXYZRGB pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+static void __pyx_f_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  __Pyx_RefNannySetupContext("_nearest_k", 0);
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_v_ind, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 212, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_v_sqdist, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 212, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":219
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)             # <<<<<<<<<<<<<<
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ */
+  try {
+    __pyx_v_k_indices.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 219, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":220
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)             # <<<<<<<<<<<<<<
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ *                                k_sqr_distances)
+ */
+  try {
+    __pyx_v_k_sqr_distances.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 220, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":221
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,             # <<<<<<<<<<<<<<
+ *                                k_sqr_distances)
+ * 
+ */
+  __pyx_v_self->me->nearestKSearch((__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_pc)[0]), __pyx_v_index, __pyx_v_k, __pyx_v_k_indices, __pyx_v_k_sqr_distances);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":224
+ *                                k_sqr_distances)
+ * 
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]
+ */
+  __pyx_t_1 = __pyx_v_k;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":225
+ * 
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             ind[i] = k_indices[i]
+ * 
+ */
+    __pyx_t_3 = __pyx_v_i;
+    if (__pyx_t_3 < 0) __pyx_t_3 += __pyx_pybuffernd_sqdist.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(float *, __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_sqdist.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":226
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+    __pyx_t_4 = __pyx_v_i;
+    if (__pyx_t_4 < 0) __pyx_t_4 += __pyx_pybuffernd_ind.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(int *, __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_ind.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":212
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud_PointXYZRGB pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGB._nearest_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":239
+ *     cdef pclkdt.KdTreeFLANN_PointXYZRGBA_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGBA_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(12, 239, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 239, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 0, "pc", 0))) __PYX_ERR(12, 239, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":240
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_10pcl_kdtree_KdTreeFLANN_PointXYZRGBA_t();
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":241
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGBA_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":239
+ *     cdef pclkdt.KdTreeFLANN_PointXYZRGBA_t *me
+ * 
+ *     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclkdt.KdTreeFLANN_PointXYZRGBA_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":243
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":244
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGBA pc not None, int k=1):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":243
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":246
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGBA pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_4nearest_k_search_for_cloud[] = "KdTreeFLANN_PointXYZRGBA.nearest_k_search_for_cloud(self, PointCloud_PointXYZRGBA pc, int k=1)\n\n        Find the k nearest neighbours and squared distances for all points\n        in the pointcloud. Results are in ndarrays, size (pc.size, k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_k,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_cloud") < 0)) __PYX_ERR(12, 246, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)values[0]);
+    if (values[1]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 246, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_cloud", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 246, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGBA.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 0, "pc", 0))) __PYX_ERR(12, 246, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_4nearest_k_search_for_cloud(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *)__pyx_v_self), __pyx_v_pc, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc, int __pyx_v_k) {
+  npy_intp __pyx_v_n_points;
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  npy_intp __pyx_t_9;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":252
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 252, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_Py_intptr_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(12, 252, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n_points = __pyx_t_2;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":253
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":254
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 254, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(12, 254, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":253
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 253, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 253, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sqdist.diminfo[1].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sqdist.diminfo[1].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":255
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":256
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n_points):
+ */
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 256, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(12, 256, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 256, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(12, 256, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":255
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 255, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 255, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 255, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ind.diminfo[1].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ind.diminfo[1].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":258
+ *                                                      dtype=np.int32)
+ * 
+ *         for i in range(n_points):             # <<<<<<<<<<<<<<
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist
+ */
+  __pyx_t_2 = __pyx_v_n_points;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_2; __pyx_t_9+=1) {
+    __pyx_v_i = __pyx_t_9;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":259
+ * 
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_ind), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 259, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 259, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_sqdist), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 259, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 259, __pyx_L1_error)
+    try {
+      ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_i, __pyx_v_k, ((PyArrayObject *)__pyx_t_1), ((PyArrayObject *)__pyx_t_3));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(12, 259, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":260
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZRGBA pc not None, int index,
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":246
+ *         del self.me
+ * 
+ *     def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGBA pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGBA.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":262
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZRGBA pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_6nearest_k_search_for_point[] = "KdTreeFLANN_PointXYZRGBA.nearest_k_search_for_point(self, PointCloud_PointXYZRGBA pc, int index, int k=1)\n\n        Find the k nearest neighbours and squared distances for the point\n        at pc[index]. Results are in ndarrays, size (k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  int __pyx_v_index;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_index,&__pyx_n_s_k,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_index)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, 1); __PYX_ERR(12, 262, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_point") < 0)) __PYX_ERR(12, 262, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)values[0]);
+    __pyx_v_index = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_index == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 262, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(12, 263, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(12, 262, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGBA.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 0, "pc", 0))) __PYX_ERR(12, 262, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_6nearest_k_search_for_point(((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *)__pyx_v_self), __pyx_v_pc, __pyx_v_index, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k) {
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":269
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 269, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 269, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 269, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":270
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_int32); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 270, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(12, 270, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_4);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(12, 270, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":272
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+  try {
+    ((struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_index, __pyx_v_k, ((PyArrayObject *)__pyx_v_ind), ((PyArrayObject *)__pyx_v_sqdist));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 272, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":273
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(12, 273, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":262
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud_PointXYZRGBA pc not None, int index,             # <<<<<<<<<<<<<<
+ *                                    int k=1):
+ *         """
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGBA.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KdTree/KdTree_FLANN.pxi":276
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud_PointXYZRGBA pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+static void __pyx_f_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA__nearest_k(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  __Pyx_RefNannySetupContext("_nearest_k", 0);
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_v_ind, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 276, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_v_sqdist, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(12, 276, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":283
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)             # <<<<<<<<<<<<<<
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ */
+  try {
+    __pyx_v_k_indices.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 283, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":284
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)             # <<<<<<<<<<<<<<
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+ *                                k_sqr_distances)
+ */
+  try {
+    __pyx_v_k_sqr_distances.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(12, 284, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":285
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)
+ *         self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,             # <<<<<<<<<<<<<<
+ *                                k_sqr_distances)
+ * 
+ */
+  __pyx_v_self->me->nearestKSearch((__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_pc)[0]), __pyx_v_index, __pyx_v_k, __pyx_v_k_indices, __pyx_v_k_sqr_distances);
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":288
+ *                                k_sqr_distances)
+ * 
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]
+ */
+  __pyx_t_1 = __pyx_v_k;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":289
+ * 
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             ind[i] = k_indices[i]
+ * 
+ */
+    __pyx_t_3 = __pyx_v_i;
+    if (__pyx_t_3 < 0) __pyx_t_3 += __pyx_pybuffernd_sqdist.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(float *, __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_sqdist.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":290
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ * 
+ */
+    __pyx_t_4 = __pyx_v_i;
+    if (__pyx_t_4 < 0) __pyx_t_4 += __pyx_pybuffernd_ind.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(int *, __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_ind.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/KdTree/KdTree_FLANN.pxi":276
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud_PointXYZRGBA pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.KdTreeFLANN_PointXYZRGBA._nearest_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":32
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16OctreePointCloud_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16OctreePointCloud_set_input_cloud[] = "OctreePointCloud.set_input_cloud(self, PointCloud pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_16OctreePointCloud_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "pc", 0))) __PYX_ERR(13, 32, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16OctreePointCloud_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16OctreePointCloud_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":36
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":32
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":56
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16OctreePointCloud_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16OctreePointCloud_2delete_tree[] = "OctreePointCloud.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_16OctreePointCloud_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16OctreePointCloud_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16OctreePointCloud_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":60
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":56
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":113
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZI pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_26OctreePointCloud_PointXYZI_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_26OctreePointCloud_PointXYZI_set_input_cloud[] = "OctreePointCloud_PointXYZI.set_input_cloud(self, PointCloud_PointXYZI pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_26OctreePointCloud_PointXYZI_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 1, "pc", 0))) __PYX_ERR(13, 113, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26OctreePointCloud_PointXYZI_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_26OctreePointCloud_PointXYZI_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":117
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":113
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZI pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":137
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_26OctreePointCloud_PointXYZI_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_26OctreePointCloud_PointXYZI_2delete_tree[] = "OctreePointCloud_PointXYZI.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_26OctreePointCloud_PointXYZI_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26OctreePointCloud_PointXYZI_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_26OctreePointCloud_PointXYZI_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":141
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":137
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":195
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_set_input_cloud[] = "OctreePointCloud_PointXYZRGB.set_input_cloud(self, PointCloud_PointXYZRGB pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 0, "pc", 0))) __PYX_ERR(13, 195, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":199
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":195
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGB pc not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":219
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_2delete_tree[] = "OctreePointCloud_PointXYZRGB.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":223
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":219
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":273
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGBA pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_set_input_cloud[] = "OctreePointCloud_PointXYZRGBA.set_input_cloud(self, PointCloud_PointXYZRGBA pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 1, "pc", 0))) __PYX_ERR(13, 273, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":277
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":273
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGBA pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud_180.pxi":298
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_2delete_tree[] = "OctreePointCloud_PointXYZRGBA.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":302
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud_180.pxi":298
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":29
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20OctreePointCloud2Buf_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20OctreePointCloud2Buf_set_input_cloud[] = "OctreePointCloud2Buf.set_input_cloud(self, PointCloud pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20OctreePointCloud2Buf_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "pc", 0))) __PYX_ERR(14, 29, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20OctreePointCloud2Buf_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20OctreePointCloud2Buf_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":33
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":29
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":53
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20OctreePointCloud2Buf_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20OctreePointCloud2Buf_2delete_tree[] = "OctreePointCloud2Buf.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20OctreePointCloud2Buf_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20OctreePointCloud2Buf_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20OctreePointCloud2Buf_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":57
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":53
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":107
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZI pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_set_input_cloud[] = "OctreePointCloud2Buf_PointXYZI.set_input_cloud(self, PointCloud_PointXYZI pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI, 1, "pc", 0))) __PYX_ERR(14, 107, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":111
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":107
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZI pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":131
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_2delete_tree[] = "OctreePointCloud2Buf_PointXYZI.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":135
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":131
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":186
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGB pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_set_input_cloud[] = "OctreePointCloud2Buf_PointXYZRGB.set_input_cloud(self, PointCloud_PointXYZRGB pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB, 1, "pc", 0))) __PYX_ERR(14, 186, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":190
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":186
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGB pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":210
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_2delete_tree[] = "OctreePointCloud2Buf_PointXYZRGB.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":214
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":210
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":261
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGBA pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_set_input_cloud[] = "OctreePointCloud2Buf_PointXYZRGBA.set_input_cloud(self, PointCloud_PointXYZRGBA pc)\n\n        Provide a pointer to the input data set.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_1set_input_cloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA, 1, "pc", 0))) __PYX_ERR(14, 261, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_set_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_set_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":265
+ *         Provide a pointer to the input data set.
+ *         """
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self):
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":261
+ *     #     self.me = NULL      # just to be sure
+ * 
+ *     def set_input_cloud(self, PointCloud_PointXYZRGBA pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Provide a pointer to the input data set.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":286
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_2delete_tree[] = "OctreePointCloud2Buf_PointXYZRGBA.delete_tree(self)\n\n        Delete the octree structure and its leaf nodes.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_3delete_tree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_2delete_tree(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_2delete_tree(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_tree", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":290
+ *         Delete the octree structure and its leaf nodes.
+ *         """
+ *         self.me.deleteTree()             # <<<<<<<<<<<<<<
+ * 
+ *     # def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me->deleteTree();
+
+  /* "pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi":286
+ *     #     self.me.addPointsFromInputCloud()
+ * 
+ *     def delete_tree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete the octree structure and its leaf nodes.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":14
+ *     cdef pcloct.OctreePointCloudSearch_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 14, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 14, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 14, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":18
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":19
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":20
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":21
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_t*> new pcloct.OctreePointCloudSearch_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 21, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 21, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":20
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":23
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_t*> new pcloct.OctreePointCloudSearch_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":24
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_t*> new pcloct.OctreePointCloudSearch_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":14
+ *     cdef pcloct.OctreePointCloudSearch_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":26
+ *         self.me = <pcloct.OctreePointCloud_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":27
+ * 
+ *     def __dealloc__(self):
+ *         del self.me2             # <<<<<<<<<<<<<<
+ *         self.me2 = NULL
+ *         self.me = NULL
+ */
+  delete __pyx_v_self->me2;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":28
+ *     def __dealloc__(self):
+ *         del self.me2
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ * 
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":29
+ *         del self.me2
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     # nearestKSearch
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":26
+ *         self.me = <pcloct.OctreePointCloud_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":33
+ *     # nearestKSearch
+ *     ###
+ *     def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_4nearest_k_search_for_cloud[] = "OctreePointCloudSearch.nearest_k_search_for_cloud(self, PointCloud pc, int k=1)\n\n        Find the k nearest neighbours and squared distances for all points\n        in the pointcloud. Results are in ndarrays, size (pc.size, k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_5nearest_k_search_for_cloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_k,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_cloud") < 0)) __PYX_ERR(2, 33, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    if (values[1]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 33, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_cloud", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 33, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(2, 33, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_4nearest_k_search_for_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self), __pyx_v_pc, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_4nearest_k_search_for_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_k) {
+  npy_intp __pyx_v_n_points;
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  npy_intp __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  npy_intp __pyx_t_9;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_cloud", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":39
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyInt_As_Py_intptr_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(2, 39, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_n_points = __pyx_t_2;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":40
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_1 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":41
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(2, 41, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":40
+ *         """
+ *         cdef cnp.npy_intp n_points = pc.size
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 40, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 40, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sqdist.diminfo[1].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sqdist.diminfo[1].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":42
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n_points); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":43
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+ *                                                      dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n_points):
+ */
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_int32); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(2, 43, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":42
+ *         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+ *                                                           dtype=np.float32)
+ *         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),             # <<<<<<<<<<<<<<
+ *                                                      dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 42, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 42, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ind.diminfo[1].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ind.diminfo[1].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[1];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":45
+ *                                                      dtype=np.int32)
+ * 
+ *         for i in range(n_points):             # <<<<<<<<<<<<<<
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist
+ */
+  __pyx_t_2 = __pyx_v_n_points;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_2; __pyx_t_9+=1) {
+    __pyx_v_i = __pyx_t_9;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":46
+ * 
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+    __pyx_t_1 = __Pyx_GetItemInt(((PyObject *)__pyx_v_ind), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 46, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 46, __pyx_L1_error)
+    __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_sqdist), __pyx_v_i, npy_intp, 1, __Pyx_PyInt_From_Py_intptr_t, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 46, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 46, __pyx_L1_error)
+    try {
+      ((struct __pyx_vtabstruct_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_i, __pyx_v_k, ((PyArrayObject *)__pyx_t_1), ((PyArrayObject *)__pyx_t_3));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 46, __pyx_L1_error)
+    }
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":47
+ *         for i in range(n_points):
+ *             self._nearest_k(pc, i, k, ind[i], sqdist[i])
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud pc not None, int index, int k=1):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_3, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":33
+ *     # nearestKSearch
+ *     ###
+ *     def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for all points
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.nearest_k_search_for_cloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":49
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud pc not None, int index, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for the point
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_6nearest_k_search_for_point[] = "OctreePointCloudSearch.nearest_k_search_for_point(self, PointCloud pc, int index, int k=1)\n\n        Find the k nearest neighbours and squared distances for the point\n        at pc[index]. Results are in ndarrays, size (k)\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_7nearest_k_search_for_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_v_index;
+  int __pyx_v_k;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,&__pyx_n_s_index,&__pyx_n_s_k,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_index)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, 1); __PYX_ERR(2, 49, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_k);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nearest_k_search_for_point") < 0)) __PYX_ERR(2, 49, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_index = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_index == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 49, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_k = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_k == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 49, __pyx_L3_error)
+    } else {
+      __pyx_v_k = ((int)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("nearest_k_search_for_point", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 49, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(2, 49, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_6nearest_k_search_for_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self), __pyx_v_pc, __pyx_v_index, __pyx_v_k);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_6nearest_k_search_for_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k) {
+  PyArrayObject *__pyx_v_sqdist = 0;
+  PyArrayObject *__pyx_v_ind = 0;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("nearest_k_search_for_point", 0);
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":55
+ *         Returns: (k_indices, k_sqr_distances)
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 55, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_sqdist = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 55, __pyx_L1_error)
+    } else {__pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_sqdist = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":56
+ *         """
+ *         cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_int32); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 56, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_4);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_ind = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 56, __pyx_L1_error)
+    } else {__pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_ind = ((PyArrayObject *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":58
+ *         cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)             # <<<<<<<<<<<<<<
+ *         return ind, sqdist
+ * 
+ */
+  try {
+    ((struct __pyx_vtabstruct_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self->__pyx_vtab)->_nearest_k(__pyx_v_self, __pyx_v_pc, __pyx_v_index, __pyx_v_k, ((PyArrayObject *)__pyx_v_ind), ((PyArrayObject *)__pyx_v_sqdist));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(2, 58, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":59
+ * 
+ *         self._nearest_k(pc, index, k, ind, sqdist)
+ *         return ind, sqdist             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(((PyObject *)__pyx_v_ind));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_ind));
+  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_ind));
+  __Pyx_INCREF(((PyObject *)__pyx_v_sqdist));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_sqdist));
+  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_sqdist));
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":49
+ *         return ind, sqdist
+ * 
+ *     def nearest_k_search_for_point(self, PointCloud pc not None, int index, int k=1):             # <<<<<<<<<<<<<<
+ *         """
+ *         Find the k nearest neighbours and squared distances for the point
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.nearest_k_search_for_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_sqdist);
+  __Pyx_XDECREF((PyObject *)__pyx_v_ind);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":62
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+static void __pyx_f_3pcl_4_pcl_22OctreePointCloudSearch__nearest_k(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc, int __pyx_v_index, int __pyx_v_k, PyArrayObject *__pyx_v_ind, PyArrayObject *__pyx_v_sqdist) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_ind;
+  __Pyx_Buffer __pyx_pybuffer_ind;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_sqdist;
+  __Pyx_Buffer __pyx_pybuffer_sqdist;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  Py_ssize_t __pyx_t_4;
+  __Pyx_RefNannySetupContext("_nearest_k", 0);
+  __pyx_pybuffer_ind.pybuffer.buf = NULL;
+  __pyx_pybuffer_ind.refcount = 0;
+  __pyx_pybuffernd_ind.data = NULL;
+  __pyx_pybuffernd_ind.rcbuffer = &__pyx_pybuffer_ind;
+  __pyx_pybuffer_sqdist.pybuffer.buf = NULL;
+  __pyx_pybuffer_sqdist.refcount = 0;
+  __pyx_pybuffernd_sqdist.data = NULL;
+  __pyx_pybuffernd_sqdist.rcbuffer = &__pyx_pybuffer_sqdist;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ind.rcbuffer->pybuffer, (PyObject*)__pyx_v_ind, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(2, 62, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_ind.diminfo[0].strides = __pyx_pybuffernd_ind.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ind.diminfo[0].shape = __pyx_pybuffernd_ind.rcbuffer->pybuffer.shape[0];
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer, (PyObject*)__pyx_v_sqdist, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) __PYX_ERR(2, 62, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_sqdist.diminfo[0].strides = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sqdist.diminfo[0].shape = __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.shape[0];
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":69
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)             # <<<<<<<<<<<<<<
+ *         k_sqr_distances.resize(k)
+ *         # self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+ */
+  try {
+    __pyx_v_k_indices.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(2, 69, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":70
+ *         cdef vector[float] k_sqr_distances
+ *         k_indices.resize(k)
+ *         k_sqr_distances.resize(k)             # <<<<<<<<<<<<<<
+ *         # self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+ *         (<pcloct.OctreePointCloudSearch_t*>self.me).nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+ */
+  try {
+    __pyx_v_k_sqr_distances.resize(__pyx_v_k);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(2, 70, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":72
+ *         k_sqr_distances.resize(k)
+ *         # self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+ *         (<pcloct.OctreePointCloudSearch_t*>self.me).nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(k):
+ */
+  ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_t *)__pyx_v_self->__pyx_base.me)->nearestKSearch((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]), __pyx_v_index, __pyx_v_k, __pyx_v_k_indices, __pyx_v_k_sqr_distances);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":74
+ *         (<pcloct.OctreePointCloudSearch_t*>self.me).nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+ * 
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]
+ */
+  __pyx_t_1 = __pyx_v_k;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":75
+ * 
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             ind[i] = k_indices[i]
+ * 
+ */
+    __pyx_t_3 = __pyx_v_i;
+    if (__pyx_t_3 < 0) __pyx_t_3 += __pyx_pybuffernd_sqdist.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(float *, __pyx_pybuffernd_sqdist.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_sqdist.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":76
+ *         for i in range(k):
+ *             sqdist[i] = k_sqr_distances[i]
+ *             ind[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ * 
+ *     ###
+ */
+    __pyx_t_4 = __pyx_v_i;
+    if (__pyx_t_4 < 0) __pyx_t_4 += __pyx_pybuffernd_ind.diminfo[0].shape;
+    *__Pyx_BufPtrCContig1d(int *, __pyx_pybuffernd_ind.rcbuffer->pybuffer.buf, __pyx_t_4, __pyx_pybuffernd_ind.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":62
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _nearest_k(self, PointCloud pc, int index, int k,             # <<<<<<<<<<<<<<
+ *                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+ *                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch._nearest_k", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ind.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sqdist.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":82
+ *     # radius Search
+ *     ###
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_9radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_8radius_search[] = "OctreePointCloudSearch.radius_search(self, point, double radius, unsigned int max_nn=0)\n\n        Search for all neighbors of query point that are within a given radius.\n        \n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_9radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_point = 0;
+  double __pyx_v_radius;
+  unsigned int __pyx_v_max_nn;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("radius_search (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_point,&__pyx_n_s_radius,&__pyx_n_s_max_nn,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_point)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, 1); __PYX_ERR(2, 82, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_nn);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "radius_search") < 0)) __PYX_ERR(2, 82, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_point = values[0];
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 82, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_max_nn = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_max_nn == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 82, __pyx_L3_error)
+    } else {
+      __pyx_v_max_nn = ((unsigned int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 82, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_8radius_search(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self), __pyx_v_point, __pyx_v_radius, __pyx_v_max_nn);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_8radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_k;
+  PyArrayObject *__pyx_v_np_k_sqr_distances = 0;
+  PyArrayObject *__pyx_v_np_k_indices = 0;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_indices;
+  __Pyx_Buffer __pyx_pybuffer_np_k_indices;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_sqr_distances;
+  __Pyx_Buffer __pyx_pybuffer_np_k_sqr_distances;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  int __pyx_t_12;
+  Py_ssize_t __pyx_t_13;
+  __Pyx_RefNannySetupContext("radius_search", 0);
+  __pyx_pybuffer_np_k_sqr_distances.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_sqr_distances.refcount = 0;
+  __pyx_pybuffernd_np_k_sqr_distances.data = NULL;
+  __pyx_pybuffernd_np_k_sqr_distances.rcbuffer = &__pyx_pybuffer_np_k_sqr_distances;
+  __pyx_pybuffer_np_k_indices.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_indices.refcount = 0;
+  __pyx_pybuffernd_np_k_indices.data = NULL;
+  __pyx_pybuffernd_np_k_indices.rcbuffer = &__pyx_pybuffer_np_k_indices;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":90
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  __pyx_t_1 = ((__pyx_v_max_nn > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":91
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)             # <<<<<<<<<<<<<<
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ */
+    try {
+      __pyx_v_k_indices.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 91, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":92
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)             # <<<<<<<<<<<<<<
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ */
+    try {
+      __pyx_v_k_sqr_distances.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 92, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":90
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":93
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ */
+  __pyx_v_k = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_t *)__pyx_v_self->__pyx_base.me)->radiusSearch(__pyx_f_3pcl_4_pcl_to_point_t(__pyx_v_point), __pyx_v_radius, __pyx_v_k_indices, __pyx_v_k_sqr_distances, __pyx_v_max_nn);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":94
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 94, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 94, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_sqr_distances = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 94, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_np_k_sqr_distances = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":95
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 95, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_indices = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 95, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_indices.diminfo[0].strides = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_indices.diminfo[0].shape = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_np_k_indices = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":96
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ */
+  __pyx_t_9 = __pyx_v_k;
+  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+    __pyx_v_i = __pyx_t_10;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":97
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances
+ */
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_11 < 0) {
+      __pyx_t_11 += __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape;
+      if (unlikely(__pyx_t_11 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 97, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":98
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ *         return np_k_indices, np_k_sqr_distances
+ * 
+ */
+    __pyx_t_13 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_13 < 0) {
+      __pyx_t_13 += __pyx_pybuffernd_np_k_indices.diminfo[0].shape;
+      if (unlikely(__pyx_t_13 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_np_k_indices.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 98, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(int *, __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_np_k_indices.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":99
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances             # <<<<<<<<<<<<<<
+ * 
+ *     ###
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_indices));
+  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_np_k_sqr_distances));
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":82
+ *     # radius Search
+ *     ###
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_sqr_distances);
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_indices);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":105
+ *     # Voxel Search
+ *     ###
+ *     def VoxelSearch (self, PointCloud pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given voxel.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_11VoxelSearch(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_10VoxelSearch[] = "OctreePointCloudSearch.VoxelSearch(self, PointCloud pc)\n\n        Search for all neighbors of query point that are within a given voxel.\n        \n        Returns: (v_indices)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_11VoxelSearch(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("VoxelSearch (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "pc", 0))) __PYX_ERR(2, 105, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_10VoxelSearch(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_10VoxelSearch(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  std::vector<int>  __pyx_v_v_indices;
+  PyObject *__pyx_v_result = NULL;
+  struct pcl::PointXYZ __pyx_v_point;
+  size_t __pyx_v_v;
+  PyArrayObject *__pyx_v_np_v_indices = 0;
+  size_t __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_v_indices;
+  __Pyx_Buffer __pyx_pybuffer_np_v_indices;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  float __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  size_t __pyx_t_8;
+  size_t __pyx_t_9;
+  size_t __pyx_t_10;
+  int __pyx_t_11;
+  __Pyx_RefNannySetupContext("VoxelSearch", 0);
+  __pyx_pybuffer_np_v_indices.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_v_indices.refcount = 0;
+  __pyx_pybuffernd_np_v_indices.data = NULL;
+  __pyx_pybuffernd_np_v_indices.rcbuffer = &__pyx_pybuffer_np_v_indices;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":114
+ *         # cdef bool isVexelSearch = (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(pc.thisptr()[0], v_indices)
+ *         # self._VoxelSearch(pc, v_indices)
+ *         result = pc.to_array()             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZ point
+ *         point.x = result[0, 0]
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 114, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 114, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 114, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_result = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":116
+ *         result = pc.to_array()
+ *         cdef cpp.PointXYZ point
+ *         point.x = result[0, 0]             # <<<<<<<<<<<<<<
+ *         point.y = result[0, 1]
+ *         point.z = result[0, 2]
+ */
+  __pyx_t_1 = PyObject_GetItem(__pyx_v_result, __pyx_tuple__5); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(2, 116, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_point.x = __pyx_t_4;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":117
+ *         cdef cpp.PointXYZ point
+ *         point.x = result[0, 0]
+ *         point.y = result[0, 1]             # <<<<<<<<<<<<<<
+ *         point.z = result[0, 2]
+ * 
+ */
+  __pyx_t_1 = PyObject_GetItem(__pyx_v_result, __pyx_tuple__6); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(2, 117, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_point.y = __pyx_t_4;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":118
+ *         point.x = result[0, 0]
+ *         point.y = result[0, 1]
+ *         point.z = result[0, 2]             # <<<<<<<<<<<<<<
+ * 
+ *         print ('VoxelSearch at (' + str(point.x) + ' ' + str(point.y) + ' ' + str(point.z) + ')')
+ */
+  __pyx_t_1 = PyObject_GetItem(__pyx_v_result, __pyx_tuple__7); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_4 == (float)-1) && PyErr_Occurred())) __PYX_ERR(2, 118, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_point.z = __pyx_t_4;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":120
+ *         point.z = result[0, 2]
+ * 
+ *         print ('VoxelSearch at (' + str(point.x) + ' ' + str(point.y) + ' ' + str(point.z) + ')')             # <<<<<<<<<<<<<<
+ * 
+ *         # print('before v_indices count = ' + str(v_indices.size()))
+ */
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_point.x); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_VoxelSearch_at, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_kp_s__8); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_point.y); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_kp_s__8); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_point.z); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_kp_s__9); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(2, 120, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":123
+ * 
+ *         # print('before v_indices count = ' + str(v_indices.size()))
+ *         self._VoxelSearch(point, v_indices)             # <<<<<<<<<<<<<<
+ *         v = v_indices.size()
+ *         # print('after v_indices count = ' + str(v))
+ */
+  try {
+    ((struct __pyx_vtabstruct_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self->__pyx_vtab)->_VoxelSearch(__pyx_v_self, __pyx_v_point, __pyx_v_v_indices);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(2, 123, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":124
+ *         # print('before v_indices count = ' + str(v_indices.size()))
+ *         self._VoxelSearch(point, v_indices)
+ *         v = v_indices.size()             # <<<<<<<<<<<<<<
+ *         # print('after v_indices count = ' + str(v))
+ * 
+ */
+  __pyx_v_v = __pyx_v_v_indices.size();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":127
+ *         # print('after v_indices count = ' + str(v))
+ * 
+ *         cdef cnp.ndarray[int] np_v_indices = np.zeros(v, dtype=np.int32)             # <<<<<<<<<<<<<<
+ *         for i in range(v):
+ *             np_v_indices[i] = v_indices[i]
+ */
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_v); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_int32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 127, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 127, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_v_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_v_indices = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_v_indices.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 127, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_v_indices.diminfo[0].strides = __pyx_pybuffernd_np_v_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_v_indices.diminfo[0].shape = __pyx_pybuffernd_np_v_indices.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_np_v_indices = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":128
+ * 
+ *         cdef cnp.ndarray[int] np_v_indices = np.zeros(v, dtype=np.int32)
+ *         for i in range(v):             # <<<<<<<<<<<<<<
+ *             np_v_indices[i] = v_indices[i]
+ * 
+ */
+  __pyx_t_8 = __pyx_v_v;
+  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) {
+    __pyx_v_i = __pyx_t_9;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":129
+ *         cdef cnp.ndarray[int] np_v_indices = np.zeros(v, dtype=np.int32)
+ *         for i in range(v):
+ *             np_v_indices[i] = v_indices[i]             # <<<<<<<<<<<<<<
+ * 
+ *         return np_v_indices
+ */
+    __pyx_t_10 = __pyx_v_i;
+    __pyx_t_11 = -1;
+    if (unlikely(__pyx_t_10 >= (size_t)__pyx_pybuffernd_np_v_indices.diminfo[0].shape)) __pyx_t_11 = 0;
+    if (unlikely(__pyx_t_11 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_11);
+      __PYX_ERR(2, 129, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(int *, __pyx_pybuffernd_np_v_indices.rcbuffer->pybuffer.buf, __pyx_t_10, __pyx_pybuffernd_np_v_indices.diminfo[0].strides) = (__pyx_v_v_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":131
+ *             np_v_indices[i] = v_indices[i]
+ * 
+ *         return np_v_indices             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_v_indices));
+  __pyx_r = ((PyObject *)__pyx_v_np_v_indices);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":105
+ *     # Voxel Search
+ *     ###
+ *     def VoxelSearch (self, PointCloud pc):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given voxel.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_v_indices.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.VoxelSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_v_indices.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF(__pyx_v_result);
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_v_indices);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":134
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _VoxelSearch(self, cpp.PointXYZ point, vector[int] &v_indices) except +:             # <<<<<<<<<<<<<<
+ *         cdef vector[int] voxel_indices
+ *         # k = 10
+ */
+
+static void __pyx_f_3pcl_4_pcl_22OctreePointCloudSearch__VoxelSearch(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, struct pcl::PointXYZ __pyx_v_point, std::vector<int>  &__pyx_v_v_indices) {
+  std::vector<int>  __pyx_v_voxel_indices;
+  size_t __pyx_v_k;
+  size_t __pyx_v_i;
+  __Pyx_RefNannyDeclarations
+  size_t __pyx_t_1;
+  size_t __pyx_t_2;
+  __Pyx_RefNannySetupContext("_VoxelSearch", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":138
+ *         # k = 10
+ *         # voxel_indices.resize(k)
+ *         (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(point, voxel_indices)             # <<<<<<<<<<<<<<
+ * 
+ *         # print('_VoxelSearch k = ' + str(k))
+ */
+  ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_t *)__pyx_v_self->__pyx_base.me)->voxelSearch(__pyx_v_point, __pyx_v_voxel_indices);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":142
+ *         # print('_VoxelSearch k = ' + str(k))
+ *         # print('_VoxelSearch voxel_indices = ' + str(voxel_indices.size()))
+ *         k = voxel_indices.size()             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(k):
+ */
+  __pyx_v_k = __pyx_v_voxel_indices.size();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":144
+ *         k = voxel_indices.size()
+ * 
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             v_indices.push_back(voxel_indices[i])
+ * 
+ */
+  __pyx_t_1 = __pyx_v_k;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":145
+ * 
+ *         for i in range(k):
+ *             v_indices.push_back(voxel_indices[i])             # <<<<<<<<<<<<<<
+ * 
+ *     ###
+ */
+    try {
+      __pyx_v_v_indices.push_back((__pyx_v_voxel_indices[__pyx_v_i]));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 145, __pyx_L1_error)
+    }
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":134
+ * 
+ *     @cython.boundscheck(False)
+ *     cdef void _VoxelSearch(self, cpp.PointXYZ point, vector[int] &v_indices) except +:             # <<<<<<<<<<<<<<
+ *         cdef vector[int] voxel_indices
+ *         # k = 10
+ */
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch._VoxelSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":185
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_13define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_12define_bounding_box[] = "OctreePointCloudSearch.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_13define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_12define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_12define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":189
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":185
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":197
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_15add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_14add_points_from_input_cloud[] = "OctreePointCloudSearch.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_15add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_14add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_14add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":201
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":197
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":203
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_17is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_16is_voxel_occupied_at_point[] = "OctreePointCloudSearch.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_17is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_16is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_16is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":207
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 207, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 207, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 207, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 207, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":203
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":209
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_19get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_18get_occupied_voxel_centers[] = "OctreePointCloudSearch.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_19get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_18get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_18get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":214
+ *         """
+ *         cdef eig.AlignedPointTVector_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":215
+ *         cdef eig.AlignedPointTVector_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 215, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(2, 215, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":209
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":217
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_21delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_20delete_voxel_at_point[] = "OctreePointCloudSearch.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_21delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_20delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22OctreePointCloudSearch_20delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":221
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":217
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":230
+ *     cdef pcloct.OctreePointCloudSearch_PointXYZI_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 230, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 230, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 230, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":234
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":235
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":236
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":237
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZI_t*> new pcloct.OctreePointCloudSearch_PointXYZI_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 237, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 237, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":236
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":239
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZI_t*> new pcloct.OctreePointCloudSearch_PointXYZI_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud_PointXYZI_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZI_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZI_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":240
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZI_t*> new pcloct.OctreePointCloudSearch_PointXYZI_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud_PointXYZI_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZI_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":230
+ *     cdef pcloct.OctreePointCloudSearch_PointXYZI_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":242
+ *         self.me = <pcloct.OctreePointCloud_PointXYZI_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":243
+ * 
+ *     def __dealloc__(self):
+ *         del self.me2             # <<<<<<<<<<<<<<
+ *         self.me2 = NULL
+ *         self.me = NULL
+ */
+  delete __pyx_v_self->me2;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":244
+ *     def __dealloc__(self):
+ *         del self.me2
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ * 
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":245
+ *         del self.me2
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":242
+ *         self.me = <pcloct.OctreePointCloud_PointXYZI_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":247
+ *         self.me = NULL
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_5radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_4radius_search[] = "OctreePointCloudSearch_PointXYZI.radius_search(self, point, double radius, unsigned int max_nn=0)\n\n        Search for all neighbors of query point that are within a given radius.\n\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_5radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_point = 0;
+  double __pyx_v_radius;
+  unsigned int __pyx_v_max_nn;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("radius_search (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_point,&__pyx_n_s_radius,&__pyx_n_s_max_nn,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_point)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, 1); __PYX_ERR(2, 247, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_nn);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "radius_search") < 0)) __PYX_ERR(2, 247, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_point = values[0];
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 247, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_max_nn = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_max_nn == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 247, __pyx_L3_error)
+    } else {
+      __pyx_v_max_nn = ((unsigned int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 247, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZI.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_4radius_search(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self), __pyx_v_point, __pyx_v_radius, __pyx_v_max_nn);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_4radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_k;
+  PyArrayObject *__pyx_v_np_k_sqr_distances = 0;
+  PyArrayObject *__pyx_v_np_k_indices = 0;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_indices;
+  __Pyx_Buffer __pyx_pybuffer_np_k_indices;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_sqr_distances;
+  __Pyx_Buffer __pyx_pybuffer_np_k_sqr_distances;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  int __pyx_t_12;
+  Py_ssize_t __pyx_t_13;
+  __Pyx_RefNannySetupContext("radius_search", 0);
+  __pyx_pybuffer_np_k_sqr_distances.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_sqr_distances.refcount = 0;
+  __pyx_pybuffernd_np_k_sqr_distances.data = NULL;
+  __pyx_pybuffernd_np_k_sqr_distances.rcbuffer = &__pyx_pybuffer_np_k_sqr_distances;
+  __pyx_pybuffer_np_k_indices.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_indices.refcount = 0;
+  __pyx_pybuffernd_np_k_indices.data = NULL;
+  __pyx_pybuffernd_np_k_indices.rcbuffer = &__pyx_pybuffer_np_k_indices;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":255
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  __pyx_t_1 = ((__pyx_v_max_nn > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":256
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)             # <<<<<<<<<<<<<<
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ */
+    try {
+      __pyx_v_k_indices.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 256, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":257
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)             # <<<<<<<<<<<<<<
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ */
+    try {
+      __pyx_v_k_sqr_distances.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 257, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":255
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":258
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ */
+  __pyx_v_k = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZI_t *)__pyx_v_self->__pyx_base.me)->radiusSearch(__pyx_f_3pcl_4_pcl_to_point2_t(__pyx_v_point), __pyx_v_radius, __pyx_v_k_indices, __pyx_v_k_sqr_distances, __pyx_v_max_nn);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":259
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 259, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_sqr_distances = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 259, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_np_k_sqr_distances = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":260
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 260, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_indices = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 260, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_indices.diminfo[0].strides = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_indices.diminfo[0].shape = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_np_k_indices = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":261
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ */
+  __pyx_t_9 = __pyx_v_k;
+  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+    __pyx_v_i = __pyx_t_10;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":262
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances
+ */
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_11 < 0) {
+      __pyx_t_11 += __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape;
+      if (unlikely(__pyx_t_11 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 262, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":263
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ *         return np_k_indices, np_k_sqr_distances
+ * 
+ */
+    __pyx_t_13 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_13 < 0) {
+      __pyx_t_13 += __pyx_pybuffernd_np_k_indices.diminfo[0].shape;
+      if (unlikely(__pyx_t_13 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_np_k_indices.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 263, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(int *, __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_np_k_indices.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":264
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances             # <<<<<<<<<<<<<<
+ * 
+ *     # base OctreePointCloud
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 264, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_indices));
+  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_np_k_sqr_distances));
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":247
+ *         self.me = NULL
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZI.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_sqr_distances);
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_indices);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":267
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_6define_bounding_box[] = "OctreePointCloudSearch_PointXYZI.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_6define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":271
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":267
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":279
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_8add_points_from_input_cloud[] = "OctreePointCloudSearch_PointXYZI.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_8add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":283
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":279
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":285
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_10is_voxel_occupied_at_point[] = "OctreePointCloudSearch_PointXYZI.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_10is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":289
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 289, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 289, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 289, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":285
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZI.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":291
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_12get_occupied_voxel_centers[] = "OctreePointCloudSearch_PointXYZI.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_12get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZI_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":296
+ *         """
+ *         cdef eig.AlignedPointTVector_PointXYZI_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":297
+ *         cdef eig.AlignedPointTVector_PointXYZI_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 297, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 297, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 297, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 297, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 297, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(2, 297, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":291
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZI.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":299
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_14delete_voxel_at_point[] = "OctreePointCloudSearch_PointXYZI.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_14delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":303
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point2_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * cdef class OctreePointCloudSearch_PointXYZRGB(OctreePointCloud_PointXYZRGB):
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point2_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":299
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":311
+ *     cdef pcloct.OctreePointCloudSearch_PointXYZRGB_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 311, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 311, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 311, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":315
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":316
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":317
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":318
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGB_t*> new pcloct.OctreePointCloudSearch_PointXYZRGB_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 318, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 318, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 318, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 318, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 318, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":317
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":320
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGB_t*> new pcloct.OctreePointCloudSearch_PointXYZRGB_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGB_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGB_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGB_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":321
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGB_t*> new pcloct.OctreePointCloudSearch_PointXYZRGB_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGB_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZRGB_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":311
+ *     cdef pcloct.OctreePointCloudSearch_PointXYZRGB_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":323
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGB_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":324
+ * 
+ *     def __dealloc__(self):
+ *         del self.me2             # <<<<<<<<<<<<<<
+ *         self.me2 = NULL
+ *         self.me = NULL
+ */
+  delete __pyx_v_self->me2;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":325
+ *     def __dealloc__(self):
+ *         del self.me2
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ * 
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":326
+ *         del self.me2
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":323
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGB_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":328
+ *         self.me = NULL
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_5radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_4radius_search[] = "OctreePointCloudSearch_PointXYZRGB.radius_search(self, point, double radius, unsigned int max_nn=0)\n\n        Search for all neighbors of query point that are within a given radius.\n\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_5radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_point = 0;
+  double __pyx_v_radius;
+  unsigned int __pyx_v_max_nn;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("radius_search (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_point,&__pyx_n_s_radius,&__pyx_n_s_max_nn,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_point)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, 1); __PYX_ERR(2, 328, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_nn);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "radius_search") < 0)) __PYX_ERR(2, 328, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_point = values[0];
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 328, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_max_nn = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_max_nn == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 328, __pyx_L3_error)
+    } else {
+      __pyx_v_max_nn = ((unsigned int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 328, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGB.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_4radius_search(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self), __pyx_v_point, __pyx_v_radius, __pyx_v_max_nn);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_4radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_k;
+  PyArrayObject *__pyx_v_np_k_sqr_distances = 0;
+  PyArrayObject *__pyx_v_np_k_indices = 0;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_indices;
+  __Pyx_Buffer __pyx_pybuffer_np_k_indices;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_sqr_distances;
+  __Pyx_Buffer __pyx_pybuffer_np_k_sqr_distances;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  int __pyx_t_12;
+  Py_ssize_t __pyx_t_13;
+  __Pyx_RefNannySetupContext("radius_search", 0);
+  __pyx_pybuffer_np_k_sqr_distances.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_sqr_distances.refcount = 0;
+  __pyx_pybuffernd_np_k_sqr_distances.data = NULL;
+  __pyx_pybuffernd_np_k_sqr_distances.rcbuffer = &__pyx_pybuffer_np_k_sqr_distances;
+  __pyx_pybuffer_np_k_indices.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_indices.refcount = 0;
+  __pyx_pybuffernd_np_k_indices.data = NULL;
+  __pyx_pybuffernd_np_k_indices.rcbuffer = &__pyx_pybuffer_np_k_indices;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":336
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  __pyx_t_1 = ((__pyx_v_max_nn > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":337
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)             # <<<<<<<<<<<<<<
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ */
+    try {
+      __pyx_v_k_indices.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 337, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":338
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)             # <<<<<<<<<<<<<<
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ */
+    try {
+      __pyx_v_k_sqr_distances.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 338, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":336
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":339
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ */
+  __pyx_v_k = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGB_t *)__pyx_v_self->__pyx_base.me)->radiusSearch(__pyx_f_3pcl_4_pcl_to_point3_t(__pyx_v_point), __pyx_v_radius, __pyx_v_k_indices, __pyx_v_k_sqr_distances, __pyx_v_max_nn);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":340
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 340, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 340, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_sqr_distances = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 340, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_np_k_sqr_distances = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":341
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 341, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 341, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_indices = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 341, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_indices.diminfo[0].strides = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_indices.diminfo[0].shape = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_np_k_indices = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":342
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ */
+  __pyx_t_9 = __pyx_v_k;
+  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+    __pyx_v_i = __pyx_t_10;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":343
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances
+ */
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_11 < 0) {
+      __pyx_t_11 += __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape;
+      if (unlikely(__pyx_t_11 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 343, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":344
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ *         return np_k_indices, np_k_sqr_distances
+ * 
+ */
+    __pyx_t_13 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_13 < 0) {
+      __pyx_t_13 += __pyx_pybuffernd_np_k_indices.diminfo[0].shape;
+      if (unlikely(__pyx_t_13 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_np_k_indices.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 344, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(int *, __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_np_k_indices.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":345
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances             # <<<<<<<<<<<<<<
+ * 
+ *     # base OctreePointCloud
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 345, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_indices));
+  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_np_k_sqr_distances));
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":328
+ *         self.me = NULL
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGB.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_sqr_distances);
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_indices);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":348
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_6define_bounding_box[] = "OctreePointCloudSearch_PointXYZRGB.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_6define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":352
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":348
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":360
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_8add_points_from_input_cloud[] = "OctreePointCloudSearch_PointXYZRGB.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_8add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":364
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":360
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":366
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_10is_voxel_occupied_at_point[] = "OctreePointCloudSearch_PointXYZRGB.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_10is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":370
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 370, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 370, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 370, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":366
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGB.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":372
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_12get_occupied_voxel_centers[] = "OctreePointCloudSearch_PointXYZRGB.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_12get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZRGB_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":377
+ *         """
+ *         cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":378
+ *         cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 378, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 378, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 378, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 378, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(2, 378, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":372
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGB.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":380
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_14delete_voxel_at_point[] = "OctreePointCloudSearch_PointXYZRGB.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_14delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":384
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point3_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point3_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":380
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":393
+ *     cdef pcloct.OctreePointCloudSearch_PointXYZRGBA_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(2, 393, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 393, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 393, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":397
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":398
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":399
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":400
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGBA_t*> new pcloct.OctreePointCloudSearch_PointXYZRGBA_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 400, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 400, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 400, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 400, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(2, 400, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":399
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":402
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGBA_t*> new pcloct.OctreePointCloudSearch_PointXYZRGBA_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGBA_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGBA_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGBA_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":403
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGBA_t*> new pcloct.OctreePointCloudSearch_PointXYZRGBA_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGBA_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud_PointXYZRGBA_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":393
+ *     cdef pcloct.OctreePointCloudSearch_PointXYZRGBA_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":405
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGBA_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":406
+ * 
+ *     def __dealloc__(self):
+ *         del self.me2             # <<<<<<<<<<<<<<
+ *         self.me2 = NULL
+ *         self.me = NULL
+ */
+  delete __pyx_v_self->me2;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":407
+ *     def __dealloc__(self):
+ *         del self.me2
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ * 
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":408
+ *         del self.me2
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":405
+ *         self.me = <pcloct.OctreePointCloud_PointXYZRGBA_t*> self.me2
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me2
+ *         self.me2 = NULL
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":410
+ *         self.me = NULL
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_5radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_4radius_search[] = "OctreePointCloudSearch_PointXYZRGBA.radius_search(self, point, double radius, unsigned int max_nn=0)\n\n        Search for all neighbors of query point that are within a given radius.\n\n        Returns: (k_indices, k_sqr_distances)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_5radius_search(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_point = 0;
+  double __pyx_v_radius;
+  unsigned int __pyx_v_max_nn;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("radius_search (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_point,&__pyx_n_s_radius,&__pyx_n_s_max_nn,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_point)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_radius)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, 1); __PYX_ERR(2, 410, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_nn);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "radius_search") < 0)) __PYX_ERR(2, 410, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_point = values[0];
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 410, __pyx_L3_error)
+    if (values[2]) {
+      __pyx_v_max_nn = __Pyx_PyInt_As_unsigned_int(values[2]); if (unlikely((__pyx_v_max_nn == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(2, 410, __pyx_L3_error)
+    } else {
+      __pyx_v_max_nn = ((unsigned int)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("radius_search", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 410, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGBA.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_4radius_search(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self), __pyx_v_point, __pyx_v_radius, __pyx_v_max_nn);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_4radius_search(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point, double __pyx_v_radius, unsigned int __pyx_v_max_nn) {
+  std::vector<int>  __pyx_v_k_indices;
+  std::vector<float>  __pyx_v_k_sqr_distances;
+  int __pyx_v_k;
+  PyArrayObject *__pyx_v_np_k_sqr_distances = 0;
+  PyArrayObject *__pyx_v_np_k_indices = 0;
+  int __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_indices;
+  __Pyx_Buffer __pyx_pybuffer_np_k_indices;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_np_k_sqr_distances;
+  __Pyx_Buffer __pyx_pybuffer_np_k_sqr_distances;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyArrayObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  int __pyx_t_9;
+  int __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  int __pyx_t_12;
+  Py_ssize_t __pyx_t_13;
+  __Pyx_RefNannySetupContext("radius_search", 0);
+  __pyx_pybuffer_np_k_sqr_distances.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_sqr_distances.refcount = 0;
+  __pyx_pybuffernd_np_k_sqr_distances.data = NULL;
+  __pyx_pybuffernd_np_k_sqr_distances.rcbuffer = &__pyx_pybuffer_np_k_sqr_distances;
+  __pyx_pybuffer_np_k_indices.pybuffer.buf = NULL;
+  __pyx_pybuffer_np_k_indices.refcount = 0;
+  __pyx_pybuffernd_np_k_indices.data = NULL;
+  __pyx_pybuffernd_np_k_indices.rcbuffer = &__pyx_pybuffer_np_k_indices;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":418
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  __pyx_t_1 = ((__pyx_v_max_nn > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":419
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)             # <<<<<<<<<<<<<<
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ */
+    try {
+      __pyx_v_k_indices.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 419, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":420
+ *         if max_nn > 0:
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)             # <<<<<<<<<<<<<<
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ */
+    try {
+      __pyx_v_k_sqr_distances.resize(__pyx_v_max_nn);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(2, 420, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":418
+ *         cdef vector[int] k_indices
+ *         cdef vector[float] k_sqr_distances
+ *         if max_nn > 0:             # <<<<<<<<<<<<<<
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":421
+ *             k_indices.resize(max_nn)
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ */
+  __pyx_v_k = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudSearch_PointXYZRGBA_t *)__pyx_v_self->__pyx_base.me)->radiusSearch(__pyx_f_3pcl_4_pcl_to_point4_t(__pyx_v_point), __pyx_v_radius, __pyx_v_k_indices, __pyx_v_k_sqr_distances, __pyx_v_max_nn);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":422
+ *             k_sqr_distances.resize(max_nn)
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 422, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 422, __pyx_L1_error)
+  __pyx_t_7 = ((PyArrayObject *)__pyx_t_6);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_sqr_distances = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 422, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape = __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_7 = 0;
+  __pyx_v_np_k_sqr_distances = ((PyArrayObject *)__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":423
+ *         cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)             # <<<<<<<<<<<<<<
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_k); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_int32); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 423, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(2, 423, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_int, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+      __pyx_v_np_k_indices = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf = NULL;
+      __PYX_ERR(2, 423, __pyx_L1_error)
+    } else {__pyx_pybuffernd_np_k_indices.diminfo[0].strides = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_np_k_indices.diminfo[0].shape = __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.shape[0];
+    }
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_np_k_indices = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":424
+ *         cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):             # <<<<<<<<<<<<<<
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ */
+  __pyx_t_9 = __pyx_v_k;
+  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
+    __pyx_v_i = __pyx_t_10;
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":425
+ *         cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]             # <<<<<<<<<<<<<<
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances
+ */
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_11 < 0) {
+      __pyx_t_11 += __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape;
+      if (unlikely(__pyx_t_11 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 425, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_np_k_sqr_distances.diminfo[0].strides) = (__pyx_v_k_sqr_distances[__pyx_v_i]);
+
+    /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":426
+ *         for i in range(k):
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]             # <<<<<<<<<<<<<<
+ *         return np_k_indices, np_k_sqr_distances
+ * 
+ */
+    __pyx_t_13 = __pyx_v_i;
+    __pyx_t_12 = -1;
+    if (__pyx_t_13 < 0) {
+      __pyx_t_13 += __pyx_pybuffernd_np_k_indices.diminfo[0].shape;
+      if (unlikely(__pyx_t_13 < 0)) __pyx_t_12 = 0;
+    } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_np_k_indices.diminfo[0].shape)) __pyx_t_12 = 0;
+    if (unlikely(__pyx_t_12 != -1)) {
+      __Pyx_RaiseBufferIndexError(__pyx_t_12);
+      __PYX_ERR(2, 426, __pyx_L1_error)
+    }
+    *__Pyx_BufPtrStrided1d(int *, __pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_np_k_indices.diminfo[0].strides) = (__pyx_v_k_indices[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":427
+ *             np_k_sqr_distances[i] = k_sqr_distances[i]
+ *             np_k_indices[i] = k_indices[i]
+ *         return np_k_indices, np_k_sqr_distances             # <<<<<<<<<<<<<<
+ * 
+ *     # base OctreePointCloud
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 427, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_indices));
+  PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_v_np_k_indices));
+  __Pyx_INCREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_np_k_sqr_distances));
+  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_np_k_sqr_distances));
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":410
+ *         self.me = NULL
+ * 
+ *     def radius_search (self, point, double radius, unsigned int max_nn = 0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Search for all neighbors of query point that are within a given radius.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGBA.radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_indices.rcbuffer->pybuffer);
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_np_k_sqr_distances.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_sqr_distances);
+  __Pyx_XDECREF((PyObject *)__pyx_v_np_k_indices);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":430
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_6define_bounding_box[] = "OctreePointCloudSearch_PointXYZRGBA.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_6define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":434
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":430
+ * 
+ *     # base OctreePointCloud
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":442
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_8add_points_from_input_cloud[] = "OctreePointCloudSearch_PointXYZRGBA.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_8add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":446
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":442
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":448
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_10is_voxel_occupied_at_point[] = "OctreePointCloudSearch_PointXYZRGBA.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_10is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":452
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 452, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 452, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 452, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 452, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 452, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(2, 452, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 452, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":448
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGBA.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":454
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_12get_occupied_voxel_centers[] = "OctreePointCloudSearch_PointXYZRGBA.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_12get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZRGBA_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":459
+ *         """
+ *         cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":460
+ *         cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 460, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 460, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 460, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 460, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 460, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(2, 460, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":454
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudSearch_PointXYZRGBA.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":462
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_14delete_voxel_at_point[] = "OctreePointCloudSearch_PointXYZRGBA.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_14delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":466
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point4_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point4_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":462
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":13
+ *     cdef pcloct.OctreePointCloudChangeDetector_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(15, 13, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 13, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 13, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":17
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":18
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":19
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":20
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_t*> new pcloct.OctreePointCloudChangeDetector_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 20, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(15, 20, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":19
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":22
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_t*> new pcloct.OctreePointCloudChangeDetector_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud2Buf_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":23
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_t*> new pcloct.OctreePointCloudChangeDetector_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud2Buf_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":13
+ *     cdef pcloct.OctreePointCloudChangeDetector_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":25
+ *         self.me = <pcloct.OctreePointCloud2Buf_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_2get_PointIndicesFromNewVoxels[] = "OctreePointCloudChangeDetector.get_PointIndicesFromNewVoxels(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_2get_PointIndicesFromNewVoxels(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self) {
+  std::vector<int>  __pyx_v_newPointIdxVector;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":27
+ *     def get_PointIndicesFromNewVoxels (self):
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)             # <<<<<<<<<<<<<<
+ *         return newPointIdxVector
+ * 
+ */
+  __pyx_v_self->me2->getPointIndicesFromNewVoxels(__pyx_v_newPointIdxVector, 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":28
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ *         return newPointIdxVector             # <<<<<<<<<<<<<<
+ * 
+ *     # use Octree2BufBase class function
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_convert_vector_to_py_int(__pyx_v_newPointIdxVector); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":25
+ *         self.me = <pcloct.OctreePointCloud2Buf_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector.get_PointIndicesFromNewVoxels", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":31
+ * 
+ *     # use Octree2BufBase class function
+ *     def switchBuffers (self):             # <<<<<<<<<<<<<<
+ *         cdef pcloct.Octree2BufBase_t* buf
+ *         buf = <pcloct.Octree2BufBase_t*>self.me2
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_5switchBuffers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_4switchBuffers[] = "OctreePointCloudChangeDetector.switchBuffers(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_5switchBuffers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("switchBuffers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_4switchBuffers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_4switchBuffers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self) {
+  __pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_t *__pyx_v_buf;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("switchBuffers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":33
+ *     def switchBuffers (self):
+ *         cdef pcloct.Octree2BufBase_t* buf
+ *         buf = <pcloct.Octree2BufBase_t*>self.me2             # <<<<<<<<<<<<<<
+ *         buf.switchBuffers()
+ * 
+ */
+  __pyx_v_buf = ((__pyx_t_3pcl_14pcl_octree_180_Octree2BufBase_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":34
+ *         cdef pcloct.Octree2BufBase_t* buf
+ *         buf = <pcloct.Octree2BufBase_t*>self.me2
+ *         buf.switchBuffers()             # <<<<<<<<<<<<<<
+ * 
+ *     # base OctreePointCloud2Buf
+ */
+  __pyx_v_buf->switchBuffers();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":31
+ * 
+ *     # use Octree2BufBase class function
+ *     def switchBuffers (self):             # <<<<<<<<<<<<<<
+ *         cdef pcloct.Octree2BufBase_t* buf
+ *         buf = <pcloct.Octree2BufBase_t*>self.me2
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":37
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_6define_bounding_box[] = "OctreePointCloudChangeDetector.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_7define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_6define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_6define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":41
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":37
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":49
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_8add_points_from_input_cloud[] = "OctreePointCloudChangeDetector.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_9add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_8add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_8add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":53
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":49
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":55
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_10is_voxel_occupied_at_point[] = "OctreePointCloudChangeDetector.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_11is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_10is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_10is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":59
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":55
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":61
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_12get_occupied_voxel_centers[] = "OctreePointCloudChangeDetector.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_13get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_12get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_12get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":66
+ *         """
+ *         cdef eig.AlignedPointTVector_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":67
+ *         cdef eig.AlignedPointTVector_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 67, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(15, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(15, 67, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":61
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":69
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_14delete_voxel_at_point[] = "OctreePointCloudChangeDetector.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_15delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_14delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30OctreePointCloudChangeDetector_14delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":73
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":69
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":84
+ *     cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(15, 84, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 84, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 84, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":88
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":89
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":90
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":91
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZI_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZI_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 91, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 91, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 91, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 91, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(15, 91, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":90
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":93
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZI_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZI_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZI_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZI_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZI_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":94
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZI_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZI_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZI_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZI_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":84
+ *     cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":96
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZI_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_2get_PointIndicesFromNewVoxels[] = "OctreePointCloudChangeDetector_PointXYZI.get_PointIndicesFromNewVoxels(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_2get_PointIndicesFromNewVoxels(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self) {
+  std::vector<int>  __pyx_v_newPointIdxVector;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":98
+ *     def get_PointIndicesFromNewVoxels (self):
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)             # <<<<<<<<<<<<<<
+ *         return newPointIdxVector
+ * 
+ */
+  __pyx_v_self->me2->getPointIndicesFromNewVoxels(__pyx_v_newPointIdxVector, 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":99
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ *         return newPointIdxVector             # <<<<<<<<<<<<<<
+ * 
+ *     # use Octree2BufBase class function
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_convert_vector_to_py_int(__pyx_v_newPointIdxVector); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 99, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":96
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZI_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZI.get_PointIndicesFromNewVoxels", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":106
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_5define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_4define_bounding_box[] = "OctreePointCloudChangeDetector_PointXYZI.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_5define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_4define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_4define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":110
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":106
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":118
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_7add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_6add_points_from_input_cloud[] = "OctreePointCloudChangeDetector_PointXYZI.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_7add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_6add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_6add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":122
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":118
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":124
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_9is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_8is_voxel_occupied_at_point[] = "OctreePointCloudChangeDetector_PointXYZI.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_9is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_8is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_8is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":128
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 128, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 128, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 128, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 128, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":124
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZI.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":130
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_11get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_10get_occupied_voxel_centers[] = "OctreePointCloudChangeDetector_PointXYZI.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_11get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_10get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_10get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZI_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":135
+ *         """
+ *         cdef eig.AlignedPointTVector_PointXYZI_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":136
+ *         cdef eig.AlignedPointTVector_PointXYZI_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 136, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 136, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 136, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(15, 136, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(15, 136, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":130
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZI.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":138
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_13delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_12delete_voxel_at_point[] = "OctreePointCloudChangeDetector_PointXYZI.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_13delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_12delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_12delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":142
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point2_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point2_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":138
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":153
+ *     cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(15, 153, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 153, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 153, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":157
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":158
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":159
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":160
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 160, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(15, 160, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":159
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":162
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGB_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGB_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGB_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":163
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGB_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZRGB_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":153
+ *     cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":165
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGB_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_2get_PointIndicesFromNewVoxels[] = "OctreePointCloudChangeDetector_PointXYZRGB.get_PointIndicesFromNewVoxels(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_2get_PointIndicesFromNewVoxels(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self) {
+  std::vector<int>  __pyx_v_newPointIdxVector;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":167
+ *     def get_PointIndicesFromNewVoxels (self):
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)             # <<<<<<<<<<<<<<
+ *         return newPointIdxVector
+ * 
+ */
+  __pyx_v_self->me2->getPointIndicesFromNewVoxels(__pyx_v_newPointIdxVector, 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":168
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ *         return newPointIdxVector             # <<<<<<<<<<<<<<
+ * 
+ *     # use Octree2BufBase class function
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_convert_vector_to_py_int(__pyx_v_newPointIdxVector); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 168, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":165
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGB_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGB.get_PointIndicesFromNewVoxels", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":175
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_5define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_4define_bounding_box[] = "OctreePointCloudChangeDetector_PointXYZRGB.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_5define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_4define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_4define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":179
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":175
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":187
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_7add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_6add_points_from_input_cloud[] = "OctreePointCloudChangeDetector_PointXYZRGB.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_7add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_6add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_6add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":191
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":187
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":193
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_9is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_8is_voxel_occupied_at_point[] = "OctreePointCloudChangeDetector_PointXYZRGB.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_9is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_8is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_8is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":197
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 197, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 197, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 197, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":193
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGB.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":199
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_11get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_10get_occupied_voxel_centers[] = "OctreePointCloudChangeDetector_PointXYZRGB.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_11get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_10get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_10get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZRGB_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":204
+ *         """
+ *         cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":205
+ *         cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 205, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 205, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 205, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 205, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(15, 205, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(15, 205, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":199
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGB.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":207
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_13delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_12delete_voxel_at_point[] = "OctreePointCloudChangeDetector_PointXYZRGB.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_13delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_12delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_12delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":211
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point3_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point3_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":207
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":222
+ *     cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  double __pyx_v_resolution;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_resolution,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_resolution)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(15, 222, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(values[0]); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 222, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(15, 222, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *)__pyx_v_self), __pyx_v_resolution);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self, double __pyx_v_resolution) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":226
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ *         """
+ *         self.me2 = NULL             # <<<<<<<<<<<<<<
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ */
+  __pyx_v_self->me2 = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":227
+ *         """
+ *         self.me2 = NULL
+ *         self.me = NULL             # <<<<<<<<<<<<<<
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ */
+  __pyx_v_self->__pyx_base.me = NULL;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":228
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  __pyx_t_1 = ((__pyx_v_resolution <= 0.) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":229
+ *         self.me = NULL
+ *         if resolution <= 0.:
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)             # <<<<<<<<<<<<<<
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t(resolution)
+ */
+    __pyx_t_2 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 229, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Expected_resolution_0_got_r, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 229, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(15, 229, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(15, 229, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(15, 229, __pyx_L1_error)
+
+    /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":228
+ *         self.me2 = NULL
+ *         self.me = NULL
+ *         if resolution <= 0.:             # <<<<<<<<<<<<<<
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":231
+ *             raise ValueError("Expected resolution > 0., got %r" % resolution)
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t(resolution)             # <<<<<<<<<<<<<<
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGBA_t*> self.me2
+ * 
+ */
+  __pyx_v_self->me2 = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGBA_t *)new __pyx_t_3pcl_14pcl_octree_180_OctreePointCloudChangeDetector_PointXYZRGBA_t(__pyx_v_resolution));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":232
+ * 
+ *         self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t(resolution)
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGBA_t*> self.me2             # <<<<<<<<<<<<<<
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):
+ */
+  __pyx_v_self->__pyx_base.me = ((__pyx_t_3pcl_14pcl_octree_180_OctreePointCloud2Buf_PointXYZRGBA_t *)__pyx_v_self->me2);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":222
+ *     cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me2
+ * 
+ *     def __cinit__(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Constructs octree pointcloud with given resolution at lowest octree level
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":234
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGBA_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_2get_PointIndicesFromNewVoxels[] = "OctreePointCloudChangeDetector_PointXYZRGBA.get_PointIndicesFromNewVoxels(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_3get_PointIndicesFromNewVoxels(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_2get_PointIndicesFromNewVoxels(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_2get_PointIndicesFromNewVoxels(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self) {
+  std::vector<int>  __pyx_v_newPointIdxVector;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_PointIndicesFromNewVoxels", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":236
+ *     def get_PointIndicesFromNewVoxels (self):
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)             # <<<<<<<<<<<<<<
+ *         return newPointIdxVector
+ * 
+ */
+  __pyx_v_self->me2->getPointIndicesFromNewVoxels(__pyx_v_newPointIdxVector, 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":237
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ *         return newPointIdxVector             # <<<<<<<<<<<<<<
+ * 
+ *     # use Octree2BufBase class function
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_convert_vector_to_py_int(__pyx_v_newPointIdxVector); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 237, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":234
+ *         self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGBA_t*> self.me2
+ * 
+ *     def get_PointIndicesFromNewVoxels (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] newPointIdxVector
+ *         self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGBA.get_PointIndicesFromNewVoxels", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":244
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_5define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_4define_bounding_box[] = "OctreePointCloudChangeDetector_PointXYZRGBA.define_bounding_box(self)\n\n        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. \n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_5define_bounding_box(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_4define_bounding_box(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_4define_bounding_box(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("define_bounding_box", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":248
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ *         """
+ *         self.me2.defineBoundingBox()             # <<<<<<<<<<<<<<
+ * 
+ *     # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+ */
+  __pyx_v_self->me2->defineBoundingBox();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":244
+ * 
+ *     # base OctreePointCloud2Buf
+ *     def define_bounding_box(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Investigate dimensions of pointcloud data set and define corresponding bounding box for octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":256
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_7add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_6add_points_from_input_cloud[] = "OctreePointCloudChangeDetector_PointXYZRGBA.add_points_from_input_cloud(self)\n\n        Add points from input point cloud to octree.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_7add_points_from_input_cloud(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_6add_points_from_input_cloud(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_6add_points_from_input_cloud(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_points_from_input_cloud", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":260
+ *         Add points from input point cloud to octree.
+ *         """
+ *         self.me2.addPointsFromInputCloud()             # <<<<<<<<<<<<<<
+ * 
+ *     def is_voxel_occupied_at_point(self, point):
+ */
+  __pyx_v_self->me2->addPointsFromInputCloud();
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":256
+ *     #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+ * 
+ *     def add_points_from_input_cloud(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Add points from input point cloud to octree.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":262
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_9is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_8is_voxel_occupied_at_point[] = "OctreePointCloudChangeDetector_PointXYZRGBA.is_voxel_occupied_at_point(self, point)\n\n        Check if voxel at given point coordinates exist.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_9is_voxel_occupied_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_8is_voxel_occupied_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_8is_voxel_occupied_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  double __pyx_t_2;
+  double __pyx_t_3;
+  double __pyx_t_4;
+  __Pyx_RefNannySetupContext("is_voxel_occupied_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":266
+ *         Check if voxel at given point coordinates exist.
+ *         """
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])             # <<<<<<<<<<<<<<
+ * 
+ *     def get_occupied_voxel_centers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_2 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 266, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_3 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 266, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_point, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_4 = __pyx_PyFloat_AsDouble(__pyx_t_1); if (unlikely((__pyx_t_4 == (double)-1) && PyErr_Occurred())) __PYX_ERR(15, 266, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me2->isVoxelOccupiedAtPoint(__pyx_t_2, __pyx_t_3, __pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":262
+ *         self.me2.addPointsFromInputCloud()
+ * 
+ *     def is_voxel_occupied_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Check if voxel at given point coordinates exist.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGBA.is_voxel_occupied_at_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":268
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_11get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_10get_occupied_voxel_centers[] = "OctreePointCloudChangeDetector_PointXYZRGBA.get_occupied_voxel_centers(self)\n\n        Get list of centers of all occupied voxels.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_11get_occupied_voxel_centers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_10get_occupied_voxel_centers(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_10get_occupied_voxel_centers(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self) {
+  __pyx_t_3pcl_5eigen_AlignedPointTVector_PointXYZRGBA_t __pyx_v_points_v;
+  int __pyx_v_num;
+  int __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("get_occupied_voxel_centers", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":273
+ *         """
+ *         cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)             # <<<<<<<<<<<<<<
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ */
+  __pyx_v_num = __pyx_v_self->me2->getOccupiedVoxelCenters(__pyx_v_points_v);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":274
+ *         cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+ *         cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]             # <<<<<<<<<<<<<<
+ * 
+ *     def delete_voxel_at_point(self, point):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(15, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_num;
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).x); if (unlikely(!__pyx_t_4)) __PYX_ERR(15, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).y); if (unlikely(!__pyx_t_5)) __PYX_ERR(15, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_6 = PyFloat_FromDouble((__pyx_v_points_v[__pyx_v_i]).z); if (unlikely(!__pyx_t_6)) __PYX_ERR(15, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(15, 274, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_6);
+    PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
+    __pyx_t_4 = 0;
+    __pyx_t_5 = 0;
+    __pyx_t_6 = 0;
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_7))) __PYX_ERR(15, 274, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":268
+ *         return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+ * 
+ *     def get_occupied_voxel_centers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Get list of centers of all occupied voxels.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGBA.get_occupied_voxel_centers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":276
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_13delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_12delete_voxel_at_point[] = "OctreePointCloudChangeDetector_PointXYZRGBA.delete_voxel_at_point(self, point)\n\n        Delete leaf node / voxel at given point.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_13delete_voxel_at_point(PyObject *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_12delete_voxel_at_point(((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *)__pyx_v_self), ((PyObject *)__pyx_v_point));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_12delete_voxel_at_point(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_point) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("delete_voxel_at_point", 0);
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":280
+ *         Delete leaf node / voxel at given point.
+ *         """
+ *         self.me2.deleteVoxelAtPoint(to_point4_t(point))             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me2->deleteVoxelAtPoint(__pyx_f_3pcl_4_pcl_to_point4_t(__pyx_v_point));
+
+  /* "pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi":276
+ *         return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+ * 
+ *     def delete_voxel_at_point(self, point):             # <<<<<<<<<<<<<<
+ *         """
+ *         Delete leaf node / voxel at given point.
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Vertices.pxi":11
+ *     # cdef cpp.Vertices *me
+ * 
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         # cdef cpp.Vertices vertices
+ *         self._view_count = 0
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_8Vertices_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_8Vertices_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_init = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_init,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_init);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(16, 11, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_init = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(16, 11, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Vertices.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8Vertices___cinit__(((struct __pyx_obj_3pcl_4_pcl_Vertices *)__pyx_v_self), __pyx_v_init);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_8Vertices___cinit__(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, PyObject *__pyx_v_init) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Vertices.pxi":13
+ *     def __cinit__(self, init=None):
+ *         # cdef cpp.Vertices vertices
+ *         self._view_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         # self.me = new cpp.Vertices()
+ */
+  __pyx_v_self->_view_count = 0;
+
+  /* "pcl/pxi/Vertices.pxi":17
+ *         # self.me = new cpp.Vertices()
+ *         # sp_assign(<cpp.shared_ptr[cpp.Vertices]> self.thisptr_shared, new cpp.Vertices())
+ *         sp_assign(self.thisptr_shared, new cpp.Vertices())             # <<<<<<<<<<<<<<
+ * 
+ *         if init is None:
+ */
+  sp_assign<pcl::Vertices>(__pyx_v_self->thisptr_shared, new pcl::Vertices());
+
+  /* "pcl/pxi/Vertices.pxi":19
+ *         sp_assign(self.thisptr_shared, new cpp.Vertices())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         # elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  __pyx_t_1 = (__pyx_v_init == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/Vertices.pxi":20
+ * 
+ *         if init is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         # elif isinstance(init, (numbers.Integral, np.integer)):
+ *         #      self.resize(init)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "pcl/pxi/Vertices.pxi":19
+ *         sp_assign(self.thisptr_shared, new cpp.Vertices())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         # elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  }
+
+  /* "pcl/pxi/Vertices.pxi":31
+ *         #      self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s" % type(init))             # <<<<<<<<<<<<<<
+ * 
+ *     # property vertices:
+ */
+  /*else*/ {
+    __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, ((PyObject *)Py_TYPE(__pyx_v_init))); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 31, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 31, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+    __pyx_t_3 = 0;
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 31, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(16, 31, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Vertices.pxi":11
+ *     # cdef cpp.Vertices *me
+ * 
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         # cdef cpp.Vertices vertices
+ *         self._view_count = 0
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.Vertices.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Vertices.pxi":37
+ *     #     def __get__(self): return self.thisptr().vertices
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<Vertices of %d points>" % self.vertices.size()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8Vertices_2__repr__(((struct __pyx_obj_3pcl_4_pcl_Vertices *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_2__repr__(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "pcl/pxi/Vertices.pxi":38
+ * 
+ *     def __repr__(self):
+ *         return "<Vertices of %d points>" % self.vertices.size()             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_vertices); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 38, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 38, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Vertices_of_d_points, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Vertices.pxi":37
+ *     #     def __get__(self): return self.thisptr().vertices
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<Vertices of %d points>" % self.vertices.size()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.Vertices.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Vertices.pxi":41
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.int_t, ndim=1] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_5from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8Vertices_4from_array[] = "Vertices.from_array(self, ndarray arr)\n\n        Fill this object from a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_5from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_array (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arr), __pyx_ptype_5numpy_ndarray, 0, "arr", 0))) __PYX_ERR(16, 41, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8Vertices_4from_array(((struct __pyx_obj_3pcl_4_pcl_Vertices *)__pyx_v_self), ((PyArrayObject *)__pyx_v_arr));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_4from_array(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, PyArrayObject *__pyx_v_arr) {
+  npy_intp __pyx_v_npts;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_arr;
+  __Pyx_Buffer __pyx_pybuffer_arr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  npy_intp __pyx_t_1;
+  npy_intp __pyx_t_2;
+  Py_ssize_t __pyx_t_3;
+  __Pyx_RefNannySetupContext("from_array", 0);
+  __pyx_pybuffer_arr.pybuffer.buf = NULL;
+  __pyx_pybuffer_arr.refcount = 0;
+  __pyx_pybuffernd_arr.data = NULL;
+  __pyx_pybuffernd_arr.rcbuffer = &__pyx_pybuffer_arr;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arr.rcbuffer->pybuffer, (PyObject*)__pyx_v_arr, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(16, 41, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_arr.diminfo[0].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arr.diminfo[0].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[0];
+
+  /* "pcl/pxi/Vertices.pxi":45
+ *         Fill this object from a 2D numpy array (float32)
+ *         """
+ *         cdef cnp.npy_intp npts = arr.shape[0]             # <<<<<<<<<<<<<<
+ * 
+ *         # cdef cpp.Vertices *p
+ */
+  __pyx_v_npts = (__pyx_v_arr->dimensions[0]);
+
+  /* "pcl/pxi/Vertices.pxi":48
+ * 
+ *         # cdef cpp.Vertices *p
+ *         for i in range(npts):             # <<<<<<<<<<<<<<
+ *             self.thisptr().vertices.push_back(arr[i])
+ * 
+ */
+  __pyx_t_1 = __pyx_v_npts;
+  for (__pyx_t_2 = 0; __pyx_t_2 < __pyx_t_1; __pyx_t_2+=1) {
+    __pyx_v_i = __pyx_t_2;
+
+    /* "pcl/pxi/Vertices.pxi":49
+ *         # cdef cpp.Vertices *p
+ *         for i in range(npts):
+ *             self.thisptr().vertices.push_back(arr[i])             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+    __pyx_t_3 = __pyx_v_i;
+    if (__pyx_t_3 < 0) __pyx_t_3 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    try {
+      __pyx_f_3pcl_4_pcl_8Vertices_thisptr(__pyx_v_self)->vertices.push_back((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_3, __pyx_pybuffernd_arr.diminfo[0].strides)));
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(16, 49, __pyx_L1_error)
+    }
+  }
+
+  /* "pcl/pxi/Vertices.pxi":41
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.int_t, ndim=1] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.Vertices.from_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Vertices.pxi":52
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_7to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8Vertices_6to_array[] = "Vertices.to_array(self)\n\n        Return this object as a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_7to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_array (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8Vertices_6to_array(((struct __pyx_obj_3pcl_4_pcl_Vertices *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_6to_array(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self) {
+  npy_intp __pyx_v_n;
+  PyArrayObject *__pyx_v_result = 0;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_result;
+  __Pyx_Buffer __pyx_pybuffer_result;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  npy_intp __pyx_t_11;
+  npy_intp __pyx_t_12;
+  __Pyx_FakeReference<size_t> __pyx_t_13;
+  __Pyx_RefNannySetupContext("to_array", 0);
+  __pyx_pybuffer_result.pybuffer.buf = NULL;
+  __pyx_pybuffer_result.refcount = 0;
+  __pyx_pybuffernd_result.data = NULL;
+  __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result;
+
+  /* "pcl/pxi/Vertices.pxi":57
+ *         """
+ *         cdef float index
+ *         cdef cnp.npy_intp n = self.thisptr().vertices.size()             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.int, ndim=1, mode="c"] result
+ *         cdef cpp.Vertices *p
+ */
+  __pyx_v_n = __pyx_f_3pcl_4_pcl_8Vertices_thisptr(__pyx_v_self)->vertices.size();
+
+  /* "pcl/pxi/Vertices.pxi":61
+ *         cdef cpp.Vertices *p
+ * 
+ *         result = np.empty((n, 1), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             result[i, 0] = self.thisptr().vertices.at(i)
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(16, 61, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+    __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_object, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack);
+    if (unlikely(__pyx_t_7 < 0)) {
+      PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_object, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS, 1, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      }
+    }
+    __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0];
+    if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(16, 61, __pyx_L1_error)
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_result = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Vertices.pxi":62
+ * 
+ *         result = np.empty((n, 1), dtype=np.float32)
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             result[i, 0] = self.thisptr().vertices.at(i)
+ * 
+ */
+  __pyx_t_11 = __pyx_v_n;
+  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/Vertices.pxi":63
+ *         result = np.empty((n, 1), dtype=np.float32)
+ *         for i in range(n):
+ *             result[i, 0] = self.thisptr().vertices.at(i)             # <<<<<<<<<<<<<<
+ * 
+ *         return result
+ */
+    try {
+      __pyx_t_13 = __pyx_f_3pcl_4_pcl_8Vertices_thisptr(__pyx_v_self)->vertices.at(__pyx_v_i);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(16, 63, __pyx_L1_error)
+    }
+    __pyx_t_5 = __Pyx_PyInt_FromSize_t(__pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(16, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_GIVEREF(__pyx_int_0);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_0);
+    __pyx_t_3 = 0;
+    if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_result), __pyx_t_1, __pyx_t_5) < 0)) __PYX_ERR(16, 63, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Vertices.pxi":65
+ *             result[i, 0] = self.thisptr().vertices.at(i)
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     def from_list(self, _list):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Vertices.pxi":52
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.Vertices.to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Vertices.pxi":67
+ *         return result
+ * 
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_9from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8Vertices_8from_list[] = "Vertices.from_list(self, _list)\n\n        Fill this pointcloud from a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_9from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8Vertices_8from_list(((struct __pyx_obj_3pcl_4_pcl_Vertices *)__pyx_v_self), ((PyObject *)__pyx_v__list));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_8from_list(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, PyObject *__pyx_v__list) {
+  Py_ssize_t __pyx_v_npts;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("from_list", 0);
+
+  /* "pcl/pxi/Vertices.pxi":71
+ *         Fill this pointcloud from a list of 3-tuples
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         # self.thisptr().width = npts
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v__list); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(16, 71, __pyx_L1_error)
+  __pyx_v_npts = __pyx_t_1;
+
+  /* "pcl/pxi/Vertices.pxi":72
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         # self.thisptr().width = npts
+ *         # self.thisptr().height = 1
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_npts); if (unlikely(!__pyx_t_4)) __PYX_ERR(16, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 72, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 72, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 72, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(16, 72, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 72, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/Vertices.pxi":67
+ *         return result
+ * 
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.Vertices.from_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Vertices.pxi":81
+ *         #      p.x, p.y, p.z = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_11to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8Vertices_10to_list[] = "Vertices.to_list(self)\n\n        Return this object as a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_11to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8Vertices_10to_list(((struct __pyx_obj_3pcl_4_pcl_Vertices *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_10to_list(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("to_list", 0);
+
+  /* "pcl/pxi/Vertices.pxi":85
+ *         Return this object as a list of 3-tuples
+ *         """
+ *         return self.to_array().tolist()             # <<<<<<<<<<<<<<
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 85, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 85, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_3)) __PYX_ERR(16, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 85, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(16, 85, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Vertices.pxi":81
+ *         #      p.x, p.y, p.z = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.Vertices.to_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Vertices.pxi":87
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize Vertices while there are"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_13resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8Vertices_12resize[] = "Vertices.resize(self, npy_intp x)";
+static PyObject *__pyx_pw_3pcl_4_pcl_8Vertices_13resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x) {
+  npy_intp __pyx_v_x;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
+  assert(__pyx_arg_x); {
+    __pyx_v_x = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_x); if (unlikely((__pyx_v_x == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(16, 87, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.Vertices.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8Vertices_12resize(((struct __pyx_obj_3pcl_4_pcl_Vertices *)__pyx_v_self), ((npy_intp)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8Vertices_12resize(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self, npy_intp __pyx_v_x) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("resize", 0);
+
+  /* "pcl/pxi/Vertices.pxi":88
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize Vertices while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Vertices.pxi":89
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize Vertices while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().vertices.resize(x)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(16, 89, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(16, 89, __pyx_L1_error)
+
+    /* "pcl/pxi/Vertices.pxi":88
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize Vertices while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  }
+
+  /* "pcl/pxi/Vertices.pxi":91
+ *             raise ValueError("can't resize Vertices while there are"
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().vertices.resize(x)             # <<<<<<<<<<<<<<
+ * ###
+ */
+  try {
+    __pyx_f_3pcl_4_pcl_8Vertices_thisptr(__pyx_v_self)->vertices.resize(__pyx_v_x);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(16, 91, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Vertices.pxi":87
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize Vertices while there are"
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.Vertices.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropHull_180.pxi":17
+ *     cdef pclfil.CropHull_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.CropHull_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_8CropHull_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_8CropHull_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(17, 17, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 17, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropHull.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(17, 17, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8CropHull___cinit__(((struct __pyx_obj_3pcl_4_pcl_CropHull *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_8CropHull___cinit__(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":18
+ * 
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclfil.CropHull_t()             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_CropHull_t();
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":19
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclfil.CropHull_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":17
+ *     cdef pclfil.CropHull_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.CropHull_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropHull_180.pxi":21
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_8CropHull_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_8CropHull_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_8CropHull_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_CropHull *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_8CropHull_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":22
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":21
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/CropHull_180.pxi":24
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8CropHull_4set_InputCloud[] = "CropHull.set_InputCloud(self, PointCloud pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(17, 24, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8CropHull_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_CropHull *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":25
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     # def SetParameter(self, shared_ptr[cpp.PointCloud[cpp.PointXYZ]] points, cpp.Vertices vt):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":24
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropHull_180.pxi":28
+ * 
+ *     # def SetParameter(self, shared_ptr[cpp.PointCloud[cpp.PointXYZ]] points, cpp.Vertices vt):
+ *     def SetParameter(self, PointCloud points, Vertices vt):             # <<<<<<<<<<<<<<
+ *         cdef const vector[cpp.Vertices] tmp_vertices
+ *         # NG
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_7SetParameter(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8CropHull_6SetParameter[] = "CropHull.SetParameter(self, PointCloud points, Vertices vt)";
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_7SetParameter(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_points = 0;
+  CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_vt = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetParameter (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_points,&__pyx_n_s_vt,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_points)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_vt)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("SetParameter", 1, 2, 2, 1); __PYX_ERR(17, 28, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SetParameter") < 0)) __PYX_ERR(17, 28, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_points = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_vt = ((struct __pyx_obj_3pcl_4_pcl_Vertices *)values[1]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("SetParameter", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(17, 28, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropHull.SetParameter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_points), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "points", 0))) __PYX_ERR(17, 28, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vt), __pyx_ptype_3pcl_4_pcl_Vertices, 1, "vt", 0))) __PYX_ERR(17, 28, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8CropHull_6SetParameter(((struct __pyx_obj_3pcl_4_pcl_CropHull *)__pyx_v_self), __pyx_v_points, __pyx_v_vt);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_6SetParameter(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_points, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_vt) {
+  std::vector<pcl::Vertices>  const __pyx_v_tmp_vertices;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetParameter", 0);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":36
+ *         # tmp_vertices.push_back(vt)
+ *         # tmp_vertices.push_back(deref(vt.thisptr()))
+ *         self.me.setHullIndices(tmp_vertices)             # <<<<<<<<<<<<<<
+ *         # self.me.setHullCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> points)
+ *         # convert <PointCloud> to <shared_ptr[cpp.PointCloud[cpp.PointXYZ]]>
+ */
+  __pyx_v_self->me->setHullIndices(__pyx_v_tmp_vertices);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":39
+ *         # self.me.setHullCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> points)
+ *         # convert <PointCloud> to <shared_ptr[cpp.PointCloud[cpp.PointXYZ]]>
+ *         self.me.setHullCloud(points.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         self.me.setDim(<int> 2)
+ *         self.me.setCropOutside(<bool> False)
+ */
+  __pyx_v_self->me->setHullCloud(__pyx_v_points->thisptr_shared);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":40
+ *         # convert <PointCloud> to <shared_ptr[cpp.PointCloud[cpp.PointXYZ]]>
+ *         self.me.setHullCloud(points.thisptr_shared)
+ *         self.me.setDim(<int> 2)             # <<<<<<<<<<<<<<
+ *         self.me.setCropOutside(<bool> False)
+ * 
+ */
+  __pyx_v_self->me->setDim(((int)2));
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":41
+ *         self.me.setHullCloud(points.thisptr_shared)
+ *         self.me.setDim(<int> 2)
+ *         self.me.setCropOutside(<bool> False)             # <<<<<<<<<<<<<<
+ * 
+ *     def Filtering(self, PointCloud outputCloud):
+ */
+  __pyx_v_self->me->setCropOutside(((bool)0));
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":28
+ * 
+ *     # def SetParameter(self, shared_ptr[cpp.PointCloud[cpp.PointXYZ]] points, cpp.Vertices vt):
+ *     def SetParameter(self, PointCloud points, Vertices vt):             # <<<<<<<<<<<<<<
+ *         cdef const vector[cpp.Vertices] tmp_vertices
+ *         # NG
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropHull_180.pxi":43
+ *         self.me.setCropOutside(<bool> False)
+ * 
+ *     def Filtering(self, PointCloud outputCloud):             # <<<<<<<<<<<<<<
+ *         # Cython 0.25.2 NG(0.24.1 OK)
+ *         # self.me.filter(deref(outputCloud.thisptr()))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_9Filtering(PyObject *__pyx_v_self, PyObject *__pyx_v_outputCloud); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8CropHull_8Filtering[] = "CropHull.Filtering(self, PointCloud outputCloud)";
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_9Filtering(PyObject *__pyx_v_self, PyObject *__pyx_v_outputCloud) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("Filtering (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_outputCloud), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "outputCloud", 0))) __PYX_ERR(17, 43, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8CropHull_8Filtering(((struct __pyx_obj_3pcl_4_pcl_CropHull *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_outputCloud));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_8Filtering(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_outputCloud) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("Filtering", 0);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":50
+ *         # self.me.filter(<vector[int]> outputCloud)
+ *         # self.me.filter(<vector[int]&> outputCloud)
+ *         self.me.c_filter(outputCloud.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         print("filter: outputCloud size = " + str(outputCloud.size))
+ *         return outputCloud
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_outputCloud)[0]));
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":51
+ *         # self.me.filter(<vector[int]&> outputCloud)
+ *         self.me.c_filter(outputCloud.thisptr()[0])
+ *         print("filter: outputCloud size = " + str(outputCloud.size))             # <<<<<<<<<<<<<<
+ *         return outputCloud
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_outputCloud), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_filter_outputCloud_size, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(17, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":52
+ *         self.me.c_filter(outputCloud.thisptr()[0])
+ *         print("filter: outputCloud size = " + str(outputCloud.size))
+ *         return outputCloud             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_outputCloud));
+  __pyx_r = ((PyObject *)__pyx_v_outputCloud);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":43
+ *         self.me.setCropOutside(<bool> False)
+ * 
+ *     def Filtering(self, PointCloud outputCloud):             # <<<<<<<<<<<<<<
+ *         # Cython 0.25.2 NG(0.24.1 OK)
+ *         # self.me.filter(deref(outputCloud.thisptr()))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.CropHull.Filtering", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropHull_180.pxi":54
+ *         return outputCloud
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.c_filter(pc.thisptr()[0])
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_11filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_8CropHull_10filter[] = "CropHull.filter(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_8CropHull_11filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_8CropHull_10filter(((struct __pyx_obj_3pcl_4_pcl_CropHull *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_8CropHull_10filter(struct __pyx_obj_3pcl_4_pcl_CropHull *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":55
+ * 
+ *     def filter(self):
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         print("filter: pc size = " + str(pc.size))
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":56
+ *     def filter(self):
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.c_filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         print("filter: pc size = " + str(pc.size))
+ *         return pc
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":57
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         print("filter: pc size = " + str(pc.size))             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_pc), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(17, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_filter_pc_size, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(17, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(17, 57, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":58
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         print("filter: pc size = " + str(pc.size))
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/CropHull_180.pxi":54
+ *         return outputCloud
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.c_filter(pc.thisptr()[0])
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.CropHull.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":19
+ *     cdef pclfil.CropBox_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.CropBox_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_7CropBox_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_7CropBox_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(18, 19, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 19, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(18, 19, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox___cinit__(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_7CropBox___cinit__(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":20
+ * 
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclfil.CropBox_t()             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_CropBox_t();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":21
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new pclfil.CropBox_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":19
+ *     cdef pclfil.CropBox_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.CropBox_t()
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":23
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_7CropBox_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_7CropBox_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_7CropBox_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_7CropBox_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":24
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":23
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":26
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_4set_InputCloud[] = "CropBox.set_InputCloud(self, PointCloud pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_5set_InputCloud(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(18, 26, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_4set_InputCloud(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_4set_InputCloud(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputCloud", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":27
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Translation(self, tx, ty, tz):
+ */
+  ((__pyx_t_3pcl_8pcl_defs_PCLBase_t *)__pyx_v_self->me)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":26
+ *         del self.me
+ * 
+ *     def set_InputCloud(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":29
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_Translation(self, tx, ty, tz):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector3f
+ *         cdef eigen3.Vector3f origin
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_7set_Translation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_6set_Translation[] = "CropBox.set_Translation(self, tx, ty, tz)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_7set_Translation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_tx = 0;
+  PyObject *__pyx_v_ty = 0;
+  PyObject *__pyx_v_tz = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Translation (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tx,&__pyx_n_s_ty,&__pyx_n_s_tz,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tx)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ty)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Translation", 1, 3, 3, 1); __PYX_ERR(18, 29, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tz)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Translation", 1, 3, 3, 2); __PYX_ERR(18, 29, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_Translation") < 0)) __PYX_ERR(18, 29, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_tx = values[0];
+    __pyx_v_ty = values[1];
+    __pyx_v_tz = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_Translation", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 29, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Translation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_6set_Translation(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), __pyx_v_tx, __pyx_v_ty, __pyx_v_tz);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_6set_Translation(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_tx, PyObject *__pyx_v_ty, PyObject *__pyx_v_tz) {
+  Eigen::Vector3f __pyx_v_origin;
+  float *__pyx_v_data;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  float __pyx_t_1;
+  __Pyx_RefNannySetupContext("set_Translation", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":32
+ *         # Convert Eigen::Vector3f
+ *         cdef eigen3.Vector3f origin
+ *         cdef float *data = origin.data()             # <<<<<<<<<<<<<<
+ *         data[0] = tx
+ *         data[1] = ty
+ */
+  __pyx_v_data = __pyx_v_origin.data();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":33
+ *         cdef eigen3.Vector3f origin
+ *         cdef float *data = origin.data()
+ *         data[0] = tx             # <<<<<<<<<<<<<<
+ *         data[1] = ty
+ *         data[2] = tz
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_tx); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 33, __pyx_L1_error)
+  (__pyx_v_data[0]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":34
+ *         cdef float *data = origin.data()
+ *         data[0] = tx
+ *         data[1] = ty             # <<<<<<<<<<<<<<
+ *         data[2] = tz
+ *         self.me.setTranslation(origin)
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_ty); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 34, __pyx_L1_error)
+  (__pyx_v_data[1]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":35
+ *         data[0] = tx
+ *         data[1] = ty
+ *         data[2] = tz             # <<<<<<<<<<<<<<
+ *         self.me.setTranslation(origin)
+ * 
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_tz); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 35, __pyx_L1_error)
+  (__pyx_v_data[2]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":36
+ *         data[1] = ty
+ *         data[2] = tz
+ *         self.me.setTranslation(origin)             # <<<<<<<<<<<<<<
+ * 
+ *     # def set_Rotation(self, cnp.ndarray[ndim=3, dtype=int, mode='c'] ind):
+ */
+  __pyx_v_self->me->setTranslation(__pyx_v_origin);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":29
+ *         (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+ * 
+ *     def set_Translation(self, tx, ty, tz):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector3f
+ *         cdef eigen3.Vector3f origin
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Translation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":39
+ * 
+ *     # def set_Rotation(self, cnp.ndarray[ndim=3, dtype=int, mode='c'] ind):
+ *     def set_Rotation(self, rx, ry, rz):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector3f
+ *         cdef eigen3.Vector3f origin
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_9set_Rotation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_8set_Rotation[] = "CropBox.set_Rotation(self, rx, ry, rz)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_9set_Rotation(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_rx = 0;
+  PyObject *__pyx_v_ry = 0;
+  PyObject *__pyx_v_rz = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Rotation (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rx,&__pyx_n_s_ry,&__pyx_n_s_rz,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rx)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ry)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Rotation", 1, 3, 3, 1); __PYX_ERR(18, 39, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rz)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Rotation", 1, 3, 3, 2); __PYX_ERR(18, 39, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_Rotation") < 0)) __PYX_ERR(18, 39, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_rx = values[0];
+    __pyx_v_ry = values[1];
+    __pyx_v_rz = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_Rotation", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 39, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Rotation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_8set_Rotation(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), __pyx_v_rx, __pyx_v_ry, __pyx_v_rz);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_8set_Rotation(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_rx, PyObject *__pyx_v_ry, PyObject *__pyx_v_rz) {
+  Eigen::Vector3f __pyx_v_origin;
+  float *__pyx_v_data;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  float __pyx_t_1;
+  __Pyx_RefNannySetupContext("set_Rotation", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":42
+ *         # Convert Eigen::Vector3f
+ *         cdef eigen3.Vector3f origin
+ *         cdef float *data = origin.data()             # <<<<<<<<<<<<<<
+ *         data[0] = rx
+ *         data[1] = ry
+ */
+  __pyx_v_data = __pyx_v_origin.data();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":43
+ *         cdef eigen3.Vector3f origin
+ *         cdef float *data = origin.data()
+ *         data[0] = rx             # <<<<<<<<<<<<<<
+ *         data[1] = ry
+ *         data[2] = rz
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_rx); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 43, __pyx_L1_error)
+  (__pyx_v_data[0]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":44
+ *         cdef float *data = origin.data()
+ *         data[0] = rx
+ *         data[1] = ry             # <<<<<<<<<<<<<<
+ *         data[2] = rz
+ *         self.me.setRotation(origin)
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_ry); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 44, __pyx_L1_error)
+  (__pyx_v_data[1]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":45
+ *         data[0] = rx
+ *         data[1] = ry
+ *         data[2] = rz             # <<<<<<<<<<<<<<
+ *         self.me.setRotation(origin)
+ * 
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_rz); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 45, __pyx_L1_error)
+  (__pyx_v_data[2]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":46
+ *         data[1] = ry
+ *         data[2] = rz
+ *         self.me.setRotation(origin)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Min(self, minx, miny, minz, mins):
+ */
+  __pyx_v_self->me->setRotation(__pyx_v_origin);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":39
+ * 
+ *     # def set_Rotation(self, cnp.ndarray[ndim=3, dtype=int, mode='c'] ind):
+ *     def set_Rotation(self, rx, ry, rz):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector3f
+ *         cdef eigen3.Vector3f origin
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Rotation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":48
+ *         self.me.setRotation(origin)
+ * 
+ *     def set_Min(self, minx, miny, minz, mins):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector4f
+ *         cdef eigen3.Vector4f originMin
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_11set_Min(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_10set_Min[] = "CropBox.set_Min(self, minx, miny, minz, mins)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_11set_Min(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_minx = 0;
+  PyObject *__pyx_v_miny = 0;
+  PyObject *__pyx_v_minz = 0;
+  PyObject *__pyx_v_mins = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Min (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_minx,&__pyx_n_s_miny,&__pyx_n_s_minz,&__pyx_n_s_mins,0};
+    PyObject* values[4] = {0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_minx)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_miny)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Min", 1, 4, 4, 1); __PYX_ERR(18, 48, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_minz)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Min", 1, 4, 4, 2); __PYX_ERR(18, 48, __pyx_L3_error)
+        }
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mins)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Min", 1, 4, 4, 3); __PYX_ERR(18, 48, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_Min") < 0)) __PYX_ERR(18, 48, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    }
+    __pyx_v_minx = values[0];
+    __pyx_v_miny = values[1];
+    __pyx_v_minz = values[2];
+    __pyx_v_mins = values[3];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_Min", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 48, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Min", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_10set_Min(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), __pyx_v_minx, __pyx_v_miny, __pyx_v_minz, __pyx_v_mins);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_10set_Min(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_minx, PyObject *__pyx_v_miny, PyObject *__pyx_v_minz, PyObject *__pyx_v_mins) {
+  Eigen::Vector4f __pyx_v_originMin;
+  float *__pyx_v_dataMin;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  float __pyx_t_1;
+  __Pyx_RefNannySetupContext("set_Min", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":51
+ *         # Convert Eigen::Vector4f
+ *         cdef eigen3.Vector4f originMin
+ *         cdef float *dataMin = originMin.data()             # <<<<<<<<<<<<<<
+ *         dataMin[0] = minx
+ *         dataMin[1] = miny
+ */
+  __pyx_v_dataMin = __pyx_v_originMin.data();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":52
+ *         cdef eigen3.Vector4f originMin
+ *         cdef float *dataMin = originMin.data()
+ *         dataMin[0] = minx             # <<<<<<<<<<<<<<
+ *         dataMin[1] = miny
+ *         dataMin[2] = minz
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_minx); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 52, __pyx_L1_error)
+  (__pyx_v_dataMin[0]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":53
+ *         cdef float *dataMin = originMin.data()
+ *         dataMin[0] = minx
+ *         dataMin[1] = miny             # <<<<<<<<<<<<<<
+ *         dataMin[2] = minz
+ *         dataMin[3] = mins
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_miny); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 53, __pyx_L1_error)
+  (__pyx_v_dataMin[1]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":54
+ *         dataMin[0] = minx
+ *         dataMin[1] = miny
+ *         dataMin[2] = minz             # <<<<<<<<<<<<<<
+ *         dataMin[3] = mins
+ *         self.me.setMin(originMin)
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_minz); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 54, __pyx_L1_error)
+  (__pyx_v_dataMin[2]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":55
+ *         dataMin[1] = miny
+ *         dataMin[2] = minz
+ *         dataMin[3] = mins             # <<<<<<<<<<<<<<
+ *         self.me.setMin(originMin)
+ * 
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_mins); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 55, __pyx_L1_error)
+  (__pyx_v_dataMin[3]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":56
+ *         dataMin[2] = minz
+ *         dataMin[3] = mins
+ *         self.me.setMin(originMin)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Max(self, maxx, maxy, maxz, maxs):
+ */
+  __pyx_v_self->me->setMin(__pyx_v_originMin);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":48
+ *         self.me.setRotation(origin)
+ * 
+ *     def set_Min(self, minx, miny, minz, mins):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector4f
+ *         cdef eigen3.Vector4f originMin
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Min", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":58
+ *         self.me.setMin(originMin)
+ * 
+ *     def set_Max(self, maxx, maxy, maxz, maxs):             # <<<<<<<<<<<<<<
+ *         cdef eigen3.Vector4f originMax;
+ *         cdef float *dataMax = originMax.data()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_13set_Max(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_12set_Max[] = "CropBox.set_Max(self, maxx, maxy, maxz, maxs)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_13set_Max(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_maxx = 0;
+  PyObject *__pyx_v_maxy = 0;
+  PyObject *__pyx_v_maxz = 0;
+  PyObject *__pyx_v_maxs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Max (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_maxx,&__pyx_n_s_maxy,&__pyx_n_s_maxz,&__pyx_n_s_maxs,0};
+    PyObject* values[4] = {0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxx)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxy)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Max", 1, 4, 4, 1); __PYX_ERR(18, 58, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxz)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Max", 1, 4, 4, 2); __PYX_ERR(18, 58, __pyx_L3_error)
+        }
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxs)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_Max", 1, 4, 4, 3); __PYX_ERR(18, 58, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_Max") < 0)) __PYX_ERR(18, 58, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+    }
+    __pyx_v_maxx = values[0];
+    __pyx_v_maxy = values[1];
+    __pyx_v_maxz = values[2];
+    __pyx_v_maxs = values[3];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_Max", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 58, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Max", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_12set_Max(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), __pyx_v_maxx, __pyx_v_maxy, __pyx_v_maxz, __pyx_v_maxs);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_12set_Max(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_maxx, PyObject *__pyx_v_maxy, PyObject *__pyx_v_maxz, PyObject *__pyx_v_maxs) {
+  Eigen::Vector4f __pyx_v_originMax;
+  float *__pyx_v_dataMax;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  float __pyx_t_1;
+  __Pyx_RefNannySetupContext("set_Max", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":60
+ *     def set_Max(self, maxx, maxy, maxz, maxs):
+ *         cdef eigen3.Vector4f originMax;
+ *         cdef float *dataMax = originMax.data()             # <<<<<<<<<<<<<<
+ *         dataMax[0] = maxx
+ *         dataMax[1] = maxy
+ */
+  __pyx_v_dataMax = __pyx_v_originMax.data();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":61
+ *         cdef eigen3.Vector4f originMax;
+ *         cdef float *dataMax = originMax.data()
+ *         dataMax[0] = maxx             # <<<<<<<<<<<<<<
+ *         dataMax[1] = maxy
+ *         dataMax[2] = maxz
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxx); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 61, __pyx_L1_error)
+  (__pyx_v_dataMax[0]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":62
+ *         cdef float *dataMax = originMax.data()
+ *         dataMax[0] = maxx
+ *         dataMax[1] = maxy             # <<<<<<<<<<<<<<
+ *         dataMax[2] = maxz
+ *         dataMax[3] = maxs
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxy); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 62, __pyx_L1_error)
+  (__pyx_v_dataMax[1]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":63
+ *         dataMax[0] = maxx
+ *         dataMax[1] = maxy
+ *         dataMax[2] = maxz             # <<<<<<<<<<<<<<
+ *         dataMax[3] = maxs
+ *         self.me.setMax(originMax)
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxz); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 63, __pyx_L1_error)
+  (__pyx_v_dataMax[2]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":64
+ *         dataMax[1] = maxy
+ *         dataMax[2] = maxz
+ *         dataMax[3] = maxs             # <<<<<<<<<<<<<<
+ *         self.me.setMax(originMax)
+ * 
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxs); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 64, __pyx_L1_error)
+  (__pyx_v_dataMax[3]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":65
+ *         dataMax[2] = maxz
+ *         dataMax[3] = maxs
+ *         self.me.setMax(originMax)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_MinMax(self, minx, miny, minz, mins, maxx, maxy, maxz, maxs):
+ */
+  __pyx_v_self->me->setMax(__pyx_v_originMax);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":58
+ *         self.me.setMin(originMin)
+ * 
+ *     def set_Max(self, maxx, maxy, maxz, maxs):             # <<<<<<<<<<<<<<
+ *         cdef eigen3.Vector4f originMax;
+ *         cdef float *dataMax = originMax.data()
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Max", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":67
+ *         self.me.setMax(originMax)
+ * 
+ *     def set_MinMax(self, minx, miny, minz, mins, maxx, maxy, maxz, maxs):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector4f
+ *         cdef eigen3.Vector4f originMin
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_15set_MinMax(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_14set_MinMax[] = "CropBox.set_MinMax(self, minx, miny, minz, mins, maxx, maxy, maxz, maxs)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_15set_MinMax(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_minx = 0;
+  PyObject *__pyx_v_miny = 0;
+  PyObject *__pyx_v_minz = 0;
+  PyObject *__pyx_v_mins = 0;
+  PyObject *__pyx_v_maxx = 0;
+  PyObject *__pyx_v_maxy = 0;
+  PyObject *__pyx_v_maxz = 0;
+  PyObject *__pyx_v_maxs = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MinMax (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_minx,&__pyx_n_s_miny,&__pyx_n_s_minz,&__pyx_n_s_mins,&__pyx_n_s_maxx,&__pyx_n_s_maxy,&__pyx_n_s_maxz,&__pyx_n_s_maxs,0};
+    PyObject* values[8] = {0,0,0,0,0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_minx)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_miny)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, 1); __PYX_ERR(18, 67, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_minz)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, 2); __PYX_ERR(18, 67, __pyx_L3_error)
+        }
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_mins)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, 3); __PYX_ERR(18, 67, __pyx_L3_error)
+        }
+        case  4:
+        if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxx)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, 4); __PYX_ERR(18, 67, __pyx_L3_error)
+        }
+        case  5:
+        if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxy)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, 5); __PYX_ERR(18, 67, __pyx_L3_error)
+        }
+        case  6:
+        if (likely((values[6] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxz)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, 6); __PYX_ERR(18, 67, __pyx_L3_error)
+        }
+        case  7:
+        if (likely((values[7] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_maxs)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, 7); __PYX_ERR(18, 67, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_MinMax") < 0)) __PYX_ERR(18, 67, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 8) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+      values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+    }
+    __pyx_v_minx = values[0];
+    __pyx_v_miny = values[1];
+    __pyx_v_minz = values[2];
+    __pyx_v_mins = values[3];
+    __pyx_v_maxx = values[4];
+    __pyx_v_maxy = values[5];
+    __pyx_v_maxz = values[6];
+    __pyx_v_maxs = values[7];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("set_MinMax", 1, 8, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(18, 67, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_MinMax", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_14set_MinMax(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), __pyx_v_minx, __pyx_v_miny, __pyx_v_minz, __pyx_v_mins, __pyx_v_maxx, __pyx_v_maxy, __pyx_v_maxz, __pyx_v_maxs);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_14set_MinMax(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, PyObject *__pyx_v_minx, PyObject *__pyx_v_miny, PyObject *__pyx_v_minz, PyObject *__pyx_v_mins, PyObject *__pyx_v_maxx, PyObject *__pyx_v_maxy, PyObject *__pyx_v_maxz, PyObject *__pyx_v_maxs) {
+  Eigen::Vector4f __pyx_v_originMin;
+  float *__pyx_v_dataMin;
+  Eigen::Vector4f __pyx_v_originMax;
+  float *__pyx_v_dataMax;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  float __pyx_t_1;
+  __Pyx_RefNannySetupContext("set_MinMax", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":70
+ *         # Convert Eigen::Vector4f
+ *         cdef eigen3.Vector4f originMin
+ *         cdef float *dataMin = originMin.data()             # <<<<<<<<<<<<<<
+ *         dataMin[0] = minx
+ *         dataMin[1] = miny
+ */
+  __pyx_v_dataMin = __pyx_v_originMin.data();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":71
+ *         cdef eigen3.Vector4f originMin
+ *         cdef float *dataMin = originMin.data()
+ *         dataMin[0] = minx             # <<<<<<<<<<<<<<
+ *         dataMin[1] = miny
+ *         dataMin[2] = minz
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_minx); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 71, __pyx_L1_error)
+  (__pyx_v_dataMin[0]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":72
+ *         cdef float *dataMin = originMin.data()
+ *         dataMin[0] = minx
+ *         dataMin[1] = miny             # <<<<<<<<<<<<<<
+ *         dataMin[2] = minz
+ *         dataMin[3] = mins
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_miny); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 72, __pyx_L1_error)
+  (__pyx_v_dataMin[1]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":73
+ *         dataMin[0] = minx
+ *         dataMin[1] = miny
+ *         dataMin[2] = minz             # <<<<<<<<<<<<<<
+ *         dataMin[3] = mins
+ *         self.me.setMin(originMin)
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_minz); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 73, __pyx_L1_error)
+  (__pyx_v_dataMin[2]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":74
+ *         dataMin[1] = miny
+ *         dataMin[2] = minz
+ *         dataMin[3] = mins             # <<<<<<<<<<<<<<
+ *         self.me.setMin(originMin)
+ * 
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_mins); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 74, __pyx_L1_error)
+  (__pyx_v_dataMin[3]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":75
+ *         dataMin[2] = minz
+ *         dataMin[3] = mins
+ *         self.me.setMin(originMin)             # <<<<<<<<<<<<<<
+ * 
+ *         cdef eigen3.Vector4f originMax;
+ */
+  __pyx_v_self->me->setMin(__pyx_v_originMin);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":78
+ * 
+ *         cdef eigen3.Vector4f originMax;
+ *         cdef float *dataMax = originMax.data()             # <<<<<<<<<<<<<<
+ *         dataMax[0] = maxx
+ *         dataMax[1] = maxy
+ */
+  __pyx_v_dataMax = __pyx_v_originMax.data();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":79
+ *         cdef eigen3.Vector4f originMax;
+ *         cdef float *dataMax = originMax.data()
+ *         dataMax[0] = maxx             # <<<<<<<<<<<<<<
+ *         dataMax[1] = maxy
+ *         dataMax[2] = maxz
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxx); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 79, __pyx_L1_error)
+  (__pyx_v_dataMax[0]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":80
+ *         cdef float *dataMax = originMax.data()
+ *         dataMax[0] = maxx
+ *         dataMax[1] = maxy             # <<<<<<<<<<<<<<
+ *         dataMax[2] = maxz
+ *         dataMax[3] = maxs
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxy); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 80, __pyx_L1_error)
+  (__pyx_v_dataMax[1]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":81
+ *         dataMax[0] = maxx
+ *         dataMax[1] = maxy
+ *         dataMax[2] = maxz             # <<<<<<<<<<<<<<
+ *         dataMax[3] = maxs
+ *         self.me.setMax(originMax)
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxz); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 81, __pyx_L1_error)
+  (__pyx_v_dataMax[2]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":82
+ *         dataMax[1] = maxy
+ *         dataMax[2] = maxz
+ *         dataMax[3] = maxs             # <<<<<<<<<<<<<<
+ *         self.me.setMax(originMax)
+ * 
+ */
+  __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_maxs); if (unlikely((__pyx_t_1 == (float)-1) && PyErr_Occurred())) __PYX_ERR(18, 82, __pyx_L1_error)
+  (__pyx_v_dataMax[3]) = __pyx_t_1;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":83
+ *         dataMax[2] = maxz
+ *         dataMax[3] = maxs
+ *         self.me.setMax(originMax)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Negative(self, bool flag):
+ */
+  __pyx_v_self->me->setMax(__pyx_v_originMax);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":67
+ *         self.me.setMax(originMax)
+ * 
+ *     def set_MinMax(self, minx, miny, minz, mins, maxx, maxy, maxz, maxs):             # <<<<<<<<<<<<<<
+ *         # Convert Eigen::Vector4f
+ *         cdef eigen3.Vector4f originMin
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_MinMax", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":85
+ *         self.me.setMax(originMax)
+ * 
+ *     def set_Negative(self, bool flag):             # <<<<<<<<<<<<<<
+ *         self.me.setNegative(flag)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_17set_Negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_flag); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_16set_Negative[] = "CropBox.set_Negative(self, bool flag)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_17set_Negative(PyObject *__pyx_v_self, PyObject *__pyx_arg_flag) {
+  bool __pyx_v_flag;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Negative (wrapper)", 0);
+  assert(__pyx_arg_flag); {
+    __pyx_v_flag = __Pyx_PyObject_IsTrue(__pyx_arg_flag); if (unlikely((__pyx_v_flag == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(18, 85, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.CropBox.set_Negative", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_16set_Negative(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self), ((bool)__pyx_v_flag));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_16set_Negative(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self, bool __pyx_v_flag) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Negative", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":86
+ * 
+ *     def set_Negative(self, bool flag):
+ *         self.me.setNegative(flag)             # <<<<<<<<<<<<<<
+ * 
+ *     # bool
+ */
+  __pyx_v_self->me->setNegative(__pyx_v_flag);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":85
+ *         self.me.setMax(originMax)
+ * 
+ *     def set_Negative(self, bool flag):             # <<<<<<<<<<<<<<
+ *         self.me.setNegative(flag)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":89
+ * 
+ *     # bool
+ *     def get_Negative (self):             # <<<<<<<<<<<<<<
+ *         self.me.getNegative ()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_19get_Negative(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_18get_Negative[] = "CropBox.get_Negative(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_19get_Negative(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_Negative (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_18get_Negative(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_18get_Negative(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_Negative", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":90
+ *     # bool
+ *     def get_Negative (self):
+ *         self.me.getNegative ()             # <<<<<<<<<<<<<<
+ * 
+ *     def get_RemovedIndices(self):
+ */
+  __pyx_v_self->me->getNegative();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":89
+ * 
+ *     # bool
+ *     def get_Negative (self):             # <<<<<<<<<<<<<<
+ *         self.me.getNegative ()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":92
+ *         self.me.getNegative ()
+ * 
+ *     def get_RemovedIndices(self):             # <<<<<<<<<<<<<<
+ *         self.me.getRemovedIndices()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_21get_RemovedIndices(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_20get_RemovedIndices[] = "CropBox.get_RemovedIndices(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_21get_RemovedIndices(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_RemovedIndices (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_20get_RemovedIndices(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_20get_RemovedIndices(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_RemovedIndices", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":93
+ * 
+ *     def get_RemovedIndices(self):
+ *         self.me.getRemovedIndices()             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_v_self->me->getRemovedIndices();
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":92
+ *         self.me.getNegative ()
+ * 
+ *     def get_RemovedIndices(self):             # <<<<<<<<<<<<<<
+ *         self.me.getRemovedIndices()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/CropBox_180.pxi":95
+ *         self.me.getRemovedIndices()
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud pc = PointCloud()
+ *         # Cython 0.25.2 NG(0.24.1 OK)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_23filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_7CropBox_22filter[] = "CropBox.filter(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_7CropBox_23filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_7CropBox_22filter(((struct __pyx_obj_3pcl_4_pcl_CropBox *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_7CropBox_22filter(struct __pyx_obj_3pcl_4_pcl_CropBox *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":96
+ * 
+ *     def filter(self):
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         # Cython 0.25.2 NG(0.24.1 OK)
+ *         # self.me.filter(deref(pc.thisptr()))
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(18, 96, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":102
+ *         # Cython 0.24.1 NG(0.25.2 OK)
+ *         # self.me.filter(<vector[int]&> pc)
+ *         self.me.c_filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":103
+ *         # self.me.filter(<vector[int]&> pc)
+ *         self.me.c_filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/CropBox_180.pxi":95
+ *         self.me.getRemovedIndices()
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud pc = PointCloud()
+ *         # Cython 0.25.2 NG(0.24.1 OK)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.CropBox.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":11
+ *     """
+ *     cdef pclfil.ProjectInliers_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ProjectInliers_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_14ProjectInliers_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_14ProjectInliers_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_14ProjectInliers___cinit__(((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_14ProjectInliers___cinit__(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":12
+ *     cdef pclfil.ProjectInliers_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ProjectInliers_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_ProjectInliers_t();
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":11
+ *     """
+ *     cdef pclfil.ProjectInliers_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ProjectInliers_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":13
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ProjectInliers_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_14ProjectInliers_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_14ProjectInliers_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_14ProjectInliers_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_14ProjectInliers_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":14
+ *         self.me = new pclfil.ProjectInliers_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":13
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ProjectInliers_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":16
+ *         del self.me
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_5filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_14ProjectInliers_4filter[] = "ProjectInliers.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_5filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_14ProjectInliers_4filter(((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_4filter(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":21
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 21, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":22
+ *         """
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":23
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ *     # def set_Model_Coefficients(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":16
+ *         del self.me
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ProjectInliers.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":36
+ *     # def get_Model_Coefficients(self):
+ *     #     self.me.getModelCoefficients()
+ *     def set_model_type(self, pclseg.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def get_model_type(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_7set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_14ProjectInliers_6set_model_type[] = "ProjectInliers.set_model_type(self, SacModel m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_7set_model_type(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  enum pcl::SacModel __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = ((enum pcl::SacModel)__Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(__pyx_arg_m)); if (unlikely(PyErr_Occurred())) __PYX_ERR(19, 36, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ProjectInliers.set_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_14ProjectInliers_6set_model_type(((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_v_self), ((enum pcl::SacModel)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_6set_model_type(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self, enum pcl::SacModel __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_model_type", 0);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":37
+ *     #     self.me.getModelCoefficients()
+ *     def set_model_type(self, pclseg.SacModel m):
+ *         self.me.setModelType(m)             # <<<<<<<<<<<<<<
+ *     def get_model_type(self):
+ *         return self.me.getModelType()
+ */
+  __pyx_v_self->me->setModelType(__pyx_v_m);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":36
+ *     # def get_Model_Coefficients(self):
+ *     #     self.me.getModelCoefficients()
+ *     def set_model_type(self, pclseg.SacModel m):             # <<<<<<<<<<<<<<
+ *         self.me.setModelType(m)
+ *     def get_model_type(self):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":38
+ *     def set_model_type(self, pclseg.SacModel m):
+ *         self.me.setModelType(m)
+ *     def get_model_type(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getModelType()
+ *     def set_copy_all_data(self, bool m):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_9get_model_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_14ProjectInliers_8get_model_type[] = "ProjectInliers.get_model_type(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_9get_model_type(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_model_type (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_14ProjectInliers_8get_model_type(((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_8get_model_type(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_model_type", 0);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":39
+ *         self.me.setModelType(m)
+ *     def get_model_type(self):
+ *         return self.me.getModelType()             # <<<<<<<<<<<<<<
+ *     def set_copy_all_data(self, bool m):
+ *         self.me.setCopyAllData (m)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->me->getModelType()); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":38
+ *     def set_model_type(self, pclseg.SacModel m):
+ *         self.me.setModelType(m)
+ *     def get_model_type(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getModelType()
+ *     def set_copy_all_data(self, bool m):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ProjectInliers.get_model_type", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":40
+ *     def get_model_type(self):
+ *         return self.me.getModelType()
+ *     def set_copy_all_data(self, bool m):             # <<<<<<<<<<<<<<
+ *         self.me.setCopyAllData (m)
+ *     def get_copy_all_data(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_11set_copy_all_data(PyObject *__pyx_v_self, PyObject *__pyx_arg_m); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_14ProjectInliers_10set_copy_all_data[] = "ProjectInliers.set_copy_all_data(self, bool m)";
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_11set_copy_all_data(PyObject *__pyx_v_self, PyObject *__pyx_arg_m) {
+  bool __pyx_v_m;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_copy_all_data (wrapper)", 0);
+  assert(__pyx_arg_m); {
+    __pyx_v_m = __Pyx_PyObject_IsTrue(__pyx_arg_m); if (unlikely((__pyx_v_m == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(19, 40, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ProjectInliers.set_copy_all_data", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_14ProjectInliers_10set_copy_all_data(((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_v_self), ((bool)__pyx_v_m));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_10set_copy_all_data(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self, bool __pyx_v_m) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_copy_all_data", 0);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":41
+ *         return self.me.getModelType()
+ *     def set_copy_all_data(self, bool m):
+ *         self.me.setCopyAllData (m)             # <<<<<<<<<<<<<<
+ *     def get_copy_all_data(self):
+ *         return self.me.getCopyAllData ()
+ */
+  __pyx_v_self->me->setCopyAllData(__pyx_v_m);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":40
+ *     def get_model_type(self):
+ *         return self.me.getModelType()
+ *     def set_copy_all_data(self, bool m):             # <<<<<<<<<<<<<<
+ *         self.me.setCopyAllData (m)
+ *     def get_copy_all_data(self):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ProjectInliers.pxi":42
+ *     def set_copy_all_data(self, bool m):
+ *         self.me.setCopyAllData (m)
+ *     def get_copy_all_data(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getCopyAllData ()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_13get_copy_all_data(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_14ProjectInliers_12get_copy_all_data[] = "ProjectInliers.get_copy_all_data(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_14ProjectInliers_13get_copy_all_data(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_copy_all_data (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_14ProjectInliers_12get_copy_all_data(((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_14ProjectInliers_12get_copy_all_data(struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_copy_all_data", 0);
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":43
+ *         self.me.setCopyAllData (m)
+ *     def get_copy_all_data(self):
+ *         return self.me.getCopyAllData ()             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->me->getCopyAllData()); if (unlikely(!__pyx_t_1)) __PYX_ERR(19, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ProjectInliers.pxi":42
+ *     def set_copy_all_data(self, bool m):
+ *         self.me.setCopyAllData (m)
+ *     def get_copy_all_data(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getCopyAllData ()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ProjectInliers.get_copy_all_data", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":14
+ *     """
+ *     cdef pclfil.RadiusOutlierRemoval_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.RadiusOutlierRemoval_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval___cinit__(((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval___cinit__(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":15
+ *     cdef pclfil.RadiusOutlierRemoval_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclfil.RadiusOutlierRemoval_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_t();
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":14
+ *     """
+ *     cdef pclfil.RadiusOutlierRemoval_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.RadiusOutlierRemoval_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":16
+ *     def __cinit__(self):
+ *         self.me = new pclfil.RadiusOutlierRemoval_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":17
+ *         self.me = new pclfil.RadiusOutlierRemoval_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":16
+ *     def __cinit__(self):
+ *         self.me = new pclfil.RadiusOutlierRemoval_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":19
+ *         del self.me
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_5filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_4filter[] = "RadiusOutlierRemoval.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_5filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_4filter(((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_4filter(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  std::vector<int>  __pyx_t_2;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":24
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         # Cython 0.25.2 NG(0.24.1 OK)
+ *         # self.me.filter(pc.thisptr()[0])
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 24, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":31
+ *         # self.me.filter(<vector[int]> pc)
+ *         # pcl 1.7.2
+ *         self.me.filter(<vector[int]&> pc)             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_t_2 = __pyx_convert_vector_from_py_int(((PyObject *)__pyx_v_pc)); if (unlikely(PyErr_Occurred())) __PYX_ERR(20, 31, __pyx_L1_error)
+  __pyx_v_self->me->filter(((std::vector<int>  &)__pyx_t_2));
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":32
+ *         # pcl 1.7.2
+ *         self.me.filter(<vector[int]&> pc)
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ *     def set_radius_search(self, double radius):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":19
+ *         del self.me
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.RadiusOutlierRemoval.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":34
+ *         return pc
+ * 
+ *     def set_radius_search(self, double radius):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusSearch(radius)
+ *     def get_radius_search(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_7set_radius_search(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_6set_radius_search[] = "RadiusOutlierRemoval.set_radius_search(self, double radius)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_7set_radius_search(PyObject *__pyx_v_self, PyObject *__pyx_arg_radius) {
+  double __pyx_v_radius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_search (wrapper)", 0);
+  assert(__pyx_arg_radius); {
+    __pyx_v_radius = __pyx_PyFloat_AsDouble(__pyx_arg_radius); if (unlikely((__pyx_v_radius == (double)-1) && PyErr_Occurred())) __PYX_ERR(20, 34, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RadiusOutlierRemoval.set_radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_6set_radius_search(((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_v_self), ((double)__pyx_v_radius));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_6set_radius_search(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self, double __pyx_v_radius) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_radius_search", 0);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":35
+ * 
+ *     def set_radius_search(self, double radius):
+ *         self.me.setRadiusSearch(radius)             # <<<<<<<<<<<<<<
+ *     def get_radius_search(self):
+ *         return self.me.getRadiusSearch()
+ */
+  __pyx_v_self->me->setRadiusSearch(__pyx_v_radius);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":34
+ *         return pc
+ * 
+ *     def set_radius_search(self, double radius):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusSearch(radius)
+ *     def get_radius_search(self):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":36
+ *     def set_radius_search(self, double radius):
+ *         self.me.setRadiusSearch(radius)
+ *     def get_radius_search(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getRadiusSearch()
+ *     def set_MinNeighborsInRadius(self, int min_pts):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_9get_radius_search(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_8get_radius_search[] = "RadiusOutlierRemoval.get_radius_search(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_9get_radius_search(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_radius_search (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_8get_radius_search(((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_8get_radius_search(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_radius_search", 0);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":37
+ *         self.me.setRadiusSearch(radius)
+ *     def get_radius_search(self):
+ *         return self.me.getRadiusSearch()             # <<<<<<<<<<<<<<
+ *     def set_MinNeighborsInRadius(self, int min_pts):
+ *         self.me.setMinNeighborsInRadius (min_pts)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getRadiusSearch()); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":36
+ *     def set_radius_search(self, double radius):
+ *         self.me.setRadiusSearch(radius)
+ *     def get_radius_search(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getRadiusSearch()
+ *     def set_MinNeighborsInRadius(self, int min_pts):
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.RadiusOutlierRemoval.get_radius_search", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":38
+ *     def get_radius_search(self):
+ *         return self.me.getRadiusSearch()
+ *     def set_MinNeighborsInRadius(self, int min_pts):             # <<<<<<<<<<<<<<
+ *         self.me.setMinNeighborsInRadius (min_pts)
+ *     def get_MinNeighborsInRadius(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_11set_MinNeighborsInRadius(PyObject *__pyx_v_self, PyObject *__pyx_arg_min_pts); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_10set_MinNeighborsInRadius[] = "RadiusOutlierRemoval.set_MinNeighborsInRadius(self, int min_pts)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_11set_MinNeighborsInRadius(PyObject *__pyx_v_self, PyObject *__pyx_arg_min_pts) {
+  int __pyx_v_min_pts;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MinNeighborsInRadius (wrapper)", 0);
+  assert(__pyx_arg_min_pts); {
+    __pyx_v_min_pts = __Pyx_PyInt_As_int(__pyx_arg_min_pts); if (unlikely((__pyx_v_min_pts == (int)-1) && PyErr_Occurred())) __PYX_ERR(20, 38, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RadiusOutlierRemoval.set_MinNeighborsInRadius", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_10set_MinNeighborsInRadius(((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_v_self), ((int)__pyx_v_min_pts));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_10set_MinNeighborsInRadius(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self, int __pyx_v_min_pts) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MinNeighborsInRadius", 0);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":39
+ *         return self.me.getRadiusSearch()
+ *     def set_MinNeighborsInRadius(self, int min_pts):
+ *         self.me.setMinNeighborsInRadius (min_pts)             # <<<<<<<<<<<<<<
+ *     def get_MinNeighborsInRadius(self):
+ *         return self.me.getMinNeighborsInRadius ()
+ */
+  __pyx_v_self->me->setMinNeighborsInRadius(__pyx_v_min_pts);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":38
+ *     def get_radius_search(self):
+ *         return self.me.getRadiusSearch()
+ *     def set_MinNeighborsInRadius(self, int min_pts):             # <<<<<<<<<<<<<<
+ *         self.me.setMinNeighborsInRadius (min_pts)
+ *     def get_MinNeighborsInRadius(self):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":40
+ *     def set_MinNeighborsInRadius(self, int min_pts):
+ *         self.me.setMinNeighborsInRadius (min_pts)
+ *     def get_MinNeighborsInRadius(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getMinNeighborsInRadius ()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_13get_MinNeighborsInRadius(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_12get_MinNeighborsInRadius[] = "RadiusOutlierRemoval.get_MinNeighborsInRadius(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_13get_MinNeighborsInRadius(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_MinNeighborsInRadius (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_12get_MinNeighborsInRadius(((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20RadiusOutlierRemoval_12get_MinNeighborsInRadius(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_MinNeighborsInRadius", 0);
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":41
+ *         self.me.setMinNeighborsInRadius (min_pts)
+ *     def get_MinNeighborsInRadius(self):
+ *         return self.me.getMinNeighborsInRadius ()             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->me->getMinNeighborsInRadius()); if (unlikely(!__pyx_t_1)) __PYX_ERR(20, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi":40
+ *     def set_MinNeighborsInRadius(self, int min_pts):
+ *         self.me.setMinNeighborsInRadius (min_pts)
+ *     def get_MinNeighborsInRadius(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getMinNeighborsInRadius ()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.RadiusOutlierRemoval.get_MinNeighborsInRadius", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ConditionAnd.pxi":21
+ *     cdef pclfil.ConditionAnd_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ConditionAnd_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_12ConditionAnd_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_12ConditionAnd_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12ConditionAnd___cinit__(((struct __pyx_obj_3pcl_4_pcl_ConditionAnd *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_12ConditionAnd___cinit__(struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":22
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclfil.ConditionAnd_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_ConditionAnd_t();
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":21
+ *     cdef pclfil.ConditionAnd_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclfil.ConditionAnd_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ConditionAnd.pxi":24
+ *         self.me = new pclfil.ConditionAnd_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_12ConditionAnd_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_12ConditionAnd_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_12ConditionAnd_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ConditionAnd *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_12ConditionAnd_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":25
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     # def add_Comparison(self, comparison):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":24
+ *         self.me = new pclfil.ConditionAnd_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Filters/ConditionAnd.pxi":30
+ *     #     self.me.addComparison(comparison.this_ptr())
+ * 
+ *     def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_12ConditionAnd_5add_Comparison2(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_12ConditionAnd_4add_Comparison2[] = "ConditionAnd.add_Comparison2(self, field_name, CompareOp2 compOp, double thresh)";
+static PyObject *__pyx_pw_3pcl_4_pcl_12ConditionAnd_5add_Comparison2(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_field_name = 0;
+  pcl::ComparisonOps::CompareOp __pyx_v_compOp;
+  double __pyx_v_thresh;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("add_Comparison2 (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_field_name,&__pyx_n_s_compOp,&__pyx_n_s_thresh,0};
+    PyObject* values[3] = {0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_field_name)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_compOp)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("add_Comparison2", 1, 3, 3, 1); __PYX_ERR(21, 30, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("add_Comparison2", 1, 3, 3, 2); __PYX_ERR(21, 30, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add_Comparison2") < 0)) __PYX_ERR(21, 30, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+    }
+    __pyx_v_field_name = values[0];
+    __pyx_v_compOp = ((pcl::ComparisonOps::CompareOp)__Pyx_PyInt_As_pcl_3a__3a_ComparisonOps_3a__3a_CompareOp(values[1])); if (unlikely(PyErr_Occurred())) __PYX_ERR(21, 30, __pyx_L3_error)
+    __pyx_v_thresh = __pyx_PyFloat_AsDouble(values[2]); if (unlikely((__pyx_v_thresh == (double)-1) && PyErr_Occurred())) __PYX_ERR(21, 30, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("add_Comparison2", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(21, 30, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ConditionAnd.add_Comparison2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_12ConditionAnd_4add_Comparison2(((struct __pyx_obj_3pcl_4_pcl_ConditionAnd *)__pyx_v_self), __pyx_v_field_name, __pyx_v_compOp, __pyx_v_thresh);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_12ConditionAnd_4add_Comparison2(struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_self, PyObject *__pyx_v_field_name, pcl::ComparisonOps::CompareOp __pyx_v_compOp, double __pyx_v_thresh) {
+  PyObject *__pyx_v_fname_ascii = 0;
+  __pyx_t_3pcl_11pcl_filters_FieldComparisonConstPtr_t __pyx_v_fieldComp;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  char *__pyx_t_5;
+  std::string __pyx_t_6;
+  __Pyx_RefNannySetupContext("add_Comparison2", 0);
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":32
+ *     def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+  __pyx_t_1 = PyUnicode_Check(__pyx_v_field_name); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/Filters/ConditionAnd.pxi":33
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r" % field_name)
+ */
+    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_field_name, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(21, 33, __pyx_L1_error)
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "pcl/pxi/Filters/ConditionAnd.pxi":32
+ *     def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh):
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):             # <<<<<<<<<<<<<<
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":34
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r" % field_name)
+ *         else:
+ */
+  __pyx_t_2 = PyBytes_Check(__pyx_v_field_name); 
+  __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/Filters/ConditionAnd.pxi":35
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r" % field_name)             # <<<<<<<<<<<<<<
+ *         else:
+ *             fname_ascii = field_name
+ */
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_field_name_should_be_a_string_go, __pyx_v_field_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(21, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(21, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(21, 35, __pyx_L1_error)
+
+    /* "pcl/pxi/Filters/ConditionAnd.pxi":34
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")
+ *         elif not isinstance(field_name, bytes):             # <<<<<<<<<<<<<<
+ *             raise TypeError("field_name should be a string, got %r" % field_name)
+ *         else:
+ */
+  }
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":37
+ *             raise TypeError("field_name should be a string, got %r" % field_name)
+ *         else:
+ *             fname_ascii = field_name             # <<<<<<<<<<<<<<
+ * 
+ *         cdef pclfil.FieldComparisonConstPtr_t fieldComp = <pclfil.FieldComparisonConstPtr_t> new pclfil.FieldComparison_t(string(fname_ascii), compOp, thresh)
+ */
+  /*else*/ {
+    if (!(likely(PyBytes_CheckExact(__pyx_v_field_name))||((__pyx_v_field_name) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_field_name)->tp_name), 0))) __PYX_ERR(21, 37, __pyx_L1_error)
+    __pyx_t_4 = __pyx_v_field_name;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_fname_ascii = ((PyObject*)__pyx_t_4);
+    __pyx_t_4 = 0;
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":39
+ *             fname_ascii = field_name
+ * 
+ *         cdef pclfil.FieldComparisonConstPtr_t fieldComp = <pclfil.FieldComparisonConstPtr_t> new pclfil.FieldComparison_t(string(fname_ascii), compOp, thresh)             # <<<<<<<<<<<<<<
+ * 
+ *         # Cython 0.25.2 NG
+ */
+  __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_fname_ascii); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(21, 39, __pyx_L1_error)
+  try {
+    __pyx_t_6 = std::string(__pyx_t_5);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(21, 39, __pyx_L1_error)
+  }
+  __pyx_v_fieldComp = ((__pyx_t_3pcl_11pcl_filters_FieldComparisonConstPtr_t)new __pyx_t_3pcl_11pcl_filters_FieldComparison_t(__pyx_t_6, __pyx_v_compOp, __pyx_v_thresh));
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":43
+ *         # Cython 0.25.2 NG
+ *         # self.me.addComparison(<shared_ptr[const pclfil.ComparisonBase[cpp.PointXYZ]]> fieldComp)
+ *         self.me.addComparison(<shared_ptr[const pclfil.ComparisonBase[cpp.PointXYZ]]> fieldComp)             # <<<<<<<<<<<<<<
+ * 
+ *         # NG
+ */
+  __pyx_v_self->me->addComparison(((boost::shared_ptr<pcl::ComparisonBase<struct pcl::PointXYZ>  const > )__pyx_v_fieldComp));
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":30
+ *     #     self.me.addComparison(comparison.this_ptr())
+ * 
+ *     def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh):             # <<<<<<<<<<<<<<
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.ConditionAnd.add_Comparison2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_fname_ascii);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ConditionalRemoval.pxi":19
+ *     cdef pclfil.ConditionalRemoval_t *me
+ * 
+ *     def __cinit__(self, ConditionAnd cond):             # <<<<<<<<<<<<<<
+ *         # self.me = new pclfil.ConditionalRemoval_t(<pclfil.ConditionBase_t*>cond.me)
+ *         # direct - NG
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_18ConditionalRemoval_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_18ConditionalRemoval_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_cond = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cond,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cond)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(22, 19, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_cond = ((struct __pyx_obj_3pcl_4_pcl_ConditionAnd *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(22, 19, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ConditionalRemoval.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cond), __pyx_ptype_3pcl_4_pcl_ConditionAnd, 1, "cond", 0))) __PYX_ERR(22, 19, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18ConditionalRemoval___cinit__(((struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *)__pyx_v_self), __pyx_v_cond);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_18ConditionalRemoval___cinit__(struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_cond) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":22
+ *         # self.me = new pclfil.ConditionalRemoval_t(<pclfil.ConditionBase_t*>cond.me)
+ *         # direct - NG
+ *         self.me = new pclfil.ConditionalRemoval_t(<pclfil.ConditionBasePtr_t>cond.me)             # <<<<<<<<<<<<<<
+ * 
+ *     # def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_t(((__pyx_t_3pcl_11pcl_filters_ConditionBasePtr_t)__pyx_v_cond->me), NULL);
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":19
+ *     cdef pclfil.ConditionalRemoval_t *me
+ * 
+ *     def __cinit__(self, ConditionAnd cond):             # <<<<<<<<<<<<<<
+ *         # self.me = new pclfil.ConditionalRemoval_t(<pclfil.ConditionBase_t*>cond.me)
+ *         # direct - NG
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ConditionalRemoval.pxi":29
+ *     #    self.me
+ * 
+ *     def set_KeepOrganized(self, flag):             # <<<<<<<<<<<<<<
+ *         self.me.setKeepOrganized(flag)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18ConditionalRemoval_3set_KeepOrganized(PyObject *__pyx_v_self, PyObject *__pyx_v_flag); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18ConditionalRemoval_2set_KeepOrganized[] = "ConditionalRemoval.set_KeepOrganized(self, flag)";
+static PyObject *__pyx_pw_3pcl_4_pcl_18ConditionalRemoval_3set_KeepOrganized(PyObject *__pyx_v_self, PyObject *__pyx_v_flag) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_KeepOrganized (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18ConditionalRemoval_2set_KeepOrganized(((struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *)__pyx_v_self), ((PyObject *)__pyx_v_flag));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18ConditionalRemoval_2set_KeepOrganized(struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *__pyx_v_self, PyObject *__pyx_v_flag) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  bool __pyx_t_1;
+  __Pyx_RefNannySetupContext("set_KeepOrganized", 0);
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":30
+ * 
+ *     def set_KeepOrganized(self, flag):
+ *         self.me.setKeepOrganized(flag)             # <<<<<<<<<<<<<<
+ * 
+ *     def filter(self):
+ */
+  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_flag); if (unlikely((__pyx_t_1 == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(22, 30, __pyx_L1_error)
+  __pyx_v_self->me->setKeepOrganized(__pyx_t_1);
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":29
+ *     #    self.me
+ * 
+ *     def set_KeepOrganized(self, flag):             # <<<<<<<<<<<<<<
+ *         self.me.setKeepOrganized(flag)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.ConditionalRemoval.set_KeepOrganized", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Filters/ConditionalRemoval.pxi":32
+ *         self.me.setKeepOrganized(flag)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_18ConditionalRemoval_5filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_18ConditionalRemoval_4filter[] = "ConditionalRemoval.filter(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_18ConditionalRemoval_5filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_18ConditionalRemoval_4filter(((struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_18ConditionalRemoval_4filter(struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("filter", 0);
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":37
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(22, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":38
+ *         """
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ */
+  __pyx_v_self->me->filter((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":39
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.filter(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Filters/ConditionalRemoval.pxi":32
+ *         self.me.setKeepOrganized(flag)
+ * 
+ *     def filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ConditionalRemoval.filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":10
+ *     """
+ *     cdef pclsf.ConcaveHull_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_11ConcaveHull_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_11ConcaveHull_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11ConcaveHull___cinit__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_11ConcaveHull___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":11
+ *     cdef pclsf.ConcaveHull_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_surface_ConcaveHull_t();
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":10
+ *     """
+ *     cdef pclsf.ConcaveHull_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":12
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_11ConcaveHull_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_11ConcaveHull_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_11ConcaveHull_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_11ConcaveHull_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":13
+ *         self.me = new pclsf.ConcaveHull_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def reconstruct(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":12
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":15
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11ConcaveHull_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11ConcaveHull_4reconstruct[] = "ConcaveHull.reconstruct(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_11ConcaveHull_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("reconstruct (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11ConcaveHull_4reconstruct(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11ConcaveHull_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("reconstruct", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":20
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud pc = PointCloud()             # <<<<<<<<<<<<<<
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 20, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":21
+ *         """
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.reconstruct(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->reconstruct((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":22
+ *         cdef PointCloud pc = PointCloud()
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Alpha(self, double d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":15
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull.reconstruct", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":24
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11ConcaveHull_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11ConcaveHull_6set_Alpha[] = "ConcaveHull.set_Alpha(self, double d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_11ConcaveHull_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  double __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsDouble(__pyx_arg_d); if (unlikely((__pyx_v_d == (double)-1) && PyErr_Occurred())) __PYX_ERR(23, 24, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull.set_Alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11ConcaveHull_6set_Alpha(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull *)__pyx_v_self), ((double)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11ConcaveHull_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_self, double __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":25
+ * 
+ *     def set_Alpha(self, double d):
+ *         self.me.setAlpha (d)             # <<<<<<<<<<<<<<
+ * 
+ * cdef class ConcaveHull_PointXYZI:
+ */
+  __pyx_v_self->me->setAlpha(__pyx_v_d);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":24
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":32
+ *     """
+ *     cdef pclsf.ConcaveHull_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":33
+ *     cdef pclsf.ConcaveHull_PointXYZI_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZI_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZI_t();
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":32
+ *     """
+ *     cdef pclsf.ConcaveHull_PointXYZI_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_PointXYZI_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":34
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":35
+ *         self.me = new pclsf.ConcaveHull_PointXYZI_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def reconstruct(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":34
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZI_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":37
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21ConcaveHull_PointXYZI_4reconstruct[] = "ConcaveHull_PointXYZI.reconstruct(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("reconstruct (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_4reconstruct(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("reconstruct", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":42
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()             # <<<<<<<<<<<<<<
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":43
+ *         """
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.reconstruct(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->reconstruct((__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":44
+ *         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Alpha(self, double d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":37
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull_PointXYZI.reconstruct", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":46
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21ConcaveHull_PointXYZI_6set_Alpha[] = "ConcaveHull_PointXYZI.set_Alpha(self, double d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  double __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsDouble(__pyx_arg_d); if (unlikely((__pyx_v_d == (double)-1) && PyErr_Occurred())) __PYX_ERR(23, 46, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull_PointXYZI.set_Alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_6set_Alpha(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *)__pyx_v_self), ((double)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21ConcaveHull_PointXYZI_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI *__pyx_v_self, double __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":47
+ * 
+ *     def set_Alpha(self, double d):
+ *         self.me.setAlpha (d)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me->setAlpha(__pyx_v_d);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":46
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":55
+ *     """
+ *     cdef pclsf.ConcaveHull_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":56
+ *     cdef pclsf.ConcaveHull_PointXYZRGB_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGB_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZRGB_t();
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":55
+ *     """
+ *     cdef pclsf.ConcaveHull_PointXYZRGB_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":57
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":58
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGB_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def reconstruct(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":57
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGB_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":60
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_4reconstruct[] = "ConcaveHull_PointXYZRGB.reconstruct(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("reconstruct (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_4reconstruct(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("reconstruct", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":65
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":66
+ *         """
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.reconstruct(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->reconstruct((__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":67
+ *         cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Alpha(self, double d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":60
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull_PointXYZRGB.reconstruct", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":69
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_6set_Alpha[] = "ConcaveHull_PointXYZRGB.set_Alpha(self, double d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  double __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsDouble(__pyx_arg_d); if (unlikely((__pyx_v_d == (double)-1) && PyErr_Occurred())) __PYX_ERR(23, 69, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull_PointXYZRGB.set_Alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_6set_Alpha(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *)__pyx_v_self), ((double)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB *__pyx_v_self, double __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":70
+ * 
+ *     def set_Alpha(self, double d):
+ *         self.me.setAlpha (d)             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_v_self->me->setAlpha(__pyx_v_d);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":69
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":78
+ *     """
+ *     cdef pclsf.ConcaveHull_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":79
+ *     cdef pclsf.ConcaveHull_PointXYZRGBA_t *me
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGBA_t()             # <<<<<<<<<<<<<<
+ *     def __dealloc__(self):
+ *         del self.me
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_11pcl_surface_ConcaveHull_PointXYZRGBA_t();
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":78
+ *     """
+ *     cdef pclsf.ConcaveHull_PointXYZRGBA_t *me
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":80
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":81
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGBA_t()
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def reconstruct(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":80
+ *     def __cinit__(self):
+ *         self.me = new pclsf.ConcaveHull_PointXYZRGBA_t()
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":83
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_4reconstruct[] = "ConcaveHull_PointXYZRGBA.reconstruct(self)\n\n        Apply the filter according to the previously set parameters and return\n        a new pointcloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_5reconstruct(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("reconstruct (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_4reconstruct(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_4reconstruct(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_pc = 0;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("reconstruct", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":88
+ *         a new pointcloud
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(23, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":89
+ *         """
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.reconstruct(pc.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         return pc
+ * 
+ */
+  __pyx_v_self->me->reconstruct((__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_pc)[0]));
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":90
+ *         cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+ *         self.me.reconstruct(pc.thisptr()[0])
+ *         return pc             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Alpha(self, double d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_pc));
+  __pyx_r = ((PyObject *)__pyx_v_pc);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":83
+ *         del self.me
+ * 
+ *     def reconstruct(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Apply the filter according to the previously set parameters and return
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull_PointXYZRGBA.reconstruct", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_pc);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Surface/ConcaveHull.pxi":92
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_6set_Alpha[] = "ConcaveHull_PointXYZRGBA.set_Alpha(self, double d)";
+static PyObject *__pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_7set_Alpha(PyObject *__pyx_v_self, PyObject *__pyx_arg_d) {
+  double __pyx_v_d;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha (wrapper)", 0);
+  assert(__pyx_arg_d); {
+    __pyx_v_d = __pyx_PyFloat_AsDouble(__pyx_arg_d); if (unlikely((__pyx_v_d == (double)-1) && PyErr_Occurred())) __PYX_ERR(23, 92, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.ConcaveHull_PointXYZRGBA.set_Alpha", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_6set_Alpha(((struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *)__pyx_v_self), ((double)__pyx_v_d));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_6set_Alpha(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA *__pyx_v_self, double __pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Alpha", 0);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":93
+ * 
+ *     def set_Alpha(self, double d):
+ *         self.me.setAlpha (d)             # <<<<<<<<<<<<<<
+ * 
+ */
+  __pyx_v_self->me->setAlpha(__pyx_v_d);
+
+  /* "pcl/pxi/Surface/ConcaveHull.pxi":92
+ *         return pc
+ * 
+ *     def set_Alpha(self, double d):             # <<<<<<<<<<<<<<
+ *         self.me.setAlpha (d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":16
+ *     rangeImage
+ *     """
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         # self.me = new pcl_r_img.RangeImage_t()
+ *         # NG : Compiler crash
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_11RangeImages_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_11RangeImages_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11RangeImages___cinit__(((struct __pyx_obj_3pcl_4_pcl_RangeImages *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_11RangeImages___cinit__(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":29
+ *     #     pass
+ * 
+ *     def CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height,             # <<<<<<<<<<<<<<
+ *         pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_3CreateFromPointCloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11RangeImages_2CreateFromPointCloud[] = "RangeImages.CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height, CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size)";
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_3CreateFromPointCloud(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_cloud = 0;
+  float __pyx_v_angular_resolution;
+  float __pyx_v_max_angle_width;
+  float __pyx_v_max_angle_height;
+  pcl::RangeImage::CoordinateFrame __pyx_v_coordinate_frame;
+  float __pyx_v_noise_level;
+  float __pyx_v_min_range;
+  int __pyx_v_border_size;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("CreateFromPointCloud (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cloud,&__pyx_n_s_angular_resolution,&__pyx_n_s_max_angle_width,&__pyx_n_s_max_angle_height,&__pyx_n_s_coordinate_frame,&__pyx_n_s_noise_level,&__pyx_n_s_min_range,&__pyx_n_s_border_size,0};
+    PyObject* values[8] = {0,0,0,0,0,0,0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cloud)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_angular_resolution)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, 1); __PYX_ERR(24, 29, __pyx_L3_error)
+        }
+        case  2:
+        if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_angle_width)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, 2); __PYX_ERR(24, 29, __pyx_L3_error)
+        }
+        case  3:
+        if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_angle_height)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, 3); __PYX_ERR(24, 29, __pyx_L3_error)
+        }
+        case  4:
+        if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_coordinate_frame)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, 4); __PYX_ERR(24, 29, __pyx_L3_error)
+        }
+        case  5:
+        if (likely((values[5] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_noise_level)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, 5); __PYX_ERR(24, 29, __pyx_L3_error)
+        }
+        case  6:
+        if (likely((values[6] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_min_range)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, 6); __PYX_ERR(24, 29, __pyx_L3_error)
+        }
+        case  7:
+        if (likely((values[7] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_border_size)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, 7); __PYX_ERR(24, 29, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "CreateFromPointCloud") < 0)) __PYX_ERR(24, 29, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 8) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
+      values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
+    }
+    __pyx_v_cloud = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_angular_resolution = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_angular_resolution == (float)-1) && PyErr_Occurred())) __PYX_ERR(24, 29, __pyx_L3_error)
+    __pyx_v_max_angle_width = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_max_angle_width == (float)-1) && PyErr_Occurred())) __PYX_ERR(24, 29, __pyx_L3_error)
+    __pyx_v_max_angle_height = __pyx_PyFloat_AsFloat(values[3]); if (unlikely((__pyx_v_max_angle_height == (float)-1) && PyErr_Occurred())) __PYX_ERR(24, 29, __pyx_L3_error)
+    __pyx_v_coordinate_frame = ((pcl::RangeImage::CoordinateFrame)__Pyx_PyInt_As_pcl_3a__3a_RangeImage_3a__3a_CoordinateFrame(values[4])); if (unlikely(PyErr_Occurred())) __PYX_ERR(24, 30, __pyx_L3_error)
+    __pyx_v_noise_level = __pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_noise_level == (float)-1) && PyErr_Occurred())) __PYX_ERR(24, 30, __pyx_L3_error)
+    __pyx_v_min_range = __pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_min_range == (float)-1) && PyErr_Occurred())) __PYX_ERR(24, 30, __pyx_L3_error)
+    __pyx_v_border_size = __Pyx_PyInt_As_int(values[7]); if (unlikely((__pyx_v_border_size == (int)-1) && PyErr_Occurred())) __PYX_ERR(24, 30, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("CreateFromPointCloud", 1, 8, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(24, 29, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RangeImages.CreateFromPointCloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cloud), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "cloud", 0))) __PYX_ERR(24, 29, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11RangeImages_2CreateFromPointCloud(((struct __pyx_obj_3pcl_4_pcl_RangeImages *)__pyx_v_self), __pyx_v_cloud, __pyx_v_angular_resolution, __pyx_v_max_angle_width, __pyx_v_max_angle_height, __pyx_v_coordinate_frame, __pyx_v_noise_level, __pyx_v_min_range, __pyx_v_border_size);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_2CreateFromPointCloud(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_cloud, float __pyx_v_angular_resolution, float __pyx_v_max_angle_width, float __pyx_v_max_angle_height, pcl::RangeImage::CoordinateFrame __pyx_v_coordinate_frame, float __pyx_v_noise_level, float __pyx_v_min_range, int __pyx_v_border_size) {
+  Eigen::Affine3f __pyx_v_sensor_pose;
+  CYTHON_UNUSED float *__pyx_v_data;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Translation3f __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("CreateFromPointCloud", 0);
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":32
+ *         pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+ * 
+ *         print('CreateFromPointCloud enter')             # <<<<<<<<<<<<<<
+ * 
+ *         # cdef cpp.PointCloudPtr_t point
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_CreateFromPointCloud_enter) < 0) __PYX_ERR(24, 32, __pyx_L1_error)
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":38
+ *         # Eigen::Translation3f
+ *         cdef eigen3.Affine3f sensor_pose
+ *         cdef float *data = sensor_pose.data()             # <<<<<<<<<<<<<<
+ *         # print('sensor_pose size = ' + str( len(data) ) )
+ *         # cdef eigen3.Translation3f data(0.0, 0.0, 0.0)
+ */
+  __pyx_v_data = __pyx_v_sensor_pose.data();
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":47
+ *         # print('sensor_pose = ' + data)
+ *         # (Eigen::Affine3f)Eigen::Translation3f(0.0f, 0.0f, 0.0f);
+ *         sensor_pose = <eigen3.Affine3f>eigen3.Translation3f(0.0, 0.0, 0.0)             # <<<<<<<<<<<<<<
+ * 
+ *         print('angular_resolution = ' + str(angular_resolution) )
+ */
+  try {
+    __pyx_t_1 = Eigen::Translation3f(0.0, 0.0, 0.0);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(24, 47, __pyx_L1_error)
+  }
+  __pyx_v_sensor_pose = ((Eigen::Affine3f)__pyx_t_1);
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":49
+ *         sensor_pose = <eigen3.Affine3f>eigen3.Translation3f(0.0, 0.0, 0.0)
+ * 
+ *         print('angular_resolution = ' + str(angular_resolution) )             # <<<<<<<<<<<<<<
+ *         print('max_angle_width = ' + str(max_angle_width) )
+ *         print('max_angle_height = ' + str(max_angle_height) )
+ */
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_angular_resolution); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Add(__pyx_kp_s_angular_resolution_2, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(24, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":50
+ * 
+ *         print('angular_resolution = ' + str(angular_resolution) )
+ *         print('max_angle_width = ' + str(max_angle_width) )             # <<<<<<<<<<<<<<
+ *         print('max_angle_height = ' + str(max_angle_height) )
+ *         print('noise_level = ' + str(noise_level) )
+ */
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_max_angle_width); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_max_angle_width_2, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(24, 50, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":51
+ *         print('angular_resolution = ' + str(angular_resolution) )
+ *         print('max_angle_width = ' + str(max_angle_width) )
+ *         print('max_angle_height = ' + str(max_angle_height) )             # <<<<<<<<<<<<<<
+ *         print('noise_level = ' + str(noise_level) )
+ *         print('min_range = ' + str(min_range) )
+ */
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_max_angle_height); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Add(__pyx_kp_s_max_angle_height_2, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(24, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":52
+ *         print('max_angle_width = ' + str(max_angle_width) )
+ *         print('max_angle_height = ' + str(max_angle_height) )
+ *         print('noise_level = ' + str(noise_level) )             # <<<<<<<<<<<<<<
+ *         print('min_range = ' + str(min_range) )
+ *         print('border_size = ' + str(border_size) )
+ */
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_noise_level); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_noise_level_2, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(24, 52, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":53
+ *         print('max_angle_height = ' + str(max_angle_height) )
+ *         print('noise_level = ' + str(noise_level) )
+ *         print('min_range = ' + str(min_range) )             # <<<<<<<<<<<<<<
+ *         print('border_size = ' + str(border_size) )
+ * 
+ */
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_min_range); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Add(__pyx_kp_s_min_range_2, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(24, 53, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":54
+ *         print('noise_level = ' + str(noise_level) )
+ *         print('min_range = ' + str(min_range) )
+ *         print('border_size = ' + str(border_size) )             # <<<<<<<<<<<<<<
+ * 
+ *         print('cloud.size = ' + str(cloud.size) )
+ */
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_border_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_border_size_2, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(24, 54, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":56
+ *         print('border_size = ' + str(border_size) )
+ * 
+ *         print('cloud.size = ' + str(cloud.size) )             # <<<<<<<<<<<<<<
+ *         print('cloud.width = ' + str(cloud.width) )
+ *         print('cloud.height = ' + str(cloud.height) )
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cloud), __pyx_n_s_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Add(__pyx_kp_s_cloud_size, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(24, 56, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":57
+ * 
+ *         print('cloud.size = ' + str(cloud.size) )
+ *         print('cloud.width = ' + str(cloud.width) )             # <<<<<<<<<<<<<<
+ *         print('cloud.height = ' + str(cloud.height) )
+ * 
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cloud), __pyx_n_s_width); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_cloud_width, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(24, 57, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":58
+ *         print('cloud.size = ' + str(cloud.size) )
+ *         print('cloud.width = ' + str(cloud.width) )
+ *         print('cloud.height = ' + str(cloud.height) )             # <<<<<<<<<<<<<<
+ * 
+ *         print('call createFromPointCloud')
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cloud), __pyx_n_s_height); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(24, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyNumber_Add(__pyx_kp_s_cloud_height, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(24, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_3) < 0) __PYX_ERR(24, 58, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":60
+ *         print('cloud.height = ' + str(cloud.height) )
+ * 
+ *         print('call createFromPointCloud')             # <<<<<<<<<<<<<<
+ * 
+ *         self.thisptr().createFromPointCloud(
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_call_createFromPointCloud) < 0) __PYX_ERR(24, 60, __pyx_L1_error)
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":62
+ *         print('call createFromPointCloud')
+ * 
+ *         self.thisptr().createFromPointCloud(             # <<<<<<<<<<<<<<
+ *             cloud.thisptr()[0],
+ *             angular_resolution,
+ */
+  __pyx_f_3pcl_4_pcl_11RangeImages_thisptr(__pyx_v_self)->createFromPointCloud((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_cloud)[0]), __pyx_v_angular_resolution, __pyx_v_max_angle_width, __pyx_v_max_angle_height, __pyx_v_sensor_pose, ((pcl::RangeImage::CoordinateFrame)__pyx_v_coordinate_frame), __pyx_v_noise_level, __pyx_v_min_range, __pyx_v_border_size);
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":29
+ *     #     pass
+ * 
+ *     def CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height,             # <<<<<<<<<<<<<<
+ *         pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.RangeImages.CreateFromPointCloud", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":73
+ *             border_size)
+ * 
+ *     def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):             # <<<<<<<<<<<<<<
+ *         self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_5SetAngularResolution(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11RangeImages_4SetAngularResolution[] = "RangeImages.SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y)";
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_5SetAngularResolution(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  float __pyx_v_angular_resolution_x;
+  float __pyx_v_angular_resolution_y;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetAngularResolution (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_angular_resolution_x,&__pyx_n_s_angular_resolution_y,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_angular_resolution_x)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_angular_resolution_y)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("SetAngularResolution", 1, 2, 2, 1); __PYX_ERR(24, 73, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "SetAngularResolution") < 0)) __PYX_ERR(24, 73, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_angular_resolution_x = __pyx_PyFloat_AsFloat(values[0]); if (unlikely((__pyx_v_angular_resolution_x == (float)-1) && PyErr_Occurred())) __PYX_ERR(24, 73, __pyx_L3_error)
+    __pyx_v_angular_resolution_y = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_angular_resolution_y == (float)-1) && PyErr_Occurred())) __PYX_ERR(24, 73, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("SetAngularResolution", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(24, 73, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RangeImages.SetAngularResolution", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11RangeImages_4SetAngularResolution(((struct __pyx_obj_3pcl_4_pcl_RangeImages *)__pyx_v_self), __pyx_v_angular_resolution_x, __pyx_v_angular_resolution_y);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_4SetAngularResolution(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self, float __pyx_v_angular_resolution_x, float __pyx_v_angular_resolution_y) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetAngularResolution", 0);
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":74
+ * 
+ *     def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):
+ *         self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)             # <<<<<<<<<<<<<<
+ * 
+ *     def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):
+ */
+  (__pyx_f_3pcl_4_pcl_11RangeImages_thisptr(__pyx_v_self)[0]).setAngularResolution(__pyx_v_angular_resolution_x, __pyx_v_angular_resolution_y);
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":73
+ *             border_size)
+ * 
+ *     def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):             # <<<<<<<<<<<<<<
+ *         self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":76
+ *         self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+ * 
+ *     def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):             # <<<<<<<<<<<<<<
+ *         # cdef pcl_r_img.RangeImage_t *user
+ *         # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_7IntegrateFarRanges(PyObject *__pyx_v_self, PyObject *__pyx_v_viewpoint); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11RangeImages_6IntegrateFarRanges[] = "RangeImages.IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint)";
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_7IntegrateFarRanges(PyObject *__pyx_v_self, PyObject *__pyx_v_viewpoint) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("IntegrateFarRanges (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_viewpoint), __pyx_ptype_3pcl_4_pcl_PointCloud_PointWithViewpoint, 1, "viewpoint", 0))) __PYX_ERR(24, 76, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11RangeImages_6IntegrateFarRanges(((struct __pyx_obj_3pcl_4_pcl_RangeImages *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_viewpoint));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_6IntegrateFarRanges(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_viewpoint) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("IntegrateFarRanges", 0);
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":79
+ *         # cdef pcl_r_img.RangeImage_t *user
+ *         # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+ *         self.thisptr().integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])             # <<<<<<<<<<<<<<
+ *         # self.thisprt()[0].integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+ *         # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+ */
+  __pyx_f_3pcl_4_pcl_11RangeImages_thisptr(__pyx_v_self)->integrateFarRanges(((__pyx_t_3pcl_8pcl_defs_PointCloud_PointWithViewpoint_t &)(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_viewpoint)[0])));
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":76
+ *         self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+ * 
+ *     def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):             # <<<<<<<<<<<<<<
+ *         # cdef pcl_r_img.RangeImage_t *user
+ *         # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":83
+ *         # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+ * 
+ *     def SetUnseenToMaxRange(self):             # <<<<<<<<<<<<<<
+ *         self.thisptr()[0].setUnseenToMaxRange()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_9SetUnseenToMaxRange(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_11RangeImages_8SetUnseenToMaxRange[] = "RangeImages.SetUnseenToMaxRange(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_11RangeImages_9SetUnseenToMaxRange(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetUnseenToMaxRange (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_11RangeImages_8SetUnseenToMaxRange(((struct __pyx_obj_3pcl_4_pcl_RangeImages *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_11RangeImages_8SetUnseenToMaxRange(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("SetUnseenToMaxRange", 0);
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":84
+ * 
+ *     def SetUnseenToMaxRange(self):
+ *         self.thisptr()[0].setUnseenToMaxRange()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  (__pyx_f_3pcl_4_pcl_11RangeImages_thisptr(__pyx_v_self)[0]).setUnseenToMaxRange();
+
+  /* "pcl/pxi/Common/RangeImage/RangeImages_180.pxi":83
+ *         # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+ * 
+ *     def SetUnseenToMaxRange(self):             # <<<<<<<<<<<<<<
+ *         self.thisptr()[0].setUnseenToMaxRange()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":18
+ *     cdef pcl_reg.GeneralizedIterativeClosestPoint_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint___cinit__(((struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint___cinit__(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_t *__pyx_t_1;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":19
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  try {
+    __pyx_t_1 = new __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_t();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(25, 19, __pyx_L1_error)
+  }
+  __pyx_v_self->me = __pyx_t_1;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":18
+ *     cdef pcl_reg.GeneralizedIterativeClosestPoint_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.GeneralizedIterativeClosestPoint.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":21
+ *         self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":22
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":21
+ *         self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":24
+ *         del self.me
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         # 1.6.0 NG(No descrription)
+ *         # reg.setInputSource(source.thisptr_shared)
+ */
+
+static PyObject *__pyx_f_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &__pyx_v_reg, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, struct __pyx_opt_args_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run *__pyx_optional_args) {
+  PyObject *__pyx_v_max_iter = ((PyObject *)Py_None);
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_result = 0;
+  Eigen::Matrix4f __pyx_v_mat;
+  PyArrayObject *__pyx_v_transf = 0;
+  __pyx_t_5numpy_float32_t *__pyx_v_transf_data;
+  long __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_transf;
+  __Pyx_Buffer __pyx_pybuffer_transf;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  long __pyx_t_12;
+  __Pyx_RefNannySetupContext("run", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_max_iter = __pyx_optional_args->max_iter;
+    }
+  }
+  __pyx_pybuffer_transf.pybuffer.buf = NULL;
+  __pyx_pybuffer_transf.refcount = 0;
+  __pyx_pybuffernd_transf.data = NULL;
+  __pyx_pybuffernd_transf.rcbuffer = &__pyx_pybuffer_transf;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":38
+ *         # get InputCloud?
+ *         # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+ *         reg.setInputTarget(target.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *         if max_iter is not None:
+ */
+  __pyx_v_reg.setInputTarget(__pyx_v_target->thisptr_shared);
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":40
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ *         if max_iter is not None:             # <<<<<<<<<<<<<<
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_max_iter != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":41
+ * 
+ *         if max_iter is not None:
+ *             reg.setMaximumIterations(max_iter)             # <<<<<<<<<<<<<<
+ * 
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ */
+    __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_max_iter); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(25, 41, __pyx_L1_error)
+    try {
+      __pyx_v_reg.setMaximumIterations(__pyx_t_3);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(25, 41, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":40
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ *         if max_iter is not None:             # <<<<<<<<<<<<<<
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":43
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()             # <<<<<<<<<<<<<<
+ * 
+ *         with nogil:
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_result = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":45
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ * 
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             reg.align(result.thisptr()[0])
+ * 
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":46
+ * 
+ *         with nogil:
+ *             reg.align(result.thisptr()[0])             # <<<<<<<<<<<<<<
+ * 
+ *         # Get transformation matrix and convert from Eigen to NumPy format.
+ */
+        try {
+          __pyx_v_reg.align((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_result)[0]));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(25, 46, __pyx_L5_error)
+        }
+      }
+
+      /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":45
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ * 
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             reg.align(result.thisptr()[0])
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L6;
+        }
+        __pyx_L5_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L6:;
+      }
+  }
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":51
+ *         # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+ *         cdef Matrix4f mat
+ *         mat = reg.getFinalTransformation()             # <<<<<<<<<<<<<<
+ *         cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+ *         cdef np.float32_t *transf_data
+ */
+  __pyx_v_mat = __pyx_v_reg.getFinalTransformation();
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":55
+ *         cdef np.float32_t *transf_data
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')             # <<<<<<<<<<<<<<
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_s_fortran) < 0) __PYX_ERR(25, 55, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__13, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(25, 55, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_7);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+    __pyx_t_3 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_transf.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_3 < 0)) {
+      PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_transf.rcbuffer->pybuffer, (PyObject*)__pyx_v_transf, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      }
+    }
+    __pyx_pybuffernd_transf.diminfo[0].strides = __pyx_pybuffernd_transf.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_transf.diminfo[0].shape = __pyx_pybuffernd_transf.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_transf.diminfo[1].strides = __pyx_pybuffernd_transf.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_transf.diminfo[1].shape = __pyx_pybuffernd_transf.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(25, 55, __pyx_L1_error)
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_transf = ((PyArrayObject *)__pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":56
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(16):
+ */
+  __pyx_v_transf_data = ((__pyx_t_5numpy_float32_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_transf)));
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":58
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ *         for i in range(16):             # <<<<<<<<<<<<<<
+ *             transf_data[i] = mat.data()[i]
+ * 
+ */
+  for (__pyx_t_12 = 0; __pyx_t_12 < 16; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":59
+ * 
+ *         for i in range(16):
+ *             transf_data[i] = mat.data()[i]             # <<<<<<<<<<<<<<
+ * 
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ */
+    (__pyx_v_transf_data[__pyx_v_i]) = (__pyx_v_mat.data()[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":61
+ *             transf_data[i] = mat.data()[i]
+ * 
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()             # <<<<<<<<<<<<<<
+ * 
+ *     def gicp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_reg.hasConverged()); if (unlikely(!__pyx_t_7)) __PYX_ERR(25, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_reg.getFitnessScore()); if (unlikely(!__pyx_t_4)) __PYX_ERR(25, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(25, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7);
+  __Pyx_INCREF(((PyObject *)__pyx_v_transf));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_transf));
+  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_transf));
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_result));
+  PyTuple_SET_ITEM(__pyx_t_5, 2, ((PyObject *)__pyx_v_result));
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4);
+  __pyx_t_7 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":24
+ *         del self.me
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         # 1.6.0 NG(No descrription)
+ *         # reg.setInputSource(source.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.GeneralizedIterativeClosestPoint.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF((PyObject *)__pyx_v_transf);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":63
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ * 
+ *     def gicp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Align source to target using generalized iterative closest point (GICP).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_5gicp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_4gicp[] = "GeneralizedIterativeClosestPoint.gicp(self, PointCloud source, PointCloud target, max_iter=None)\n\n        Align source to target using generalized iterative closest point (GICP).\n        \n        Parameters\n        ----------\n        source : PointCloud\n            Source point cloud.\n        target : PointCloud\n            Target point cloud.\n        max_iter : integer, optional\n            Maximum number of iterations. If not given, uses the default number\n            hardwired into PCL.\n        \n        Returns\n        -------\n        converged : bool\n            Whether the ICP algorithm converged in at most max_iter steps.\n        transf : np.ndarray, shape = [4, 4]\n            Transformation matrix.\n        estimate : PointCloud\n            Transformed version of source.\n        fitness : float\n            Sum of squares error in the estimated transformation.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_5gicp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source = 0;
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target = 0;
+  PyObject *__pyx_v_max_iter = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("gicp (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source,&__pyx_n_s_target,&__pyx_n_s_max_iter,0};
+    PyObject* values[3] = {0,0,0};
+    values[2] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_source)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("gicp", 0, 2, 3, 1); __PYX_ERR(25, 63, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_iter);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gicp") < 0)) __PYX_ERR(25, 63, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_source = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_target = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[1]);
+    __pyx_v_max_iter = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("gicp", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(25, 63, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.GeneralizedIterativeClosestPoint.gicp", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_source), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "source", 0))) __PYX_ERR(25, 63, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_target), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "target", 0))) __PYX_ERR(25, 63, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_4gicp(((struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *)__pyx_v_self), __pyx_v_source, __pyx_v_target, __pyx_v_max_iter);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_4gicp(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, PyObject *__pyx_v_max_iter) {
+  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_t __pyx_v_gicp;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  struct __pyx_opt_args_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run __pyx_t_2;
+  __Pyx_RefNannySetupContext("gicp", 0);
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":89
+ *         """
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t gicp
+ *         gicp.setInputCloud(source.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return self.run(gicp, source, target, max_iter)
+ * 
+ */
+  __pyx_v_gicp.setInputCloud(__pyx_v_source->thisptr_shared);
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":90
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t gicp
+ *         gicp.setInputCloud(source.thisptr_shared)
+ *         return self.run(gicp, source, target, max_iter)             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2.__pyx_n = 1;
+  __pyx_t_2.max_iter = __pyx_v_max_iter;
+  __pyx_t_1 = ((struct __pyx_vtabstruct_3pcl_4_pcl_GeneralizedIterativeClosestPoint *)__pyx_v_self->__pyx_vtab)->run(__pyx_v_self, __pyx_v_gicp, __pyx_v_source, __pyx_v_target, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(25, 90, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":63
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ * 
+ *     def gicp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Align source to target using generalized iterative closest point (GICP).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.GeneralizedIterativeClosestPoint.gicp", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":22
+ *     cdef pcl_reg.IterativeClosestPoint_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_reg.IterativeClosestPoint_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint___cinit__(((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint___cinit__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_t *__pyx_t_1;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":23
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pcl_reg.IterativeClosestPoint_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  try {
+    __pyx_t_1 = new __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_t();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(26, 23, __pyx_L1_error)
+  }
+  __pyx_v_self->me = __pyx_t_1;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":22
+ *     cdef pcl_reg.IterativeClosestPoint_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_reg.IterativeClosestPoint_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPoint.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":25
+ *         self.me = new pcl_reg.IterativeClosestPoint_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":26
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     # def set_InputTarget(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":25
+ *         self.me = new pcl_reg.IterativeClosestPoint_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":29
+ * 
+ *     # def set_InputTarget(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg):
+ *     def set_InputTarget(self, _pcl.PointCloud cloud):             # <<<<<<<<<<<<<<
+ *         self.me.setInputTarget (cloud.thisptr_shared)
+ *         pass
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_5set_InputTarget(PyObject *__pyx_v_self, PyObject *__pyx_v_cloud); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21IterativeClosestPoint_4set_InputTarget[] = "IterativeClosestPoint.set_InputTarget(self, PointCloud cloud)";
+static PyObject *__pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_5set_InputTarget(PyObject *__pyx_v_self, PyObject *__pyx_v_cloud) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputTarget (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_cloud), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "cloud", 0))) __PYX_ERR(26, 29, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_4set_InputTarget(((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_cloud));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_4set_InputTarget(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_cloud) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputTarget", 0);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":30
+ *     # def set_InputTarget(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg):
+ *     def set_InputTarget(self, _pcl.PointCloud cloud):
+ *         self.me.setInputTarget (cloud.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_v_self->me->setInputTarget(__pyx_v_cloud->thisptr_shared);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":29
+ * 
+ *     # def set_InputTarget(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg):
+ *     def set_InputTarget(self, _pcl.PointCloud cloud):             # <<<<<<<<<<<<<<
+ *         self.me.setInputTarget (cloud.thisptr_shared)
+ *         pass
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":54
+ *     #     return self.me.getFinalNumIteration()
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ */
+
+static PyObject *__pyx_f_3pcl_4_pcl_21IterativeClosestPoint_run(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &__pyx_v_reg, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, struct __pyx_opt_args_3pcl_4_pcl_21IterativeClosestPoint_run *__pyx_optional_args) {
+  PyObject *__pyx_v_max_iter = ((PyObject *)Py_None);
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_result = 0;
+  Eigen::Matrix4f __pyx_v_mat;
+  PyArrayObject *__pyx_v_transf = 0;
+  __pyx_t_5numpy_float32_t *__pyx_v_transf_data;
+  long __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_transf;
+  __Pyx_Buffer __pyx_pybuffer_transf;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  long __pyx_t_12;
+  __Pyx_RefNannySetupContext("run", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_max_iter = __pyx_optional_args->max_iter;
+    }
+  }
+  __pyx_pybuffer_transf.pybuffer.buf = NULL;
+  __pyx_pybuffer_transf.refcount = 0;
+  __pyx_pybuffernd_transf.data = NULL;
+  __pyx_pybuffernd_transf.rcbuffer = &__pyx_pybuffer_transf;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":55
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+ *         reg.setInputTarget(target.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *         if max_iter is not None:
+ */
+  __pyx_v_reg.setInputTarget(__pyx_v_target->thisptr_shared);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":57
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ *         if max_iter is not None:             # <<<<<<<<<<<<<<
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_max_iter != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":58
+ * 
+ *         if max_iter is not None:
+ *             reg.setMaximumIterations(max_iter)             # <<<<<<<<<<<<<<
+ * 
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ */
+    __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_max_iter); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(26, 58, __pyx_L1_error)
+    try {
+      __pyx_v_reg.setMaximumIterations(__pyx_t_3);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(26, 58, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":57
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ *         if max_iter is not None:             # <<<<<<<<<<<<<<
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":60
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()             # <<<<<<<<<<<<<<
+ * 
+ *         with nogil:
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(26, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_result = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":62
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ * 
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             reg.align(result.thisptr()[0])
+ * 
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":63
+ * 
+ *         with nogil:
+ *             reg.align(result.thisptr()[0])             # <<<<<<<<<<<<<<
+ * 
+ *         # Get transformation matrix and convert from Eigen to NumPy format.
+ */
+        try {
+          __pyx_v_reg.align((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_result)[0]));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(26, 63, __pyx_L5_error)
+        }
+      }
+
+      /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":62
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ * 
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             reg.align(result.thisptr()[0])
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L6;
+        }
+        __pyx_L5_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L6:;
+      }
+  }
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":68
+ *         # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+ *         cdef Matrix4f mat
+ *         mat = reg.getFinalTransformation()             # <<<<<<<<<<<<<<
+ *         cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+ *         cdef np.float32_t *transf_data
+ */
+  __pyx_v_mat = __pyx_v_reg.getFinalTransformation();
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":72
+ *         cdef np.float32_t *transf_data
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')             # <<<<<<<<<<<<<<
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_7)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_s_fortran) < 0) __PYX_ERR(26, 72, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__15, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(26, 72, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_7);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+    __pyx_t_3 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_transf.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_3 < 0)) {
+      PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_transf.rcbuffer->pybuffer, (PyObject*)__pyx_v_transf, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      }
+    }
+    __pyx_pybuffernd_transf.diminfo[0].strides = __pyx_pybuffernd_transf.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_transf.diminfo[0].shape = __pyx_pybuffernd_transf.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_transf.diminfo[1].strides = __pyx_pybuffernd_transf.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_transf.diminfo[1].shape = __pyx_pybuffernd_transf.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(26, 72, __pyx_L1_error)
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_transf = ((PyArrayObject *)__pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":73
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(16):
+ */
+  __pyx_v_transf_data = ((__pyx_t_5numpy_float32_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_transf)));
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":75
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ *         for i in range(16):             # <<<<<<<<<<<<<<
+ *             transf_data[i] = mat.data()[i]
+ * 
+ */
+  for (__pyx_t_12 = 0; __pyx_t_12 < 16; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":76
+ * 
+ *         for i in range(16):
+ *             transf_data[i] = mat.data()[i]             # <<<<<<<<<<<<<<
+ * 
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ */
+    (__pyx_v_transf_data[__pyx_v_i]) = (__pyx_v_mat.data()[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":78
+ *             transf_data[i] = mat.data()[i]
+ * 
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()             # <<<<<<<<<<<<<<
+ * 
+ *     def icp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_reg.hasConverged()); if (unlikely(!__pyx_t_7)) __PYX_ERR(26, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_reg.getFitnessScore()); if (unlikely(!__pyx_t_4)) __PYX_ERR(26, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(26, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7);
+  __Pyx_INCREF(((PyObject *)__pyx_v_transf));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_transf));
+  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_transf));
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_result));
+  PyTuple_SET_ITEM(__pyx_t_5, 2, ((PyObject *)__pyx_v_result));
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4);
+  __pyx_t_7 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":54
+ *     #     return self.me.getFinalNumIteration()
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPoint.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF((PyObject *)__pyx_v_transf);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":80
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ * 
+ *     def icp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Align source to target using iterative closest point (ICP).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_7icp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21IterativeClosestPoint_6icp[] = "IterativeClosestPoint.icp(self, PointCloud source, PointCloud target, max_iter=None)\n\n        Align source to target using iterative closest point (ICP).\n        Parameters\n        ----------\n        source : PointCloud\n            Source point cloud.\n        target : PointCloud\n            Target point cloud.\n        max_iter : integer, optional\n            Maximum number of iterations. If not given, uses the default number\n            hardwired into PCL.\n        Returns\n        -------\n        converged : bool\n            Whether the ICP algorithm converged in at most max_iter steps.\n        transf : np.ndarray, shape = [4, 4]\n            Transformation matrix.\n        estimate : PointCloud\n            Transformed version of source.\n        fitness : float\n            Sum of squares error in the estimated transformation.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_7icp(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source = 0;
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target = 0;
+  PyObject *__pyx_v_max_iter = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("icp (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source,&__pyx_n_s_target,&__pyx_n_s_max_iter,0};
+    PyObject* values[3] = {0,0,0};
+    values[2] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_source)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("icp", 0, 2, 3, 1); __PYX_ERR(26, 80, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_iter);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "icp") < 0)) __PYX_ERR(26, 80, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_source = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_target = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[1]);
+    __pyx_v_max_iter = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("icp", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(26, 80, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPoint.icp", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_source), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "source", 0))) __PYX_ERR(26, 80, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_target), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "target", 0))) __PYX_ERR(26, 80, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_6icp(((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *)__pyx_v_self), __pyx_v_source, __pyx_v_target, __pyx_v_max_iter);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21IterativeClosestPoint_6icp(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, PyObject *__pyx_v_max_iter) {
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_t __pyx_v_icp;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  struct __pyx_opt_args_3pcl_4_pcl_21IterativeClosestPoint_run __pyx_t_2;
+  __Pyx_RefNannySetupContext("icp", 0);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":104
+ *         """
+ *         cdef pcl_reg.IterativeClosestPoint_t icp
+ *         icp.setInputCloud(source.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return self.run(icp, source, target, max_iter)
+ */
+  __pyx_v_icp.setInputCloud(__pyx_v_source->thisptr_shared);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":105
+ *         cdef pcl_reg.IterativeClosestPoint_t icp
+ *         icp.setInputCloud(source.thisptr_shared)
+ *         return self.run(icp, source, target, max_iter)             # <<<<<<<<<<<<<<
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2.__pyx_n = 1;
+  __pyx_t_2.max_iter = __pyx_v_max_iter;
+  __pyx_t_1 = ((struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPoint *)__pyx_v_self->__pyx_vtab)->run(__pyx_v_self, __pyx_v_icp, __pyx_v_source, __pyx_v_target, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(26, 105, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":80
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ * 
+ *     def icp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Align source to target using iterative closest point (ICP).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPoint.icp", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":18
+ *     cdef pcl_reg.IterativeClosestPointNonLinear_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_reg.IterativeClosestPointNonLinear_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear___cinit__(((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear___cinit__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_t *__pyx_t_1;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":19
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pcl_reg.IterativeClosestPointNonLinear_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  try {
+    __pyx_t_1 = new __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_t();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(27, 19, __pyx_L1_error)
+  }
+  __pyx_v_self->me = __pyx_t_1;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":18
+ *     cdef pcl_reg.IterativeClosestPointNonLinear_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_reg.IterativeClosestPointNonLinear_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPointNonLinear.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":21
+ *         self.me = new pcl_reg.IterativeClosestPointNonLinear_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":22
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":21
+ *         self.me = new pcl_reg.IterativeClosestPointNonLinear_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":24
+ *         del self.me
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         # 1.6.0 NG(No descrription)
+ *         # reg.setInputSource(source.thisptr_shared)
+ */
+
+static PyObject *__pyx_f_3pcl_4_pcl_30IterativeClosestPointNonLinear_run(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &__pyx_v_reg, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, struct __pyx_opt_args_3pcl_4_pcl_30IterativeClosestPointNonLinear_run *__pyx_optional_args) {
+  PyObject *__pyx_v_max_iter = ((PyObject *)Py_None);
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_result = 0;
+  Eigen::Matrix4f __pyx_v_mat;
+  PyArrayObject *__pyx_v_transf = 0;
+  __pyx_t_5numpy_float32_t *__pyx_v_transf_data;
+  long __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_transf;
+  __Pyx_Buffer __pyx_pybuffer_transf;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyArrayObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  long __pyx_t_12;
+  __Pyx_RefNannySetupContext("run", 0);
+  if (__pyx_optional_args) {
+    if (__pyx_optional_args->__pyx_n > 0) {
+      __pyx_v_max_iter = __pyx_optional_args->max_iter;
+    }
+  }
+  __pyx_pybuffer_transf.pybuffer.buf = NULL;
+  __pyx_pybuffer_transf.refcount = 0;
+  __pyx_pybuffernd_transf.data = NULL;
+  __pyx_pybuffernd_transf.rcbuffer = &__pyx_pybuffer_transf;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":38
+ *         # get InputCloud?
+ *         # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+ *         reg.setInputTarget(target.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *         if max_iter is not None:
+ */
+  __pyx_v_reg.setInputTarget(__pyx_v_target->thisptr_shared);
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":40
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ *         if max_iter is not None:             # <<<<<<<<<<<<<<
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ */
+  __pyx_t_1 = (__pyx_v_max_iter != Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":41
+ * 
+ *         if max_iter is not None:
+ *             reg.setMaximumIterations(max_iter)             # <<<<<<<<<<<<<<
+ * 
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ */
+    __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_v_max_iter); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(27, 41, __pyx_L1_error)
+    try {
+      __pyx_v_reg.setMaximumIterations(__pyx_t_3);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(27, 41, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":40
+ *         reg.setInputTarget(target.thisptr_shared)
+ * 
+ *         if max_iter is not None:             # <<<<<<<<<<<<<<
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ */
+  }
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":43
+ *             reg.setMaximumIterations(max_iter)
+ * 
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()             # <<<<<<<<<<<<<<
+ * 
+ *         with nogil:
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_v_result = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_4);
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":45
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ * 
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             reg.align(result.thisptr()[0])
+ * 
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":46
+ * 
+ *         with nogil:
+ *             reg.align(result.thisptr()[0])             # <<<<<<<<<<<<<<
+ * 
+ *         # Get transformation matrix and convert from Eigen to NumPy format.
+ */
+        try {
+          __pyx_v_reg.align((__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_result)[0]));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(27, 46, __pyx_L5_error)
+        }
+      }
+
+      /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":45
+ *         cdef _pcl.PointCloud result = _pcl.PointCloud()
+ * 
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             reg.align(result.thisptr()[0])
+ * 
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L6;
+        }
+        __pyx_L5_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L6:;
+      }
+  }
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":51
+ *         # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+ *         cdef Matrix4f mat
+ *         mat = reg.getFinalTransformation()             # <<<<<<<<<<<<<<
+ *         cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+ *         cdef np.float32_t *transf_data
+ */
+  __pyx_v_mat = __pyx_v_reg.getFinalTransformation();
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":55
+ *         cdef np.float32_t *transf_data
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')             # <<<<<<<<<<<<<<
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_7) < 0) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_order, __pyx_n_s_fortran) < 0) __PYX_ERR(27, 55, __pyx_L1_error)
+  __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__17, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(27, 55, __pyx_L1_error)
+  __pyx_t_8 = ((PyArrayObject *)__pyx_t_7);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+    __pyx_t_3 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_transf.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_3 < 0)) {
+      PyErr_Fetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_transf.rcbuffer->pybuffer, (PyObject*)__pyx_v_transf, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_F_CONTIGUOUS, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_11);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
+      }
+    }
+    __pyx_pybuffernd_transf.diminfo[0].strides = __pyx_pybuffernd_transf.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_transf.diminfo[0].shape = __pyx_pybuffernd_transf.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_transf.diminfo[1].strides = __pyx_pybuffernd_transf.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_transf.diminfo[1].shape = __pyx_pybuffernd_transf.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(27, 55, __pyx_L1_error)
+  }
+  __pyx_t_8 = 0;
+  __pyx_v_transf = ((PyArrayObject *)__pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":56
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(16):
+ */
+  __pyx_v_transf_data = ((__pyx_t_5numpy_float32_t *)PyArray_DATA(((PyArrayObject *)__pyx_v_transf)));
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":58
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ *         for i in range(16):             # <<<<<<<<<<<<<<
+ *             transf_data[i] = mat.data()[i]
+ * 
+ */
+  for (__pyx_t_12 = 0; __pyx_t_12 < 16; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":59
+ * 
+ *         for i in range(16):
+ *             transf_data[i] = mat.data()[i]             # <<<<<<<<<<<<<<
+ * 
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ */
+    (__pyx_v_transf_data[__pyx_v_i]) = (__pyx_v_mat.data()[__pyx_v_i]);
+  }
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":61
+ *             transf_data[i] = mat.data()[i]
+ * 
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()             # <<<<<<<<<<<<<<
+ * 
+ *     def icp_nl(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_reg.hasConverged()); if (unlikely(!__pyx_t_7)) __PYX_ERR(27, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_reg.getFitnessScore()); if (unlikely(!__pyx_t_4)) __PYX_ERR(27, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(27, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7);
+  __Pyx_INCREF(((PyObject *)__pyx_v_transf));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_transf));
+  PyTuple_SET_ITEM(__pyx_t_5, 1, ((PyObject *)__pyx_v_transf));
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_result));
+  PyTuple_SET_ITEM(__pyx_t_5, 2, ((PyObject *)__pyx_v_result));
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4);
+  __pyx_t_7 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":24
+ *         del self.me
+ * 
+ *     cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         # 1.6.0 NG(No descrription)
+ *         # reg.setInputSource(source.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPointNonLinear.run", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_transf.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF((PyObject *)__pyx_v_transf);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":63
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ * 
+ *     def icp_nl(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Align source to target using generalized non-linear ICP (ICP-NL).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_5icp_nl(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_30IterativeClosestPointNonLinear_4icp_nl[] = "IterativeClosestPointNonLinear.icp_nl(self, PointCloud source, PointCloud target, max_iter=None)\n\n        Align source to target using generalized non-linear ICP (ICP-NL).\n        \n        Parameters\n        ----------\n        source : PointCloud\n            Source point cloud.\n        target : PointCloud\n            Target point cloud.\n        \n        max_iter : integer, optional\n            Maximum number of iterations. If not given, uses the default number\n            hardwired into PCL.\n        \n        Returns\n        -------\n        converged : bool\n            Whether the ICP algorithm converged in at most max_iter steps.\n        transf : np.ndarray, shape = [4, 4]\n            Transformation matrix.\n        estimate : PointCloud\n            Transformed version of source.\n        fitness : float\n            Sum of squares error in the estimated transformation.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_5icp_nl(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source = 0;
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target = 0;
+  PyObject *__pyx_v_max_iter = 0;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("icp_nl (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_source,&__pyx_n_s_target,&__pyx_n_s_max_iter,0};
+    PyObject* values[3] = {0,0,0};
+    values[2] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_source)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_target)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("icp_nl", 0, 2, 3, 1); __PYX_ERR(27, 63, __pyx_L3_error)
+        }
+        case  2:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_max_iter);
+          if (value) { values[2] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "icp_nl") < 0)) __PYX_ERR(27, 63, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_source = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+    __pyx_v_target = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[1]);
+    __pyx_v_max_iter = values[2];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("icp_nl", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(27, 63, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPointNonLinear.icp_nl", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_source), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "source", 0))) __PYX_ERR(27, 63, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_target), __pyx_ptype_3pcl_4_pcl_PointCloud, 1, "target", 0))) __PYX_ERR(27, 63, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear_4icp_nl(((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *)__pyx_v_self), __pyx_v_source, __pyx_v_target, __pyx_v_max_iter);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_30IterativeClosestPointNonLinear_4icp_nl(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_source, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_target, PyObject *__pyx_v_max_iter) {
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_t __pyx_v_icp_nl;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  struct __pyx_opt_args_3pcl_4_pcl_30IterativeClosestPointNonLinear_run __pyx_t_2;
+  __Pyx_RefNannySetupContext("icp_nl", 0);
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":90
+ *         """
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t icp_nl
+ *         icp_nl.setInputCloud(source.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return self.run(icp_nl, source, target, max_iter)
+ * 
+ */
+  __pyx_v_icp_nl.setInputCloud(__pyx_v_source->thisptr_shared);
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":91
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t icp_nl
+ *         icp_nl.setInputCloud(source.thisptr_shared)
+ *         return self.run(icp_nl, source, target, max_iter)             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2.__pyx_n = 1;
+  __pyx_t_2.max_iter = __pyx_v_max_iter;
+  __pyx_t_1 = ((struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPointNonLinear *)__pyx_v_self->__pyx_vtab)->run(__pyx_v_self, __pyx_v_icp_nl, __pyx_v_source, __pyx_v_target, &__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(27, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":63
+ *         return reg.hasConverged(), transf, result, reg.getFitnessScore()
+ * 
+ *     def icp_nl(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Align source to target using generalized non-linear ICP (ICP-NL).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.IterativeClosestPointNonLinear.icp_nl", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":14
+ * 
+ *     # SetNG
+ *     def __cinit__(self, SampleConsensusModel model):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+ *         pass
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *__pyx_v_model = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_model,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_model)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(28, 14, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_model = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(28, 14, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RandomSampleConsensus.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_model), __pyx_ptype_3pcl_4_pcl_SampleConsensusModel, 1, "model", 0))) __PYX_ERR(28, 14, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus___cinit__(((struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *)__pyx_v_self), __pyx_v_model);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus___cinit__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *__pyx_v_model) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":15
+ *     # SetNG
+ *     def __cinit__(self, SampleConsensusModel model):
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_t(((__pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPtr_t)__pyx_v_model->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":14
+ * 
+ *     # SetNG
+ *     def __cinit__(self, SampleConsensusModel model):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+ *         pass
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":19
+ * 
+ *     # SetNG
+ *     def __cinit__(self, SampleConsensusModelPlane model):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+ *         pass
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_3__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_3__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_v_model = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_model,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_model)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(28, 19, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_model = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(28, 19, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RandomSampleConsensus.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_model), __pyx_ptype_3pcl_4_pcl_SampleConsensusModelPlane, 1, "model", 0))) __PYX_ERR(28, 19, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_2__cinit__(((struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *)__pyx_v_self), __pyx_v_model);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_2__cinit__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_v_model) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":20
+ *     # SetNG
+ *     def __cinit__(self, SampleConsensusModelPlane model):
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_t(((__pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPtr_t)__pyx_v_model->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":19
+ * 
+ *     # SetNG
+ *     def __cinit__(self, SampleConsensusModelPlane model):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+ *         pass
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":23
+ *         pass
+ * 
+ *     def __cinit__(self, SampleConsensusModelSphere model):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+ *         pass
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_5__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_5__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_v_model = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_model,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_model)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(28, 23, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_model = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(28, 23, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RandomSampleConsensus.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_model), __pyx_ptype_3pcl_4_pcl_SampleConsensusModelSphere, 1, "model", 0))) __PYX_ERR(28, 23, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_4__cinit__(((struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *)__pyx_v_self), __pyx_v_model);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_4__cinit__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_v_model) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":24
+ * 
+ *     def __cinit__(self, SampleConsensusModelSphere model):
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_sample_consensus_RandomSampleConsensus_t(((__pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPtr_t)__pyx_v_model->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":23
+ *         pass
+ * 
+ *     def __cinit__(self, SampleConsensusModelSphere model):             # <<<<<<<<<<<<<<
+ *         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+ *         pass
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":55
+ *     #     pass
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_7__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_7__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_6__dealloc__(((struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_6__dealloc__(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":56
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def computeModel(self):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":55
+ *     #     pass
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":58
+ *         del self.me
+ * 
+ *     def computeModel(self):             # <<<<<<<<<<<<<<
+ *         self.me.computeModel(0)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_9computeModel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21RandomSampleConsensus_8computeModel[] = "RandomSampleConsensus.computeModel(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_9computeModel(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("computeModel (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_8computeModel(((struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_8computeModel(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("computeModel", 0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":59
+ * 
+ *     def computeModel(self):
+ *         self.me.computeModel(0)             # <<<<<<<<<<<<<<
+ * 
+ *     # base Class(SampleConsensus)
+ */
+  __pyx_v_self->me->computeModel(0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":58
+ *         del self.me
+ * 
+ *     def computeModel(self):             # <<<<<<<<<<<<<<
+ *         self.me.computeModel(0)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":62
+ * 
+ *     # base Class(SampleConsensus)
+ *     def set_DistanceThreshold(self, double param):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold(param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_11set_DistanceThreshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21RandomSampleConsensus_10set_DistanceThreshold[] = "RandomSampleConsensus.set_DistanceThreshold(self, double param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_11set_DistanceThreshold(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  double __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_DistanceThreshold (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __pyx_PyFloat_AsDouble(__pyx_arg_param); if (unlikely((__pyx_v_param == (double)-1) && PyErr_Occurred())) __PYX_ERR(28, 62, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.RandomSampleConsensus.set_DistanceThreshold", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_10set_DistanceThreshold(((struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *)__pyx_v_self), ((double)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_10set_DistanceThreshold(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self, double __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_DistanceThreshold", 0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":63
+ *     # base Class(SampleConsensus)
+ *     def set_DistanceThreshold(self, double param):
+ *         self.me.setDistanceThreshold(param)             # <<<<<<<<<<<<<<
+ * 
+ *     # base Class(SampleConsensus)
+ */
+  __pyx_v_self->me->setDistanceThreshold(__pyx_v_param);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":62
+ * 
+ *     # base Class(SampleConsensus)
+ *     def set_DistanceThreshold(self, double param):             # <<<<<<<<<<<<<<
+ *         self.me.setDistanceThreshold(param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":66
+ * 
+ *     # base Class(SampleConsensus)
+ *     def get_Inliers(self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] inliers
+ *         self.me.getInliers(inliers)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_13get_Inliers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_21RandomSampleConsensus_12get_Inliers[] = "RandomSampleConsensus.get_Inliers(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_13get_Inliers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_Inliers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_12get_Inliers(((struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_21RandomSampleConsensus_12get_Inliers(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus *__pyx_v_self) {
+  std::vector<int>  __pyx_v_inliers;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_Inliers", 0);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":68
+ *     def get_Inliers(self):
+ *         cdef vector[int] inliers
+ *         self.me.getInliers(inliers)             # <<<<<<<<<<<<<<
+ *         return inliers
+ * 
+ */
+  __pyx_v_self->me->getInliers(__pyx_v_inliers);
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":69
+ *         cdef vector[int] inliers
+ *         self.me.getInliers(inliers)
+ *         return inliers             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_convert_vector_to_py_int(__pyx_v_inliers); if (unlikely(!__pyx_t_1)) __PYX_ERR(28, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi":66
+ * 
+ *     # base Class(SampleConsensus)
+ *     def get_Inliers(self):             # <<<<<<<<<<<<<<
+ *         cdef vector[int] inliers
+ *         self.me.getInliers(inliers)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.RandomSampleConsensus.get_Inliers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi":10
+ *     # cdef pcl_sac.SampleConsensusModelPlane_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # NG
+ *         # self.me = new pcl_sac.SampleConsensusModelPlane_t()
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_25SampleConsensusModelPlane_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_25SampleConsensusModelPlane_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(29, 10, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(29, 10, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SampleConsensusModelPlane.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(29, 10, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25SampleConsensusModelPlane___cinit__(((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_25SampleConsensusModelPlane___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi":15
+ *         # self.me = new pcl_sac.SampleConsensusModelPlane_t(pc.thisptr_shared)
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelPlane[cpp.PointXYZ](pc.thisptr_shared))             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  sp_assign<pcl::SampleConsensusModelPlane<struct pcl::PointXYZ> >(__pyx_v_self->thisptr_shared, new pcl::SampleConsensusModelPlane<struct pcl::PointXYZ> (__pyx_v_pc->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi":10
+ *     # cdef pcl_sac.SampleConsensusModelPlane_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # NG
+ *         # self.me = new pcl_sac.SampleConsensusModelPlane_t()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi":12
+ *     # cdef pcl_sac.SampleConsensusModelSphere_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # NG
+ *         # self.me = new pcl_sac.SampleConsensusModelSphere_t()
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_26SampleConsensusModelSphere_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_26SampleConsensusModelSphere_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(30, 12, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(30, 12, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SampleConsensusModelSphere.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(30, 12, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_26SampleConsensusModelSphere___cinit__(((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_26SampleConsensusModelSphere___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi":19
+ *         # NG
+ *         # sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelSphere_t(pc.thisptr_shared))
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelSphere[cpp.PointXYZ](pc.thisptr_shared))             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  sp_assign<pcl::SampleConsensusModelSphere<struct pcl::PointXYZ> >(__pyx_v_self->thisptr_shared, new pcl::SampleConsensusModelSphere<struct pcl::PointXYZ> (__pyx_v_pc->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi":12
+ *     # cdef pcl_sac.SampleConsensusModelSphere_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # NG
+ *         # self.me = new pcl_sac.SampleConsensusModelSphere_t()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal](pc.thisptr_shared))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_28SampleConsensusModelCylinder_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_28SampleConsensusModelCylinder_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(31, 9, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(31, 9, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SampleConsensusModelCylinder.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(31, 9, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28SampleConsensusModelCylinder___cinit__(((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_28SampleConsensusModelCylinder___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi":11
+ *     def __cinit__(self, PointCloud pc not None):
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal](pc.thisptr_shared))             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  sp_assign<pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal> >(__pyx_v_self->thisptr_shared, new pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal> (__pyx_v_pc->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal](pc.thisptr_shared))
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelLine[cpp.PointXYZ](pc.thisptr_shared))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_24SampleConsensusModelLine_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_24SampleConsensusModelLine_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(32, 9, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(32, 9, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SampleConsensusModelLine.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(32, 9, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_24SampleConsensusModelLine___cinit__(((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_24SampleConsensusModelLine___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi":11
+ *     def __cinit__(self, PointCloud pc not None):
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelLine[cpp.PointXYZ](pc.thisptr_shared))             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  sp_assign<pcl::SampleConsensusModelLine<struct pcl::PointXYZ> >(__pyx_v_self->thisptr_shared, new pcl::SampleConsensusModelLine<struct pcl::PointXYZ> (__pyx_v_pc->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelLine[cpp.PointXYZ](pc.thisptr_shared))
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ](pc.thisptr_shared))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_32SampleConsensusModelRegistration_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_32SampleConsensusModelRegistration_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(33, 9, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(33, 9, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SampleConsensusModelRegistration.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(33, 9, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_32SampleConsensusModelRegistration___cinit__(((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_32SampleConsensusModelRegistration___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi":11
+ *     def __cinit__(self, PointCloud pc not None):
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ](pc.thisptr_shared))             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  sp_assign<pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ> >(__pyx_v_self->thisptr_shared, new pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ> (__pyx_v_pc->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ](pc.thisptr_shared))
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelStick[cpp.PointXYZ](pc.thisptr_shared))
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_25SampleConsensusModelStick_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_25SampleConsensusModelStick_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(34, 9, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(34, 9, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.SampleConsensusModelStick.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(34, 9, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25SampleConsensusModelStick___cinit__(((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_25SampleConsensusModelStick___cinit__(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi":11
+ *     def __cinit__(self, PointCloud pc not None):
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelStick[cpp.PointXYZ](pc.thisptr_shared))             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  sp_assign<pcl::SampleConsensusModelStick<struct pcl::PointXYZ> >(__pyx_v_self->thisptr_shared, new pcl::SampleConsensusModelStick<struct pcl::PointXYZ> (__pyx_v_pc->thisptr_shared));
+
+  /* "pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi":9
+ *     """
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # shared_ptr
+ *         sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelStick[cpp.PointXYZ](pc.thisptr_shared))
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/NormalEstimation_180.pxi":16
+ *     cdef pclftr.NormalEstimation_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclftr.NormalEstimation_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_16NormalEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_16NormalEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16NormalEstimation___cinit__(((struct __pyx_obj_3pcl_4_pcl_NormalEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_16NormalEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":17
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclftr.NormalEstimation_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_16pcl_features_180_NormalEstimation_t();
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":16
+ *     cdef pclftr.NormalEstimation_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclftr.NormalEstimation_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/NormalEstimation_180.pxi":19
+ *         self.me = new pclftr.NormalEstimation_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_16NormalEstimation_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_16NormalEstimation_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_16NormalEstimation_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_NormalEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_16NormalEstimation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":20
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":19
+ *         self.me = new pclftr.NormalEstimation_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Features/NormalEstimation_180.pxi":22
+ *         del self.me
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_5set_SearchMethod(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16NormalEstimation_4set_SearchMethod[] = "NormalEstimation.set_SearchMethod(self, KdTree kdtree)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_5set_SearchMethod(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_SearchMethod (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kdtree), __pyx_ptype_3pcl_4_pcl_KdTree, 1, "kdtree", 0))) __PYX_ERR(35, 22, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16NormalEstimation_4set_SearchMethod(((struct __pyx_obj_3pcl_4_pcl_NormalEstimation *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_KdTree *)__pyx_v_kdtree));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_4set_SearchMethod(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_SearchMethod", 0);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":23
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_RadiusSearch(self, double param):
+ */
+  __pyx_v_self->me->setSearchMethod(__pyx_v_kdtree->thisptr_shared);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":22
+ *         del self.me
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/NormalEstimation_180.pxi":25
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ *     def set_RadiusSearch(self, double param):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusSearch(param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_7set_RadiusSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16NormalEstimation_6set_RadiusSearch[] = "NormalEstimation.set_RadiusSearch(self, double param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_7set_RadiusSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  double __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_RadiusSearch (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __pyx_PyFloat_AsDouble(__pyx_arg_param); if (unlikely((__pyx_v_param == (double)-1) && PyErr_Occurred())) __PYX_ERR(35, 25, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.NormalEstimation.set_RadiusSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16NormalEstimation_6set_RadiusSearch(((struct __pyx_obj_3pcl_4_pcl_NormalEstimation *)__pyx_v_self), ((double)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_6set_RadiusSearch(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self, double __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_RadiusSearch", 0);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":26
+ * 
+ *     def set_RadiusSearch(self, double param):
+ *         self.me.setRadiusSearch(param)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_KSearch (self, int param):
+ */
+  __pyx_v_self->me->setRadiusSearch(__pyx_v_param);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":25
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ *     def set_RadiusSearch(self, double param):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusSearch(param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/NormalEstimation_180.pxi":28
+ *         self.me.setRadiusSearch(param)
+ * 
+ *     def set_KSearch (self, int param):             # <<<<<<<<<<<<<<
+ *         self.me.setKSearch (param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_9set_KSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16NormalEstimation_8set_KSearch[] = "NormalEstimation.set_KSearch(self, int param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_9set_KSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  int __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_KSearch (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __Pyx_PyInt_As_int(__pyx_arg_param); if (unlikely((__pyx_v_param == (int)-1) && PyErr_Occurred())) __PYX_ERR(35, 28, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.NormalEstimation.set_KSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16NormalEstimation_8set_KSearch(((struct __pyx_obj_3pcl_4_pcl_NormalEstimation *)__pyx_v_self), ((int)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_8set_KSearch(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self, int __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_KSearch", 0);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":29
+ * 
+ *     def set_KSearch (self, int param):
+ *         self.me.setKSearch (param)             # <<<<<<<<<<<<<<
+ * 
+ *     def compute(self):
+ */
+  __pyx_v_self->me->setKSearch(__pyx_v_param);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":28
+ *         self.me.setRadiusSearch(param)
+ * 
+ *     def set_KSearch (self, int param):             # <<<<<<<<<<<<<<
+ *         self.me.setKSearch (param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/NormalEstimation_180.pxi":31
+ *         self.me.setKSearch (param)
+ * 
+ *     def compute(self):             # <<<<<<<<<<<<<<
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_11compute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16NormalEstimation_10compute[] = "NormalEstimation.compute(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16NormalEstimation_11compute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("compute (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16NormalEstimation_10compute(((struct __pyx_obj_3pcl_4_pcl_NormalEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16NormalEstimation_10compute(struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *__pyx_v_normal = NULL;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t *__pyx_v_cNormal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("compute", 0);
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":32
+ * 
+ *     def compute(self):
+ *         normal = PointCloud_Normal()             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ *         self.me.compute (deref(cNormal))
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_Normal), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(35, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_normal = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":33
+ *     def compute(self):
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()             # <<<<<<<<<<<<<<
+ *         self.me.compute (deref(cNormal))
+ *         return normal
+ */
+  __pyx_v_cNormal = ((__pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t *)__pyx_f_3pcl_4_pcl_17PointCloud_Normal_thisptr(__pyx_v_normal));
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":34
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ *         self.me.compute (deref(cNormal))             # <<<<<<<<<<<<<<
+ *         return normal
+ * 
+ */
+  __pyx_v_self->me->compute((*__pyx_v_cNormal));
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":35
+ *         cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ *         self.me.compute (deref(cNormal))
+ *         return normal             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_normal));
+  __pyx_r = ((PyObject *)__pyx_v_normal);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Features/NormalEstimation_180.pxi":31
+ *         self.me.setKSearch (param)
+ * 
+ *     def compute(self):             # <<<<<<<<<<<<<<
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.NormalEstimation.compute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_normal);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/VFHEstimation_180.pxi":16
+ *     cdef pclftr.VFHEstimation_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclftr.VFHEstimation_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_13VFHEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_13VFHEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_13VFHEstimation___cinit__(((struct __pyx_obj_3pcl_4_pcl_VFHEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_13VFHEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":17
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclftr.VFHEstimation_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_16pcl_features_180_VFHEstimation_t();
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":16
+ *     cdef pclftr.VFHEstimation_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclftr.VFHEstimation_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/VFHEstimation_180.pxi":19
+ *         self.me = new pclftr.VFHEstimation_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_13VFHEstimation_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_13VFHEstimation_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_13VFHEstimation_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_VFHEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_13VFHEstimation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":20
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":19
+ *         self.me = new pclftr.VFHEstimation_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Features/VFHEstimation_180.pxi":22
+ *         del self.me
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_13VFHEstimation_5set_SearchMethod(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_13VFHEstimation_4set_SearchMethod[] = "VFHEstimation.set_SearchMethod(self, KdTree kdtree)";
+static PyObject *__pyx_pw_3pcl_4_pcl_13VFHEstimation_5set_SearchMethod(PyObject *__pyx_v_self, PyObject *__pyx_v_kdtree) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_SearchMethod (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_kdtree), __pyx_ptype_3pcl_4_pcl_KdTree, 1, "kdtree", 0))) __PYX_ERR(36, 22, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_13VFHEstimation_4set_SearchMethod(((struct __pyx_obj_3pcl_4_pcl_VFHEstimation *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_KdTree *)__pyx_v_kdtree));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_13VFHEstimation_4set_SearchMethod(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_kdtree) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_SearchMethod", 0);
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":23
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_KSearch (self, int param):
+ */
+  __pyx_v_self->me->setSearchMethod(__pyx_v_kdtree->thisptr_shared);
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":22
+ *         del self.me
+ * 
+ *     def set_SearchMethod(self, _pcl.KdTree kdtree):             # <<<<<<<<<<<<<<
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/VFHEstimation_180.pxi":25
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ *     def set_KSearch (self, int param):             # <<<<<<<<<<<<<<
+ *         self.me.setKSearch (param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_13VFHEstimation_7set_KSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_13VFHEstimation_6set_KSearch[] = "VFHEstimation.set_KSearch(self, int param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_13VFHEstimation_7set_KSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  int __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_KSearch (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __Pyx_PyInt_As_int(__pyx_arg_param); if (unlikely((__pyx_v_param == (int)-1) && PyErr_Occurred())) __PYX_ERR(36, 25, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.VFHEstimation.set_KSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_13VFHEstimation_6set_KSearch(((struct __pyx_obj_3pcl_4_pcl_VFHEstimation *)__pyx_v_self), ((int)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_13VFHEstimation_6set_KSearch(struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_self, int __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_KSearch", 0);
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":26
+ * 
+ *     def set_KSearch (self, int param):
+ *         self.me.setKSearch (param)             # <<<<<<<<<<<<<<
+ * 
+ *     # use PointCloud[VFHSignature308]
+ */
+  __pyx_v_self->me->setKSearch(__pyx_v_param);
+
+  /* "pcl/pxi/Features/VFHEstimation_180.pxi":25
+ *         self.me.setSearchMethod(kdtree.thisptr_shared)
+ * 
+ *     def set_KSearch (self, int param):             # <<<<<<<<<<<<<<
+ *         self.me.setKSearch (param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":23
+ *     # cdef pcl_ftr.IntegralImageNormalEstimation_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         print ('__cinit__ start')
+ *         sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(37, 23, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(37, 23, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(37, 23, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation___cinit__(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":24
+ * 
+ *     def __cinit__(self, PointCloud pc not None):
+ *         print ('__cinit__ start')             # <<<<<<<<<<<<<<
+ *         sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())
+ *         # NG : Reference Count
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_cinit___start) < 0) __PYX_ERR(37, 24, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":25
+ *     def __cinit__(self, PointCloud pc not None):
+ *         print ('__cinit__ start')
+ *         sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())             # <<<<<<<<<<<<<<
+ *         # NG : Reference Count
+ *         self.thisptr().setInputCloud(pc.thisptr_shared)
+ */
+  sp_assign<pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal> >(__pyx_v_self->thisptr_shared, new pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal> ());
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":27
+ *         sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())
+ *         # NG : Reference Count
+ *         self.thisptr().setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         print ('__cinit__ end')
+ *         # self.me = new pcl_ftr.IntegralImageNormalEstimation_t()
+ */
+  __pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self)->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":28
+ *         # NG : Reference Count
+ *         self.thisptr().setInputCloud(pc.thisptr_shared)
+ *         print ('__cinit__ end')             # <<<<<<<<<<<<<<
+ *         # self.me = new pcl_ftr.IntegralImageNormalEstimation_t()
+ *         # self.me.setInputCloud(pc.thisptr_shared)
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_cinit___end) < 0) __PYX_ERR(37, 28, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":23
+ *     # cdef pcl_ftr.IntegralImageNormalEstimation_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         print ('__cinit__ start')
+ *         sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":33
+ *         # pass
+ * 
+ *     def set_NormalEstimation_Method_AVERAGE_3D_GRADIENT (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_3set_NormalEstimation_Method_AVERAGE_3D_GRADIENT(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_2set_NormalEstimation_Method_AVERAGE_3D_GRADIENT[] = "IntegralImageNormalEstimation.set_NormalEstimation_Method_AVERAGE_3D_GRADIENT(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_3set_NormalEstimation_Method_AVERAGE_3D_GRADIENT(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_AVERAGE_3D_GRADIENT (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_2set_NormalEstimation_Method_AVERAGE_3D_GRADIENT(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_2set_NormalEstimation_Method_AVERAGE_3D_GRADIENT(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_AVERAGE_3D_GRADIENT", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":34
+ * 
+ *     def set_NormalEstimation_Method_AVERAGE_3D_GRADIENT (self):
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ * 
+ *     def set_NormalEstimation_Method_COVARIANCE_MATRIX (self):
+ */
+  try {
+    mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(((__pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_t)(*__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self))));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(37, 34, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":33
+ *         # pass
+ * 
+ *     def set_NormalEstimation_Method_AVERAGE_3D_GRADIENT (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.set_NormalEstimation_Method_AVERAGE_3D_GRADIENT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":36
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ *     def set_NormalEstimation_Method_COVARIANCE_MATRIX (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_5set_NormalEstimation_Method_COVARIANCE_MATRIX(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_4set_NormalEstimation_Method_COVARIANCE_MATRIX[] = "IntegralImageNormalEstimation.set_NormalEstimation_Method_COVARIANCE_MATRIX(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_5set_NormalEstimation_Method_COVARIANCE_MATRIX(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_COVARIANCE_MATRIX (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_4set_NormalEstimation_Method_COVARIANCE_MATRIX(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_4set_NormalEstimation_Method_COVARIANCE_MATRIX(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_COVARIANCE_MATRIX", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":37
+ * 
+ *     def set_NormalEstimation_Method_COVARIANCE_MATRIX (self):
+ *        mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ * 
+ *     def set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (self):
+ */
+  try {
+    mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(((__pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_t)(*__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self))));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(37, 37, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":36
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ *     def set_NormalEstimation_Method_COVARIANCE_MATRIX (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.set_NormalEstimation_Method_COVARIANCE_MATRIX", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":39
+ *        mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ *     def set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_7set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_6set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE[] = "IntegralImageNormalEstimation.set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_7set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_6set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_6set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":40
+ * 
+ *     def set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (self):
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ * 
+ *     def set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (self):
+ */
+  try {
+    mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(((__pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_t)(*__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self))));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(37, 40, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":39
+ *        mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ *     def set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":42
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ *     def set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_9set_NormalEstimation_Method_SIMPLE_3D_GRADIENT(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_8set_NormalEstimation_Method_SIMPLE_3D_GRADIENT[] = "IntegralImageNormalEstimation.set_NormalEstimation_Method_SIMPLE_3D_GRADIENT(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_9set_NormalEstimation_Method_SIMPLE_3D_GRADIENT(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_8set_NormalEstimation_Method_SIMPLE_3D_GRADIENT(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_8set_NormalEstimation_Method_SIMPLE_3D_GRADIENT(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalEstimation_Method_SIMPLE_3D_GRADIENT", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":43
+ * 
+ *     def set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (self):
+ *        mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ * 
+ *     # enum Set NG
+ */
+  try {
+    mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(((__pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_t)(*__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self))));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(37, 43, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":42
+ *        mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ *     def set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (self):             # <<<<<<<<<<<<<<
+ *        mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.set_NormalEstimation_Method_SIMPLE_3D_GRADIENT", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":49
+ *     #    self.thisptr().setNormalEstimationMethod(pcl_ftr.NormalEstimationMethod2.ESTIMATIONMETHOD_COVARIANCE_MATRIX)
+ * 
+ *     def set_MaxDepthChange_Factor(self, double param):             # <<<<<<<<<<<<<<
+ *         self.thisptr().setMaxDepthChangeFactor(param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_11set_MaxDepthChange_Factor(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_10set_MaxDepthChange_Factor[] = "IntegralImageNormalEstimation.set_MaxDepthChange_Factor(self, double param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_11set_MaxDepthChange_Factor(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  double __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MaxDepthChange_Factor (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __pyx_PyFloat_AsDouble(__pyx_arg_param); if (unlikely((__pyx_v_param == (double)-1) && PyErr_Occurred())) __PYX_ERR(37, 49, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.set_MaxDepthChange_Factor", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_10set_MaxDepthChange_Factor(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self), ((double)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_10set_MaxDepthChange_Factor(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, double __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_MaxDepthChange_Factor", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":50
+ * 
+ *     def set_MaxDepthChange_Factor(self, double param):
+ *         self.thisptr().setMaxDepthChangeFactor(param)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_NormalSmoothingSize(self, double param):
+ */
+  __pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self)->setMaxDepthChangeFactor(__pyx_v_param);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":49
+ *     #    self.thisptr().setNormalEstimationMethod(pcl_ftr.NormalEstimationMethod2.ESTIMATIONMETHOD_COVARIANCE_MATRIX)
+ * 
+ *     def set_MaxDepthChange_Factor(self, double param):             # <<<<<<<<<<<<<<
+ *         self.thisptr().setMaxDepthChangeFactor(param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":52
+ *         self.thisptr().setMaxDepthChangeFactor(param)
+ * 
+ *     def set_NormalSmoothingSize(self, double param):             # <<<<<<<<<<<<<<
+ *         self.thisptr().setNormalSmoothingSize(param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_13set_NormalSmoothingSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_12set_NormalSmoothingSize[] = "IntegralImageNormalEstimation.set_NormalSmoothingSize(self, double param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_13set_NormalSmoothingSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  double __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalSmoothingSize (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __pyx_PyFloat_AsDouble(__pyx_arg_param); if (unlikely((__pyx_v_param == (double)-1) && PyErr_Occurred())) __PYX_ERR(37, 52, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.set_NormalSmoothingSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_12set_NormalSmoothingSize(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self), ((double)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_12set_NormalSmoothingSize(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, double __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NormalSmoothingSize", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":53
+ * 
+ *     def set_NormalSmoothingSize(self, double param):
+ *         self.thisptr().setNormalSmoothingSize(param)             # <<<<<<<<<<<<<<
+ * 
+ *     def compute(self, PointCloud pc not None):
+ */
+  __pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self)->setNormalSmoothingSize(__pyx_v_param);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":52
+ *         self.thisptr().setMaxDepthChangeFactor(param)
+ * 
+ *     def set_NormalSmoothingSize(self, double param):             # <<<<<<<<<<<<<<
+ *         self.thisptr().setNormalSmoothingSize(param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":55
+ *         self.thisptr().setNormalSmoothingSize(param)
+ * 
+ *     def compute(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # cdef PointCloud_PointNormal normal = PointCloud_PointNormal()
+ *         # normal = PointCloud_PointNormal()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_15compute(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_14compute[] = "IntegralImageNormalEstimation.compute(self, PointCloud pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_15compute(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("compute (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(37, 55, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_14compute(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_14compute(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *__pyx_v_normal = NULL;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t *__pyx_v_cPointCloudNormal;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("compute", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":58
+ *         # cdef PointCloud_PointNormal normal = PointCloud_PointNormal()
+ *         # normal = PointCloud_PointNormal()
+ *         normal = PointCloud_Normal()             # <<<<<<<<<<<<<<
+ *         # NG : No Python object
+ *         # normal = PointCloud_Normal(pc)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_Normal), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(37, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_normal = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":61
+ *         # NG : No Python object
+ *         # normal = PointCloud_Normal(pc)
+ *         cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()             # <<<<<<<<<<<<<<
+ *         print ('3')
+ *         # print (str(self.thisptr().size))
+ */
+  __pyx_v_cPointCloudNormal = ((__pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t *)__pyx_f_3pcl_4_pcl_17PointCloud_Normal_thisptr(__pyx_v_normal));
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":62
+ *         # normal = PointCloud_Normal(pc)
+ *         cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ *         print ('3')             # <<<<<<<<<<<<<<
+ *         # print (str(self.thisptr().size))
+ * 
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_3) < 0) __PYX_ERR(37, 62, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":74
+ *         # NG : (Exception)
+ *         # self.thisptr().compute (deref(cPointCloudNormal.makeShared().get()))
+ *         self.thisptr().compute (deref(cPointCloudNormal))             # <<<<<<<<<<<<<<
+ *         print ('4')
+ *         return normal
+ */
+  __pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self)->compute((*__pyx_v_cPointCloudNormal));
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":75
+ *         # self.thisptr().compute (deref(cPointCloudNormal.makeShared().get()))
+ *         self.thisptr().compute (deref(cPointCloudNormal))
+ *         print ('4')             # <<<<<<<<<<<<<<
+ *         return normal
+ * 
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_4) < 0) __PYX_ERR(37, 75, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":76
+ *         self.thisptr().compute (deref(cPointCloudNormal))
+ *         print ('4')
+ *         return normal             # <<<<<<<<<<<<<<
+ * 
+ *     def compute2(self, PointCloud pc not None):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_normal));
+  __pyx_r = ((PyObject *)__pyx_v_normal);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":55
+ *         self.thisptr().setNormalSmoothingSize(param)
+ * 
+ *     def compute(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         # cdef PointCloud_PointNormal normal = PointCloud_PointNormal()
+ *         # normal = PointCloud_PointNormal()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.compute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_normal);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":78
+ *         return normal
+ * 
+ *     def compute2(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_17compute2(PyObject *__pyx_v_self, PyObject *__pyx_v_pc); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_16compute2[] = "IntegralImageNormalEstimation.compute2(self, PointCloud pc)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_17compute2(PyObject *__pyx_v_self, PyObject *__pyx_v_pc) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("compute2 (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(37, 78, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_16compute2(((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_pc));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29IntegralImageNormalEstimation_16compute2(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *__pyx_v_normal = NULL;
+  CYTHON_UNUSED __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t *__pyx_v_cPointCloudNormal;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t __pyx_v_normals;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("compute2", 0);
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":79
+ * 
+ *     def compute2(self, PointCloud pc not None):
+ *         normal = PointCloud_Normal()             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ *         print ('3')
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_Normal), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(37, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_normal = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":80
+ *     def compute2(self, PointCloud pc not None):
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()             # <<<<<<<<<<<<<<
+ *         print ('3')
+ *         # OK
+ */
+  __pyx_v_cPointCloudNormal = ((__pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t *)__pyx_f_3pcl_4_pcl_17PointCloud_Normal_thisptr(__pyx_v_normal));
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":81
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ *         print ('3')             # <<<<<<<<<<<<<<
+ *         # OK
+ *         cdef cpp.PointCloud_Normal_t normals
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_3) < 0) __PYX_ERR(37, 81, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":84
+ *         # OK
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), normals)             # <<<<<<<<<<<<<<
+ *         print ('3a')
+ *         # Copy?
+ */
+  try {
+    mpcl_features_NormalEstimationMethod_compute(((__pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimation_t)(*__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(__pyx_v_self))), __pyx_v_normals);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(37, 84, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":85
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), normals)
+ *         print ('3a')             # <<<<<<<<<<<<<<
+ *         # Copy?
+ *         cPointCloudNormal = normals.makeShared().get()
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_3a) < 0) __PYX_ERR(37, 85, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":87
+ *         print ('3a')
+ *         # Copy?
+ *         cPointCloudNormal = normals.makeShared().get()             # <<<<<<<<<<<<<<
+ *         print ('3b')
+ * 
+ */
+  __pyx_v_cPointCloudNormal = __pyx_v_normals.makeShared().get();
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":88
+ *         # Copy?
+ *         cPointCloudNormal = normals.makeShared().get()
+ *         print ('3b')             # <<<<<<<<<<<<<<
+ * 
+ *         # NG : Normal Pointer Nothing?
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_3b) < 0) __PYX_ERR(37, 88, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":95
+ *         # NG : Normal Pointer Nothing?
+ *         # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal))
+ *         print ('4')             # <<<<<<<<<<<<<<
+ *         return normal
+ * 
+ */
+  if (__Pyx_PrintOne(0, __pyx_kp_s_4) < 0) __PYX_ERR(37, 95, __pyx_L1_error)
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":96
+ *         # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal))
+ *         print ('4')
+ *         return normal             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_normal));
+  __pyx_r = ((PyObject *)__pyx_v_normal);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi":78
+ *         return normal
+ * 
+ *     def compute2(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         normal = PointCloud_Normal()
+ *         cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.IntegralImageNormalEstimation.compute2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_normal);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":26
+ *     # Eigen::Vector3f mass_center;
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclftr.MomentOfInertiaEstimation_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation___cinit__(((struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation___cinit__(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":27
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclftr.MomentOfInertiaEstimation_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_t();
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":26
+ *     # Eigen::Vector3f mass_center;
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclftr.MomentOfInertiaEstimation_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":29
+ *         self.me = new pclftr.MomentOfInertiaEstimation_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":30
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     # feature_extractor.getMomentOfInertia (moment_of_inertia);
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":29
+ *         self.me = new pclftr.MomentOfInertiaEstimation_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":39
+ *     # feature_extractor.getEigenVectors (major_vector, middle_vector, minor_vector);
+ *     # feature_extractor.getMassCenter (mass_center);
+ *     def get_MomentOfInertia (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[float] moment_of_inertia
+ *         self.me.getMomentOfInertia(moment_of_inertia)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_5get_MomentOfInertia(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_4get_MomentOfInertia[] = "MomentOfInertiaEstimation.get_MomentOfInertia(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_5get_MomentOfInertia(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_MomentOfInertia (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_4get_MomentOfInertia(((struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_4get_MomentOfInertia(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self) {
+  std::vector<float>  __pyx_v_moment_of_inertia;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_MomentOfInertia", 0);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":41
+ *     def get_MomentOfInertia (self):
+ *         cdef vector[float] moment_of_inertia
+ *         self.me.getMomentOfInertia(moment_of_inertia)             # <<<<<<<<<<<<<<
+ *         return moment_of_inertia
+ * 
+ */
+  __pyx_v_self->me->getMomentOfInertia(__pyx_v_moment_of_inertia);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":42
+ *         cdef vector[float] moment_of_inertia
+ *         self.me.getMomentOfInertia(moment_of_inertia)
+ *         return moment_of_inertia             # <<<<<<<<<<<<<<
+ * 
+ *     def get_Eccentricity (self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_convert_vector_to_py_float(__pyx_v_moment_of_inertia); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":39
+ *     # feature_extractor.getEigenVectors (major_vector, middle_vector, minor_vector);
+ *     # feature_extractor.getMassCenter (mass_center);
+ *     def get_MomentOfInertia (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[float] moment_of_inertia
+ *         self.me.getMomentOfInertia(moment_of_inertia)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.MomentOfInertiaEstimation.get_MomentOfInertia", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":44
+ *         return moment_of_inertia
+ * 
+ *     def get_Eccentricity (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[float] eccentricity
+ *         self.me.getEccentricity(eccentricity)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_7get_Eccentricity(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_6get_Eccentricity[] = "MomentOfInertiaEstimation.get_Eccentricity(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_7get_Eccentricity(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_Eccentricity (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_6get_Eccentricity(((struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_6get_Eccentricity(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self) {
+  std::vector<float>  __pyx_v_eccentricity;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_Eccentricity", 0);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":46
+ *     def get_Eccentricity (self):
+ *         cdef vector[float] eccentricity
+ *         self.me.getEccentricity(eccentricity)             # <<<<<<<<<<<<<<
+ *         return eccentricity
+ * 
+ */
+  __pyx_v_self->me->getEccentricity(__pyx_v_eccentricity);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":47
+ *         cdef vector[float] eccentricity
+ *         self.me.getEccentricity(eccentricity)
+ *         return eccentricity             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __pyx_convert_vector_to_py_float(__pyx_v_eccentricity); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":44
+ *         return moment_of_inertia
+ * 
+ *     def get_Eccentricity (self):             # <<<<<<<<<<<<<<
+ *         cdef vector[float] eccentricity
+ *         self.me.getEccentricity(eccentricity)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.MomentOfInertiaEstimation.get_Eccentricity", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":50
+ * 
+ *     @cython.boundscheck(False)
+ *     def get_AABB (self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZ min_point_AABB
+ *         cdef cpp.PointXYZ max_point_AABB
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_9get_AABB(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_8get_AABB[] = "MomentOfInertiaEstimation.get_AABB(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_9get_AABB(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_AABB (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_8get_AABB(((struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_8get_AABB(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self) {
+  struct pcl::PointXYZ __pyx_v_min_point_AABB;
+  struct pcl::PointXYZ __pyx_v_max_point_AABB;
+  npy_intp __pyx_v_n;
+  PyObject *__pyx_v_result1 = NULL;
+  npy_intp __pyx_v_i;
+  PyObject *__pyx_v_result2 = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  npy_intp __pyx_t_6;
+  npy_intp __pyx_t_7;
+  __Pyx_RefNannySetupContext("get_AABB", 0);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":53
+ *         cdef cpp.PointXYZ min_point_AABB
+ *         cdef cpp.PointXYZ max_point_AABB
+ *         self.me.getAABB (min_point_AABB, max_point_AABB)             # <<<<<<<<<<<<<<
+ *         # return min_point_AABB, max_point_AABB
+ * 
+ */
+  __pyx_v_self->me->getAABB(__pyx_v_min_point_AABB, __pyx_v_max_point_AABB);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":56
+ *         # return min_point_AABB, max_point_AABB
+ * 
+ *         cdef cnp.npy_intp n = 1             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ * 
+ */
+  __pyx_v_n = 1;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":59
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ * 
+ *         result1 = np.empty((n, 3), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             result1[i, 0] = min_point_AABB.x
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_3);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_result1 = __pyx_t_5;
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":60
+ * 
+ *         result1 = np.empty((n, 3), dtype=np.float32)
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             result1[i, 0] = min_point_AABB.x
+ *             result1[i, 1] = min_point_AABB.y
+ */
+  __pyx_t_6 = __pyx_v_n;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":61
+ *         result1 = np.empty((n, 3), dtype=np.float32)
+ *         for i in range(n):
+ *             result1[i, 0] = min_point_AABB.x             # <<<<<<<<<<<<<<
+ *             result1[i, 1] = min_point_AABB.y
+ *             result1[i, 2] = min_point_AABB.z
+ */
+    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_min_point_AABB.x); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 61, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 61, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 61, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_GIVEREF(__pyx_int_0);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_0);
+    __pyx_t_3 = 0;
+    if (unlikely(PyObject_SetItem(__pyx_v_result1, __pyx_t_1, __pyx_t_5) < 0)) __PYX_ERR(38, 61, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":62
+ *         for i in range(n):
+ *             result1[i, 0] = min_point_AABB.x
+ *             result1[i, 1] = min_point_AABB.y             # <<<<<<<<<<<<<<
+ *             result1[i, 2] = min_point_AABB.z
+ * 
+ */
+    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_min_point_AABB.y); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 62, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 62, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 62, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_1);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+    __Pyx_INCREF(__pyx_int_1);
+    __Pyx_GIVEREF(__pyx_int_1);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_1);
+    __pyx_t_1 = 0;
+    if (unlikely(PyObject_SetItem(__pyx_v_result1, __pyx_t_3, __pyx_t_5) < 0)) __PYX_ERR(38, 62, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":63
+ *             result1[i, 0] = min_point_AABB.x
+ *             result1[i, 1] = min_point_AABB.y
+ *             result1[i, 2] = min_point_AABB.z             # <<<<<<<<<<<<<<
+ * 
+ *         result2 = np.empty((n, 3), dtype=np.float32)
+ */
+    __pyx_t_5 = PyFloat_FromDouble(__pyx_v_min_point_AABB.z); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 63, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_2);
+    __pyx_t_3 = 0;
+    if (unlikely(PyObject_SetItem(__pyx_v_result1, __pyx_t_1, __pyx_t_5) < 0)) __PYX_ERR(38, 63, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  }
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":65
+ *             result1[i, 2] = min_point_AABB.z
+ * 
+ *         result2 = np.empty((n, 3), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             result2[i, 0] = max_point_AABB.x
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_3);
+  __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_v_result2 = __pyx_t_4;
+  __pyx_t_4 = 0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":66
+ * 
+ *         result2 = np.empty((n, 3), dtype=np.float32)
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             result2[i, 0] = max_point_AABB.x
+ *             result2[i, 1] = max_point_AABB.y
+ */
+  __pyx_t_6 = __pyx_v_n;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":67
+ *         result2 = np.empty((n, 3), dtype=np.float32)
+ *         for i in range(n):
+ *             result2[i, 0] = max_point_AABB.x             # <<<<<<<<<<<<<<
+ *             result2[i, 1] = max_point_AABB.y
+ *             result2[i, 2] = max_point_AABB.z
+ */
+    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_point_AABB.x); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+    __Pyx_INCREF(__pyx_int_0);
+    __Pyx_GIVEREF(__pyx_int_0);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_0);
+    __pyx_t_3 = 0;
+    if (unlikely(PyObject_SetItem(__pyx_v_result2, __pyx_t_5, __pyx_t_4) < 0)) __PYX_ERR(38, 67, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":68
+ *         for i in range(n):
+ *             result2[i, 0] = max_point_AABB.x
+ *             result2[i, 1] = max_point_AABB.y             # <<<<<<<<<<<<<<
+ *             result2[i, 2] = max_point_AABB.z
+ * 
+ */
+    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_point_AABB.y); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_5 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5);
+    __Pyx_INCREF(__pyx_int_1);
+    __Pyx_GIVEREF(__pyx_int_1);
+    PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_1);
+    __pyx_t_5 = 0;
+    if (unlikely(PyObject_SetItem(__pyx_v_result2, __pyx_t_3, __pyx_t_4) < 0)) __PYX_ERR(38, 68, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":69
+ *             result2[i, 0] = max_point_AABB.x
+ *             result2[i, 1] = max_point_AABB.y
+ *             result2[i, 2] = max_point_AABB.z             # <<<<<<<<<<<<<<
+ * 
+ *         return result1, result2
+ */
+    __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_point_AABB.z); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 69, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 69, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(38, 69, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
+    __Pyx_INCREF(__pyx_int_2);
+    __Pyx_GIVEREF(__pyx_int_2);
+    PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_2);
+    __pyx_t_3 = 0;
+    if (unlikely(PyObject_SetItem(__pyx_v_result2, __pyx_t_5, __pyx_t_4) < 0)) __PYX_ERR(38, 69, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":71
+ *             result2[i, 2] = max_point_AABB.z
+ * 
+ *         return result1, result2             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 71, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_v_result1);
+  __Pyx_GIVEREF(__pyx_v_result1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_result1);
+  __Pyx_INCREF(__pyx_v_result2);
+  __Pyx_GIVEREF(__pyx_v_result2);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_result2);
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":50
+ * 
+ *     @cython.boundscheck(False)
+ *     def get_AABB (self):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZ min_point_AABB
+ *         cdef cpp.PointXYZ max_point_AABB
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.MomentOfInertiaEstimation.get_AABB", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_result1);
+  __Pyx_XDECREF(__pyx_v_result2);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":82
+ *     #   return min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB
+ * 
+ *     def get_EigenValues (self):             # <<<<<<<<<<<<<<
+ *         cdef float major_value = 0.0
+ *         cdef float middle_value = 0.0
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_11get_EigenValues(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_10get_EigenValues[] = "MomentOfInertiaEstimation.get_EigenValues(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_11get_EigenValues(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_EigenValues (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_10get_EigenValues(((struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_25MomentOfInertiaEstimation_10get_EigenValues(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_self) {
+  float __pyx_v_major_value;
+  float __pyx_v_middle_value;
+  float __pyx_v_minor_value;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("get_EigenValues", 0);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":83
+ * 
+ *     def get_EigenValues (self):
+ *         cdef float major_value = 0.0             # <<<<<<<<<<<<<<
+ *         cdef float middle_value = 0.0
+ *         cdef float minor_value = 0.0
+ */
+  __pyx_v_major_value = 0.0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":84
+ *     def get_EigenValues (self):
+ *         cdef float major_value = 0.0
+ *         cdef float middle_value = 0.0             # <<<<<<<<<<<<<<
+ *         cdef float minor_value = 0.0
+ *         self.me.getEigenValues (major_value, middle_value, minor_value)
+ */
+  __pyx_v_middle_value = 0.0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":85
+ *         cdef float major_value = 0.0
+ *         cdef float middle_value = 0.0
+ *         cdef float minor_value = 0.0             # <<<<<<<<<<<<<<
+ *         self.me.getEigenValues (major_value, middle_value, minor_value)
+ *         return major_value, middle_value, minor_value
+ */
+  __pyx_v_minor_value = 0.0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":86
+ *         cdef float middle_value = 0.0
+ *         cdef float minor_value = 0.0
+ *         self.me.getEigenValues (major_value, middle_value, minor_value)             # <<<<<<<<<<<<<<
+ *         return major_value, middle_value, minor_value
+ * 
+ */
+  __pyx_v_self->me->getEigenValues(__pyx_v_major_value, __pyx_v_middle_value, __pyx_v_minor_value);
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":87
+ *         cdef float minor_value = 0.0
+ *         self.me.getEigenValues (major_value, middle_value, minor_value)
+ *         return major_value, middle_value, minor_value             # <<<<<<<<<<<<<<
+ * 
+ *     # def get_EigenVectors (self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_major_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(38, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_middle_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(38, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_minor_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(38, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(38, 87, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3);
+  __pyx_t_1 = 0;
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi":82
+ *     #   return min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB
+ * 
+ *     def get_EigenValues (self):             # <<<<<<<<<<<<<<
+ *         cdef float major_value = 0.0
+ *         cdef float middle_value = 0.0
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.MomentOfInertiaEstimation.get_EigenValues", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":28
+ *     cdef keypt.HarrisKeypoint3D_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new keypt.HarrisKeypoint3D_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pc,0};
+    PyObject* values[1] = {0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pc)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(39, 28, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 1) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+    }
+    __pyx_v_pc = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)values[0]);
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(39, 28, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.HarrisKeypoint3D.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pc), __pyx_ptype_3pcl_4_pcl_PointCloud, 0, "pc", 0))) __PYX_ERR(39, 28, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D___cinit__(((struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *)__pyx_v_self), __pyx_v_pc);
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D___cinit__(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_pc) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":29
+ * 
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new keypt.HarrisKeypoint3D_t()             # <<<<<<<<<<<<<<
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ *         # pass
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_17pcl_keypoints_180_HarrisKeypoint3D_t();
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":30
+ *     def __cinit__(self, PointCloud pc not None):
+ *         self.me = new keypt.HarrisKeypoint3D_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         # pass
+ * 
+ */
+  __pyx_v_self->me->setInputCloud(__pyx_v_pc->thisptr_shared);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":28
+ *     cdef keypt.HarrisKeypoint3D_t *me
+ * 
+ *     def __cinit__(self, PointCloud pc not None):             # <<<<<<<<<<<<<<
+ *         self.me = new keypt.HarrisKeypoint3D_t()
+ *         self.me.setInputCloud(pc.thisptr_shared)
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":33
+ *         # pass
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":34
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     def set_NonMaxSupression(self, bool param):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":33
+ *         # pass
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":36
+ *         del self.me
+ * 
+ *     def set_NonMaxSupression(self, bool param):             # <<<<<<<<<<<<<<
+ *         self.me.setNonMaxSupression (param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_5set_NonMaxSupression(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_4set_NonMaxSupression[] = "HarrisKeypoint3D.set_NonMaxSupression(self, bool param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_5set_NonMaxSupression(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  bool __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NonMaxSupression (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __Pyx_PyObject_IsTrue(__pyx_arg_param); if (unlikely((__pyx_v_param == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(39, 36, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.HarrisKeypoint3D.set_NonMaxSupression", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_4set_NonMaxSupression(((struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *)__pyx_v_self), ((bool)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_4set_NonMaxSupression(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, bool __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_NonMaxSupression", 0);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":37
+ * 
+ *     def set_NonMaxSupression(self, bool param):
+ *         self.me.setNonMaxSupression (param)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_Radius(self, float param):
+ */
+  __pyx_v_self->me->setNonMaxSupression(__pyx_v_param);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":36
+ *         del self.me
+ * 
+ *     def set_NonMaxSupression(self, bool param):             # <<<<<<<<<<<<<<
+ *         self.me.setNonMaxSupression (param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":39
+ *         self.me.setNonMaxSupression (param)
+ * 
+ *     def set_Radius(self, float param):             # <<<<<<<<<<<<<<
+ *         self.me.setRadius (param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_7set_Radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_6set_Radius[] = "HarrisKeypoint3D.set_Radius(self, float param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_7set_Radius(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  float __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Radius (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __pyx_PyFloat_AsFloat(__pyx_arg_param); if (unlikely((__pyx_v_param == (float)-1) && PyErr_Occurred())) __PYX_ERR(39, 39, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.HarrisKeypoint3D.set_Radius", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_6set_Radius(((struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *)__pyx_v_self), ((float)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_6set_Radius(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, float __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Radius", 0);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":40
+ * 
+ *     def set_Radius(self, float param):
+ *         self.me.setRadius (param)             # <<<<<<<<<<<<<<
+ * 
+ *     def set_RadiusSearch(self, double param):
+ */
+  __pyx_v_self->me->setRadius(__pyx_v_param);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":39
+ *         self.me.setNonMaxSupression (param)
+ * 
+ *     def set_Radius(self, float param):             # <<<<<<<<<<<<<<
+ *         self.me.setRadius (param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":42
+ *         self.me.setRadius (param)
+ * 
+ *     def set_RadiusSearch(self, double param):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusSearch (param)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_9set_RadiusSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_8set_RadiusSearch[] = "HarrisKeypoint3D.set_RadiusSearch(self, double param)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_9set_RadiusSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_param) {
+  double __pyx_v_param;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_RadiusSearch (wrapper)", 0);
+  assert(__pyx_arg_param); {
+    __pyx_v_param = __pyx_PyFloat_AsDouble(__pyx_arg_param); if (unlikely((__pyx_v_param == (double)-1) && PyErr_Occurred())) __PYX_ERR(39, 42, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.HarrisKeypoint3D.set_RadiusSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_8set_RadiusSearch(((struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *)__pyx_v_self), ((double)__pyx_v_param));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_8set_RadiusSearch(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self, double __pyx_v_param) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_RadiusSearch", 0);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":43
+ * 
+ *     def set_RadiusSearch(self, double param):
+ *         self.me.setRadiusSearch (param)             # <<<<<<<<<<<<<<
+ * 
+ *     def compute(self):
+ */
+  __pyx_v_self->me->setRadiusSearch(__pyx_v_param);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":42
+ *         self.me.setRadius (param)
+ * 
+ *     def set_RadiusSearch(self, double param):             # <<<<<<<<<<<<<<
+ *         self.me.setRadiusSearch (param)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":45
+ *         self.me.setRadiusSearch (param)
+ * 
+ *     def compute(self):             # <<<<<<<<<<<<<<
+ *         # compute function based KeyPoint class
+ *         # self.thisptr().compute (deref(cPointCloudPointXYZI.makeShared().get()))
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_11compute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_10compute[] = "HarrisKeypoint3D.compute(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_11compute(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("compute (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_10compute(((struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_16HarrisKeypoint3D_10compute(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_keypoints = NULL;
+  __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZI_t *__pyx_v_ckeypoints;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("compute", 0);
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":50
+ *         ###
+ *         # OK : data 0
+ *         keypoints = PointCloud_PointXYZI()             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointCloud_PointXYZI_t *ckeypoints = <cpp.PointCloud_PointXYZI_t*>keypoints.thisptr()
+ *         # self.me.compute (<cpp.PointCloud[cpp.PointXYZI]> deref(ckeypoints.makeShared().get()))
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(39, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_keypoints = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":51
+ *         # OK : data 0
+ *         keypoints = PointCloud_PointXYZI()
+ *         cdef cpp.PointCloud_PointXYZI_t *ckeypoints = <cpp.PointCloud_PointXYZI_t*>keypoints.thisptr()             # <<<<<<<<<<<<<<
+ *         # self.me.compute (<cpp.PointCloud[cpp.PointXYZI]> deref(ckeypoints.makeShared().get()))
+ *         # pcl.1.7.2
+ */
+  __pyx_v_ckeypoints = ((__pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZI_t *)__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_keypoints));
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":54
+ *         # self.me.compute (<cpp.PointCloud[cpp.PointXYZI]> deref(ckeypoints.makeShared().get()))
+ *         # pcl.1.7.2
+ *         self.me.compute (<cpp.PointCloud[cpp.PointXYZI]&> deref(ckeypoints.makeShared().get()))             # <<<<<<<<<<<<<<
+ *         # self.me.compute (ckeypoints.makeShared().get())
+ *         print('keypoints.count : ' + str(keypoints.size))
+ */
+  __pyx_v_self->me->compute(((pcl::PointCloud<struct pcl::PointXYZI>  &)(*__pyx_v_ckeypoints->makeShared().get())));
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":56
+ *         self.me.compute (<cpp.PointCloud[cpp.PointXYZI]&> deref(ckeypoints.makeShared().get()))
+ *         # self.me.compute (ckeypoints.makeShared().get())
+ *         print('keypoints.count : ' + str(keypoints.size))             # <<<<<<<<<<<<<<
+ *         return keypoints
+ * 
+ */
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_keypoints), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(39, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(39, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(39, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyNumber_Add(__pyx_kp_s_keypoints_count, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(39, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  if (__Pyx_PrintOne(0, __pyx_t_2) < 0) __PYX_ERR(39, 56, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":57
+ *         # self.me.compute (ckeypoints.makeShared().get())
+ *         print('keypoints.count : ' + str(keypoints.size))
+ *         return keypoints             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_keypoints));
+  __pyx_r = ((PyObject *)__pyx_v_keypoints);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi":45
+ *         self.me.setRadiusSearch (param)
+ * 
+ *     def compute(self):             # <<<<<<<<<<<<<<
+ *         # compute function based KeyPoint class
+ *         # self.thisptr().compute (deref(cPointCloudPointXYZI.makeShared().get()))
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.HarrisKeypoint3D.compute", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_keypoints);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":12
+ *     cdef pclreg.NormalDistributionsTransform_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclreg.NormalDistributionsTransform_t()
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
+    __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
+  if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform___cinit__(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform___cinit__(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":13
+ * 
+ *     def __cinit__(self):
+ *         self.me = new pclreg.NormalDistributionsTransform_t()             # <<<<<<<<<<<<<<
+ * 
+ *     def __dealloc__(self):
+ */
+  __pyx_v_self->me = new __pyx_t_3pcl_20pcl_registration_180_NormalDistributionsTransform_t();
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":12
+ *     cdef pclreg.NormalDistributionsTransform_t *me
+ * 
+ *     def __cinit__(self):             # <<<<<<<<<<<<<<
+ *         self.me = new pclreg.NormalDistributionsTransform_t()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":15
+ *         self.me = new pclreg.NormalDistributionsTransform_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+/* Python wrapper */
+static void __pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
+static void __pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_3__dealloc__(PyObject *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_2__dealloc__(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_2__dealloc__(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__dealloc__", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":16
+ * 
+ *     def __dealloc__(self):
+ *         del self.me             # <<<<<<<<<<<<<<
+ * 
+ *     # def set_InputTarget(self, pclreg.RegistrationPtr_t cloud):
+ */
+  delete __pyx_v_self->me;
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":15
+ *         self.me = new pclreg.NormalDistributionsTransform_t()
+ * 
+ *     def __dealloc__(self):             # <<<<<<<<<<<<<<
+ *         del self.me
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":19
+ * 
+ *     # def set_InputTarget(self, pclreg.RegistrationPtr_t cloud):
+ *     def set_InputTarget(self):             # <<<<<<<<<<<<<<
+ *         # self.me.setInputTarget (cloud.this_ptr())
+ *         pass
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_5set_InputTarget(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_4set_InputTarget[] = "NormalDistributionsTransform.set_InputTarget(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_5set_InputTarget(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputTarget (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_4set_InputTarget(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_4set_InputTarget(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_InputTarget", 0);
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":23
+ *         pass
+ * 
+ *     def set_Resolution(self, float resolution):             # <<<<<<<<<<<<<<
+ *         self.me.setResolution(resolution)
+ *         pass
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_7set_Resolution(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_6set_Resolution[] = "NormalDistributionsTransform.set_Resolution(self, float resolution)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_7set_Resolution(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution) {
+  float __pyx_v_resolution;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Resolution (wrapper)", 0);
+  assert(__pyx_arg_resolution); {
+    __pyx_v_resolution = __pyx_PyFloat_AsFloat(__pyx_arg_resolution); if (unlikely((__pyx_v_resolution == (float)-1) && PyErr_Occurred())) __PYX_ERR(40, 23, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.set_Resolution", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_6set_Resolution(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self), ((float)__pyx_v_resolution));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_6set_Resolution(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self, float __pyx_v_resolution) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_Resolution", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":24
+ * 
+ *     def set_Resolution(self, float resolution):
+ *         self.me.setResolution(resolution)             # <<<<<<<<<<<<<<
+ *         pass
+ * 
+ */
+  __pyx_v_self->me->setResolution(__pyx_v_resolution);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":23
+ *         pass
+ * 
+ *     def set_Resolution(self, float resolution):             # <<<<<<<<<<<<<<
+ *         self.me.setResolution(resolution)
+ *         pass
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":27
+ *         pass
+ * 
+ *     def get_Resolution(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getResolution()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_9get_Resolution(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_8get_Resolution[] = "NormalDistributionsTransform.get_Resolution(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_9get_Resolution(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_Resolution (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_8get_Resolution(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_8get_Resolution(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_Resolution", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":28
+ * 
+ *     def get_Resolution(self):
+ *         return self.me.getResolution()             # <<<<<<<<<<<<<<
+ * 
+ *     def get_StepSize(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getResolution()); if (unlikely(!__pyx_t_1)) __PYX_ERR(40, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":27
+ *         pass
+ * 
+ *     def get_Resolution(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getResolution()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.get_Resolution", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":30
+ *         return self.me.getResolution()
+ * 
+ *     def get_StepSize(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getStepSize()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_11get_StepSize(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_10get_StepSize[] = "NormalDistributionsTransform.get_StepSize(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_11get_StepSize(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_StepSize (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_10get_StepSize(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_10get_StepSize(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_StepSize", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":31
+ * 
+ *     def get_StepSize(self):
+ *         return self.me.getStepSize()             # <<<<<<<<<<<<<<
+ * 
+ *     def set_StepSize(self, double step_size):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getStepSize()); if (unlikely(!__pyx_t_1)) __PYX_ERR(40, 31, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":30
+ *         return self.me.getResolution()
+ * 
+ *     def get_StepSize(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getStepSize()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.get_StepSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":33
+ *         return self.me.getStepSize()
+ * 
+ *     def set_StepSize(self, double step_size):             # <<<<<<<<<<<<<<
+ *         self.me.setStepSize(step_size)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_13set_StepSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_step_size); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_12set_StepSize[] = "NormalDistributionsTransform.set_StepSize(self, double step_size)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_13set_StepSize(PyObject *__pyx_v_self, PyObject *__pyx_arg_step_size) {
+  double __pyx_v_step_size;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_StepSize (wrapper)", 0);
+  assert(__pyx_arg_step_size); {
+    __pyx_v_step_size = __pyx_PyFloat_AsDouble(__pyx_arg_step_size); if (unlikely((__pyx_v_step_size == (double)-1) && PyErr_Occurred())) __PYX_ERR(40, 33, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.set_StepSize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_12set_StepSize(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self), ((double)__pyx_v_step_size));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_12set_StepSize(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self, double __pyx_v_step_size) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_StepSize", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":34
+ * 
+ *     def set_StepSize(self, double step_size):
+ *         self.me.setStepSize(step_size)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_OulierRatio(self):
+ */
+  __pyx_v_self->me->setStepSize(__pyx_v_step_size);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":33
+ *         return self.me.getStepSize()
+ * 
+ *     def set_StepSize(self, double step_size):             # <<<<<<<<<<<<<<
+ *         self.me.setStepSize(step_size)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":36
+ *         self.me.setStepSize(step_size)
+ * 
+ *     def get_OulierRatio(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getOulierRatio()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_15get_OulierRatio(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_14get_OulierRatio[] = "NormalDistributionsTransform.get_OulierRatio(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_15get_OulierRatio(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_OulierRatio (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_14get_OulierRatio(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_14get_OulierRatio(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_OulierRatio", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":37
+ * 
+ *     def get_OulierRatio(self):
+ *         return self.me.getOulierRatio()             # <<<<<<<<<<<<<<
+ * 
+ *     def set_OulierRatio(self, double outlier_ratio):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getOulierRatio()); if (unlikely(!__pyx_t_1)) __PYX_ERR(40, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":36
+ *         self.me.setStepSize(step_size)
+ * 
+ *     def get_OulierRatio(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getOulierRatio()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.get_OulierRatio", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":39
+ *         return self.me.getOulierRatio()
+ * 
+ *     def set_OulierRatio(self, double outlier_ratio):             # <<<<<<<<<<<<<<
+ *         self.me.setOulierRatio(outlier_ratio)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_17set_OulierRatio(PyObject *__pyx_v_self, PyObject *__pyx_arg_outlier_ratio); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_16set_OulierRatio[] = "NormalDistributionsTransform.set_OulierRatio(self, double outlier_ratio)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_17set_OulierRatio(PyObject *__pyx_v_self, PyObject *__pyx_arg_outlier_ratio) {
+  double __pyx_v_outlier_ratio;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_OulierRatio (wrapper)", 0);
+  assert(__pyx_arg_outlier_ratio); {
+    __pyx_v_outlier_ratio = __pyx_PyFloat_AsDouble(__pyx_arg_outlier_ratio); if (unlikely((__pyx_v_outlier_ratio == (double)-1) && PyErr_Occurred())) __PYX_ERR(40, 39, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.set_OulierRatio", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_16set_OulierRatio(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self), ((double)__pyx_v_outlier_ratio));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_16set_OulierRatio(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self, double __pyx_v_outlier_ratio) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("set_OulierRatio", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":40
+ * 
+ *     def set_OulierRatio(self, double outlier_ratio):
+ *         self.me.setOulierRatio(outlier_ratio)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_TransformationProbability(self):
+ */
+  __pyx_v_self->me->setOulierRatio(__pyx_v_outlier_ratio);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":39
+ *         return self.me.getOulierRatio()
+ * 
+ *     def set_OulierRatio(self, double outlier_ratio):             # <<<<<<<<<<<<<<
+ *         self.me.setOulierRatio(outlier_ratio)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":42
+ *         self.me.setOulierRatio(outlier_ratio)
+ * 
+ *     def get_TransformationProbability(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getTransformationProbability()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_19get_TransformationProbability(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_18get_TransformationProbability[] = "NormalDistributionsTransform.get_TransformationProbability(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_19get_TransformationProbability(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_TransformationProbability (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_18get_TransformationProbability(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_18get_TransformationProbability(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_TransformationProbability", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":43
+ * 
+ *     def get_TransformationProbability(self):
+ *         return self.me.getTransformationProbability()             # <<<<<<<<<<<<<<
+ * 
+ *     def get_FinalNumIteration(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->me->getTransformationProbability()); if (unlikely(!__pyx_t_1)) __PYX_ERR(40, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":42
+ *         self.me.setOulierRatio(outlier_ratio)
+ * 
+ *     def get_TransformationProbability(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getTransformationProbability()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.get_TransformationProbability", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":45
+ *         return self.me.getTransformationProbability()
+ * 
+ *     def get_FinalNumIteration(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getFinalNumIteration()
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_21get_FinalNumIteration(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_20get_FinalNumIteration[] = "NormalDistributionsTransform.get_FinalNumIteration(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_21get_FinalNumIteration(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_FinalNumIteration (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_20get_FinalNumIteration(((struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_28NormalDistributionsTransform_20get_FinalNumIteration(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("get_FinalNumIteration", 0);
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":46
+ * 
+ *     def get_FinalNumIteration(self):
+ *         return self.me.getFinalNumIteration()             # <<<<<<<<<<<<<<
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->me->getFinalNumIteration()); if (unlikely(!__pyx_t_1)) __PYX_ERR(40, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/registration/NormalDistributionsTransform_180.pxi":45
+ *         return self.me.getTransformationProbability()
+ * 
+ *     def get_FinalNumIteration(self):             # <<<<<<<<<<<<<<
+ *         return self.me.getFinalNumIteration()
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.NormalDistributionsTransform.get_FinalNumIteration", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":63
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud other
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_10PointCloud_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_10PointCloud_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_init = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_init,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_init);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(3, 63, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_init = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 63, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud___cinit__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), __pyx_v_init);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_10PointCloud___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyObject *__pyx_v_init) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_other = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  pcl::PointCloud<struct pcl::PointXYZ>  *__pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":66
+ *         cdef PointCloud other
+ * 
+ *         self._view_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+ */
+  __pyx_v_self->_view_count = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":70
+ *         # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+ *         # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())             # <<<<<<<<<<<<<<
+ * 
+ *         if init is None:
+ */
+  try {
+    __pyx_t_1 = new pcl::PointCloud<struct pcl::PointXYZ> ();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 70, __pyx_L1_error)
+  }
+  sp_assign<pcl::PointCloud<struct pcl::PointXYZ> >(__pyx_v_self->thisptr_shared, __pyx_t_1);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":72
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  __pyx_t_2 = (__pyx_v_init == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":73
+ * 
+ *         if init is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":72
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":74
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Integral); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_integer); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); 
+  __pyx_t_7 = (__pyx_t_2 != 0);
+  if (!__pyx_t_7) {
+  } else {
+    __pyx_t_3 = __pyx_t_7;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_7 = PyObject_IsInstance(__pyx_v_init, __pyx_t_6); 
+  __pyx_t_2 = (__pyx_t_7 != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":75
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 75, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 75, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 75, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 75, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 75, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":74
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":76
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_init, __pyx_ptype_5numpy_ndarray); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":77
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 77, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_8) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 77, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 77, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 77, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 77, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 77, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":76
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":78
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(3, 78, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":79
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_list); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 79, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 79, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 79, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 79, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 79, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 79, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":78
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":80
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(3, 80, __pyx_L1_error)
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":81
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ *             other = init             # <<<<<<<<<<<<<<
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ */
+    if (!(likely(((__pyx_v_init) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_init, __pyx_ptype_3pcl_4_pcl_PointCloud))))) __PYX_ERR(3, 81, __pyx_L1_error)
+    __pyx_t_5 = __pyx_v_init;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_v_other = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":82
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ */
+    (__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)[0]) = (__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_other)[0]);
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":80
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":84
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+  /*else*/ {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":85
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ *                             % type(init))             # <<<<<<<<<<<<<<
+ * 
+ *     property width:
+ */
+    __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, ((PyObject *)Py_TYPE(__pyx_v_init))); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 85, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":84
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+    __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 84, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 84, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(3, 84, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":63
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud other
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_other);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":89
+ *     property width:
+ *         """ property containing the width of the point cloud """
+ *         def __get__(self): return self.thisptr().width             # <<<<<<<<<<<<<<
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_5width_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_5width_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_5width___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->width); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.width.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":92
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ *         def __get__(self): return self.thisptr().height             # <<<<<<<<<<<<<<
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_6height_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_6height_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_6height___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->height); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.height.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":95
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ *         def __get__(self): return self.thisptr().size()             # <<<<<<<<<<<<<<
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_4size_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_4size___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 95, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":98
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ *         def __get__(self): return self.thisptr().is_dense             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_8is_dense_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_8is_dense_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_8is_dense___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->is_dense); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.is_dense.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":100
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_2__repr__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":101
+ * 
+ *     def __repr__(self):
+ *         return "<PointCloud of %d points>" % self.size             # <<<<<<<<<<<<<<
+ * 
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_PointCloud_of_d_points, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 101, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":100
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":105
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_10PointCloud_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_10PointCloud_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_4__getbuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_10PointCloud_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags) {
+  Py_ssize_t __pyx_v_npoints;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  struct pcl::PointXYZ *__pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_buffer != NULL) {
+    __pyx_v_buffer->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_buffer->obj);
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":107
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._view_count == 0:
+ */
+  __pyx_v_npoints = __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":109
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":110
+ * 
+ *         if self._view_count == 0:
+ *             self._view_count += 1             # <<<<<<<<<<<<<<
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 3
+ */
+    __pyx_v_self->_view_count = (__pyx_v_self->_view_count + 1);
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":111
+ *         if self._view_count == 0:
+ *             self._view_count += 1
+ *             self._shape[0] = npoints             # <<<<<<<<<<<<<<
+ *             self._shape[1] = 3
+ * 
+ */
+    (__pyx_v_self->_shape[0]) = __pyx_v_npoints;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":112
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 3             # <<<<<<<<<<<<<<
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ */
+    (__pyx_v_self->_shape[1]) = 3;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":109
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":114
+ *             self._shape[1] = 3
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)             # <<<<<<<<<<<<<<
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ */
+  try {
+    __pyx_t_2 = getptr_at<struct pcl::PointXYZ>(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self), 0);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 114, __pyx_L1_error)
+  }
+  __pyx_v_buffer->buf = ((char *)(&__pyx_t_2->x));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":115
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'             # <<<<<<<<<<<<<<
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ */
+  __pyx_v_buffer->format = ((char *)"f");
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":116
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL             # <<<<<<<<<<<<<<
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 3 * sizeof(float)
+ */
+  __pyx_v_buffer->internal = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":117
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.len = npoints * 3 * sizeof(float)
+ *         buffer.ndim = 2
+ */
+  __pyx_v_buffer->itemsize = (sizeof(float));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":118
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 3 * sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ */
+  __pyx_v_buffer->len = ((__pyx_v_npoints * 3) * (sizeof(float)));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":119
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 3 * sizeof(float)
+ *         buffer.ndim = 2             # <<<<<<<<<<<<<<
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ */
+  __pyx_v_buffer->ndim = 2;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":120
+ *         buffer.len = npoints * 3 * sizeof(float)
+ *         buffer.ndim = 2
+ *         buffer.obj = self             # <<<<<<<<<<<<<<
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  __Pyx_GOTREF(__pyx_v_buffer->obj);
+  __Pyx_DECREF(__pyx_v_buffer->obj);
+  __pyx_v_buffer->obj = ((PyObject *)__pyx_v_self);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":121
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ *         buffer.readonly = 0             # <<<<<<<<<<<<<<
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides
+ */
+  __pyx_v_buffer->readonly = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":122
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape             # <<<<<<<<<<<<<<
+ *         buffer.strides = _strides
+ *         buffer.suboffsets = NULL
+ */
+  __pyx_t_3 = __pyx_v_self->_shape;
+  __pyx_v_buffer->shape = __pyx_t_3;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":123
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides             # <<<<<<<<<<<<<<
+ *         buffer.suboffsets = NULL
+ * 
+ */
+  __pyx_v_buffer->strides = __pyx_v_3pcl_4_pcl__strides;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":124
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides
+ *         buffer.suboffsets = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ */
+  __pyx_v_buffer->suboffsets = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":105
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_buffer->obj);
+    __Pyx_DECREF(__pyx_v_buffer->obj); __pyx_v_buffer->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_buffer->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":126
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_10PointCloud_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_10PointCloud_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_10PointCloud_6__releasebuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_10PointCloud_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":127
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ *         self._view_count -= 1             # <<<<<<<<<<<<<<
+ * 
+ *     # Pickle support. XXX this copies the entire pointcloud; it would be nice
+ */
+  __pyx_v_self->_view_count = (__pyx_v_self->_view_count - 1);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":126
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":132
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_8__reduce__[] = "PointCloud.__reduce__(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_8__reduce__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__reduce__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":133
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):
+ *         return type(self), (self.to_array(),)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_origin:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 133, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 133, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 133, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":132
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":136
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_13sensor_origin_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_13sensor_origin_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_13sensor_origin___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  Eigen::Vector4f __pyx_v_origin;
+  float *__pyx_v_data;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Vector4f __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":137
+ *     property sensor_origin:
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_             # <<<<<<<<<<<<<<
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->sensor_origin_;
+  __pyx_v_origin = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":138
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()             # <<<<<<<<<<<<<<
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)
+ */
+  __pyx_v_data = __pyx_v_origin.data();
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":139
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble((__pyx_v_data[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyFloat_FromDouble((__pyx_v_data[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble((__pyx_v_data[2])); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble((__pyx_v_data[3])); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyList_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_7, 3, __pyx_t_6);
+  __pyx_t_2 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":140
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_orientation:
+ */
+  __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 140, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 140, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 140, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(3, 140, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":139
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 139, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":136
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.sensor_origin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":143
+ * 
+ *     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_
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_18sensor_orientation_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_18sensor_orientation_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_18sensor_orientation___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  Eigen::Quaternionf __pyx_v_o;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Quaternionf __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":145
+ *         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()])
+ * 
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->sensor_orientation_;
+  __pyx_v_o = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":146
+ *             # 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()])             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_o.w()); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_o.x()); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_o.y()); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_o.z()); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyList_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyList_SET_ITEM(__pyx_t_8, 3, __pyx_t_7);
+  __pyx_t_3 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (!__pyx_t_7) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 146, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_8);
+      __pyx_t_8 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":143
+ * 
+ *     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_
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.sensor_orientation.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":149
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_10from_array[] = "PointCloud.from_array(self, ndarray arr)\n\n        Fill this object from a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_array (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arr), __pyx_ptype_5numpy_ndarray, 0, "arr", 0))) __PYX_ERR(3, 149, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_10from_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((PyArrayObject *)__pyx_v_arr));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyArrayObject *__pyx_v_arr) {
+  npy_intp __pyx_v_npts;
+  struct pcl::PointXYZ *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_arr;
+  __Pyx_Buffer __pyx_pybuffer_arr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  npy_intp __pyx_t_6;
+  npy_intp __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  __pyx_t_5numpy_float32_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  __pyx_t_5numpy_float32_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  __pyx_t_5numpy_float32_t __pyx_t_16;
+  __Pyx_RefNannySetupContext("from_array", 0);
+  __pyx_pybuffer_arr.pybuffer.buf = NULL;
+  __pyx_pybuffer_arr.refcount = 0;
+  __pyx_pybuffernd_arr.data = NULL;
+  __pyx_pybuffernd_arr.rcbuffer = &__pyx_pybuffer_arr;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arr.rcbuffer->pybuffer, (PyObject*)__pyx_v_arr, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(3, 149, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_arr.diminfo[0].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arr.diminfo[0].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_arr.diminfo[1].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_arr.diminfo[1].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[1];
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":153
+ *         Fill this object from a 2D numpy array (float32)
+ *         """
+ *         assert arr.shape[1] == 3             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!(((__pyx_v_arr->dimensions[1]) == 3) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(3, 153, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":155
+ *         assert arr.shape[1] == 3
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ */
+  __pyx_v_npts = (__pyx_v_arr->dimensions[0]);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":156
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_npts); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 156, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 156, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 156, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 156, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 156, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":157
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ * 
+ */
+  __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":158
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cpp.PointXYZ *p
+ */
+  __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":161
+ * 
+ *         cdef cpp.PointXYZ *p
+ *         for i in range(npts):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+ */
+  __pyx_t_6 = __pyx_v_npts;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":162
+ *         cdef cpp.PointXYZ *p
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+ * 
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZ>(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":163
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_t_9 = 0;
+    if (__pyx_t_8 < 0) __pyx_t_8 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_9 < 0) __pyx_t_9 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_10 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = 1;
+    if (__pyx_t_11 < 0) __pyx_t_11 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_12 < 0) __pyx_t_12 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_13 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 2;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_16 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_v_p->x = __pyx_t_10;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_16;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":149
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.from_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":166
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_12to_array[] = "PointCloud.to_array(self)\n\n        Return this object as a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_array (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_12to_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  npy_intp __pyx_v_n;
+  PyArrayObject *__pyx_v_result = 0;
+  struct pcl::PointXYZ *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_result;
+  __Pyx_Buffer __pyx_pybuffer_result;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  npy_intp __pyx_t_11;
+  npy_intp __pyx_t_12;
+  float __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  Py_ssize_t __pyx_t_19;
+  __Pyx_RefNannySetupContext("to_array", 0);
+  __pyx_pybuffer_result.pybuffer.buf = NULL;
+  __pyx_pybuffer_result.refcount = 0;
+  __pyx_pybuffernd_result.data = NULL;
+  __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":171
+ *         """
+ *         cdef float x,y,z
+ *         cdef cnp.npy_intp n = self.thisptr().size()             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ *         cdef cpp.PointXYZ *p
+ */
+  __pyx_v_n = __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":175
+ *         cdef cpp.PointXYZ *p
+ * 
+ *         result = np.empty((n, 3), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_3);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 175, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(3, 175, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+    __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_7 < 0)) {
+      PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      }
+    }
+    __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_result.diminfo[1].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_result.diminfo[1].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(3, 175, __pyx_L1_error)
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_result = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":176
+ * 
+ *         result = np.empty((n, 3), dtype=np.float32)
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ */
+  __pyx_t_11 = __pyx_v_n;
+  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":177
+ *         result = np.empty((n, 3), dtype=np.float32)
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZ>(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":178
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x             # <<<<<<<<<<<<<<
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ */
+    __pyx_t_13 = __pyx_v_p->x;
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 0;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":179
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y             # <<<<<<<<<<<<<<
+ *             result[i, 2] = p.z
+ * 
+ */
+    __pyx_t_13 = __pyx_v_p->y;
+    __pyx_t_16 = __pyx_v_i;
+    __pyx_t_17 = 1;
+    if (__pyx_t_16 < 0) __pyx_t_16 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":180
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z             # <<<<<<<<<<<<<<
+ * 
+ *         return result
+ */
+    __pyx_t_13 = __pyx_v_p->z;
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_19 = 2;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_19 < 0) __pyx_t_19 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_19, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":182
+ *             result[i, 2] = p.z
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     def from_list(self, _list):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":166
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":184
+ *         return result
+ * 
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_14from_list[] = "PointCloud.from_list(self, _list)\n\n        Fill this pointcloud from a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_14from_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((PyObject *)__pyx_v__list));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyObject *__pyx_v__list) {
+  Py_ssize_t __pyx_v_npts;
+  struct pcl::PointXYZ *__pyx_v_p;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_l = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *(*__pyx_t_10)(PyObject *);
+  float __pyx_t_11;
+  float __pyx_t_12;
+  float __pyx_t_13;
+  __Pyx_RefNannySetupContext("from_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":188
+ *         Fill this pointcloud from a list of 3-tuples
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v__list); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(3, 188, __pyx_L1_error)
+  __pyx_v_npts = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":189
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_npts); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 189, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 189, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 189, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 189, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 189, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 189, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":190
+ *         cdef Py_ssize_t npts = len(_list)
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ *         cdef cpp.PointXYZ* p
+ */
+  __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":191
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZ* p
+ *         # OK
+ */
+  __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":196
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z = l
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v__list)) || PyTuple_CheckExact(__pyx_v__list)) {
+    __pyx_t_3 = __pyx_v__list; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v__list); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 196, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 196, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(3, 196, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 196, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(3, 196, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 196, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      }
+    } else {
+      __pyx_t_6 = __pyx_t_7(__pyx_t_3);
+      if (unlikely(!__pyx_t_6)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(3, 196, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_6);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 196, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_6;
+    __pyx_t_6 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":197
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)             # <<<<<<<<<<<<<<
+ *              p.x, p.y, p.z = l
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 197, __pyx_L1_error)
+    __pyx_v_p = getptr<struct pcl::PointXYZ>(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self), ((int)__pyx_t_8));
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":198
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z = l             # <<<<<<<<<<<<<<
+ * 
+ *     def to_list(self):
+ */
+    if ((likely(PyTuple_CheckExact(__pyx_v_l))) || (PyList_CheckExact(__pyx_v_l))) {
+      PyObject* sequence = __pyx_v_l;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 3)) {
+        if (size > 3) __Pyx_RaiseTooManyValuesError(3);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(3, 198, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2); 
+      } else {
+        __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyList_GET_ITEM(sequence, 2); 
+      }
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      #else
+      __pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 198, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 198, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_5 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 198, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      #endif
+    } else {
+      Py_ssize_t index = -1;
+      __pyx_t_9 = PyObject_GetIter(__pyx_v_l); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 198, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_9);
+      __pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
+      index = 0; __pyx_t_6 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_6);
+      index = 1; __pyx_t_4 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_4)) goto __pyx_L5_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_4);
+      index = 2; __pyx_t_5 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed;
+      __Pyx_GOTREF(__pyx_t_5);
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 3) < 0) __PYX_ERR(3, 198, __pyx_L1_error)
+      __pyx_t_10 = NULL;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      goto __pyx_L6_unpacking_done;
+      __pyx_L5_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+      __pyx_t_10 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(3, 198, __pyx_L1_error)
+      __pyx_L6_unpacking_done:;
+    }
+    __pyx_t_11 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_11 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 198, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_12 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_12 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 198, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_13 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_13 == (float)-1) && PyErr_Occurred())) __PYX_ERR(3, 198, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_v_p->x = __pyx_t_11;
+    __pyx_v_p->y = __pyx_t_12;
+    __pyx_v_p->z = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":196
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z = l
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":184
+ *         return result
+ * 
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.from_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_l);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":200
+ *              p.x, p.y, p.z = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_16to_list[] = "PointCloud.to_list(self)\n\n        Return this object as a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_16to_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("to_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":204
+ *         Return this object as a list of 3-tuples
+ *         """
+ *         return self.to_array().tolist()             # <<<<<<<<<<<<<<
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 204, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 204, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 204, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 204, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 204, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":200
+ *              p.x, p.y, p.z = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.to_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":206
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_18resize[] = "PointCloud.resize(self, npy_intp x)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x) {
+  npy_intp __pyx_v_x;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
+  assert(__pyx_arg_x); {
+    __pyx_v_x = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_x); if (unlikely((__pyx_v_x == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(3, 206, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_18resize(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((npy_intp)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, npy_intp __pyx_v_x) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("resize", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":207
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":208
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 208, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(3, 208, __pyx_L1_error)
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":207
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":210
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+ */
+  try {
+    __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)->resize(__pyx_v_x);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 210, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":206
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":212
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_20get_point[] = "PointCloud.get_point(self, npy_intp row, npy_intp col)\n\n        Return a point (3-tuple) at the given row/column\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  npy_intp __pyx_v_row;
+  npy_intp __pyx_v_col;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_col,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_row)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_col)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, 1); __PYX_ERR(3, 212, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_point") < 0)) __PYX_ERR(3, 212, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_row = __Pyx_PyInt_As_Py_intptr_t(values[0]); if (unlikely((__pyx_v_row == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(3, 212, __pyx_L3_error)
+    __pyx_v_col = __Pyx_PyInt_As_Py_intptr_t(values[1]); if (unlikely((__pyx_v_col == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(3, 212, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 212, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_20get_point(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), __pyx_v_row, __pyx_v_col);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col) {
+  struct pcl::PointXYZ *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZ *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("get_point", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":216
+ *         Return a point (3-tuple) at the given row/column
+ *         """
+ *         cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at2<struct pcl::PointXYZ>(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self), __pyx_v_row, __pyx_v_col);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 216, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":217
+ *         """
+ *         cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)
+ *         return p.x, p.y, p.z             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 217, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":212
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":219
+ *         return p.x, p.y, p.z
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx) {
+  npy_intp __pyx_v_nmidx;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  assert(__pyx_arg_nmidx); {
+    __pyx_v_nmidx = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_nmidx); if (unlikely((__pyx_v_nmidx == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(3, 219, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_22__getitem__(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((npy_intp)__pyx_v_nmidx));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, npy_intp __pyx_v_nmidx) {
+  struct pcl::PointXYZ *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZ *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":220
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at<struct pcl::PointXYZ>(__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self), __pyx_v_nmidx);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 220, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":221
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z             # <<<<<<<<<<<<<<
+ * 
+ *     def from_file(self, char *f):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 221, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_4);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_5;
+  __pyx_t_5 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":219
+ *         return p.x, p.y, p.z
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":223
+ *         return p.x, p.y, p.z
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_24from_file[] = "PointCloud.from_file(self, char *f)\n\n        Fill this pointcloud from a file (a local path).\n        Only pcd files supported currently.\n        \n        Deprecated; use pcl.load instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  char *__pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_file (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __Pyx_PyObject_AsString(__pyx_arg_f); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(3, 223, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_24from_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((char *)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char *__pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("from_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":230
+ *         Deprecated; use pcl.load instead.
+ *         """
+ *         return self._from_pcd_file(f)             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 230, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 230, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 230, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 230, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 230, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":223
+ *         return p.x, p.y, p.z
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":232
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_26_from_pcd_file[] = "PointCloud._from_pcd_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_pcd_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(3, 232, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_26_from_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_error;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":233
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":234
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":237
+ *             # NG
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *         return error
+ * 
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(3, 237, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPCDFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(3, 237, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":234
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":238
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_ply_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":232
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":240
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_28_from_ply_file[] = "PointCloud._from_ply_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_ply_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(3, 240, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_28_from_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_ok;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":241
+ * 
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  __pyx_v_ok = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":242
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":245
+ *             # NG
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *         return ok
+ * 
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(3, 245, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPLYFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(3, 245, __pyx_L4_error)
+        }
+        __pyx_v_ok = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":242
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":246
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *         return ok             # <<<<<<<<<<<<<<
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_ok); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 246, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":240
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":248
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_30to_file[] = "PointCloud.to_file(self, const char *fname, bool ascii=True)\nSave pointcloud to a file in PCD format.\n\n        Deprecated: use pcl.save instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_fname;
+  bool __pyx_v_ascii;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fname,&__pyx_n_s_ascii,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fname)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ascii);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "to_file") < 0)) __PYX_ERR(3, 248, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_fname = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_fname) && PyErr_Occurred())) __PYX_ERR(3, 248, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_ascii = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_ascii == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 248, __pyx_L3_error)
+    } else {
+      __pyx_v_ascii = ((bool)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("to_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 248, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_30to_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), __pyx_v_fname, __pyx_v_ascii);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("to_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":253
+ *         Deprecated: use pcl.save instead.
+ *         """
+ *         return self._to_pcd_file(fname, not ascii)             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_fname); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyBool_FromLong((!(__pyx_v_ascii != 0))); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 253, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 253, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 253, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 253, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_5) {
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 253, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":248
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":255
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_32_to_pcd_file[] = "PointCloud._to_pcd_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_pcd_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_pcd_file") < 0)) __PYX_ERR(3, 255, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(3, 255, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 255, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_pcd_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 255, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_32_to_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":256
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":257
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 257, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":258
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":262
+ *             # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+ *             # OK
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *             # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()
+ *             # error = pclio.savePCDFile(s, p, binary)
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePCDFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(3, 262, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":258
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":265
+ *             # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()
+ *             # error = pclio.savePCDFile(s, p, binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 265, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":255
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":267
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_34_to_ply_file[] = "PointCloud._to_ply_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_ply_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_ply_file") < 0)) __PYX_ERR(3, 267, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(3, 267, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 267, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_ply_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 267, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_34_to_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":268
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":269
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 269, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":270
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":273
+ *             # NG
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *         return error
+ * 
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePLYFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(3, 273, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":270
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":274
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 274, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":267
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":276
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_36make_segmenter[] = "PointCloud.make_segmenter(self)\n\n        Return a pcl.Segmentation object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_36make_segmenter(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_Segmentation *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":280
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ *         """
+ *         seg = Segmentation()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_Segmentation), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 280, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_Segmentation *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":281
+ *         """
+ *         seg = Segmentation()
+ *         cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":282
+ *         seg = Segmentation()
+ *         cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":283
+ *         cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":276
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_segmenter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":285
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_38make_segmenter_normals[] = "PointCloud.make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0)\n\n        Return a pcl.SegmentationNormal object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_v_ksearch;
+  double __pyx_v_searchRadius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter_normals (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksearch,&__pyx_n_s_searchRadius,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ksearch);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_searchRadius);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_segmenter_normals") < 0)) __PYX_ERR(3, 285, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    if (values[0]) {
+      __pyx_v_ksearch = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_ksearch == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 285, __pyx_L3_error)
+    } else {
+      __pyx_v_ksearch = ((int)-1);
+    }
+    if (values[1]) {
+      __pyx_v_searchRadius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_searchRadius == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 285, __pyx_L3_error)
+    } else {
+      __pyx_v_searchRadius = ((double)-1.0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("make_segmenter_normals", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 285, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_38make_segmenter_normals(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), __pyx_v_ksearch, __pyx_v_searchRadius);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius) {
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t __pyx_v_normals;
+  struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter_normals", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":290
+ *         """
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         mpcl_compute_normals(<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), ksearch, searchRadius, normals)             # <<<<<<<<<<<<<<
+ *         seg = SegmentationNormal()
+ *         cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me
+ */
+  try {
+    mpcl_compute_normals(((pcl::PointCloud<struct pcl::PointXYZ> )(*__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_self))), __pyx_v_ksearch, __pyx_v_searchRadius, __pyx_v_normals);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 290, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":291
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         mpcl_compute_normals(<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), ksearch, searchRadius, normals)
+ *         seg = SegmentationNormal()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_SegmentationNormal), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 291, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_SegmentationNormal *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":292
+ *         mpcl_compute_normals(<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), ksearch, searchRadius, normals)
+ *         seg = SegmentationNormal()
+ *         cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":293
+ *         seg = SegmentationNormal()
+ *         cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":294
+ *         cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputNormals(__pyx_v_normals.makeShared());
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":295
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_statistical_outlier_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":285
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":297
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_40make_statistical_outlier_filter[] = "PointCloud.make_statistical_outlier_filter(self)\n\n        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_40make_statistical_outlier_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":304
+ *         # cdef pclfil.StatisticalOutlierRemoval_t *cfil = <pclfil.StatisticalOutlierRemoval_t *>fil.me
+ *         # cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return StatisticalOutlierRemovalFilter(self)             # <<<<<<<<<<<<<<
+ * 
+ *     def make_voxel_grid_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 304, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 304, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":297
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_statistical_outlier_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":306
+ *         return StatisticalOutlierRemovalFilter(self)
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_42make_voxel_grid_filter[] = "PointCloud.make_voxel_grid_filter(self)\n\n        Return a pcl.VoxelGridFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_42make_voxel_grid_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":310
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ *         """
+ *         fil = VoxelGridFilter()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_VoxelGridFilter), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 310, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":311
+ *         """
+ *         fil = VoxelGridFilter()
+ *         cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_VoxelGrid_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":312
+ *         fil = VoxelGridFilter()
+ *         cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":313
+ *         cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_ApproximateVoxelGrid(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":306
+ *         return StatisticalOutlierRemovalFilter(self)
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_voxel_grid_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":315
+ *         return fil
+ * 
+ *     def make_ApproximateVoxelGrid(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ApproximateVoxelGrid object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_45make_ApproximateVoxelGrid(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_44make_ApproximateVoxelGrid[] = "PointCloud.make_ApproximateVoxelGrid(self)\n\n        Return a pcl.ApproximateVoxelGrid object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_45make_ApproximateVoxelGrid(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_ApproximateVoxelGrid (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_44make_ApproximateVoxelGrid(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_44make_ApproximateVoxelGrid(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_ApproximateVoxelGrid", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":319
+ *         Return a pcl.ApproximateVoxelGrid object with this object set as the input-cloud
+ *         """
+ *         fil = ApproximateVoxelGrid()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.ApproximateVoxelGrid_t *cfil = <pclfil.ApproximateVoxelGrid_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 319, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":320
+ *         """
+ *         fil = ApproximateVoxelGrid()
+ *         cdef pclfil.ApproximateVoxelGrid_t *cfil = <pclfil.ApproximateVoxelGrid_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_ApproximateVoxelGrid_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":321
+ *         fil = ApproximateVoxelGrid()
+ *         cdef pclfil.ApproximateVoxelGrid_t *cfil = <pclfil.ApproximateVoxelGrid_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":322
+ *         cdef pclfil.ApproximateVoxelGrid_t *cfil = <pclfil.ApproximateVoxelGrid_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_passthrough_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":315
+ *         return fil
+ * 
+ *     def make_ApproximateVoxelGrid(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ApproximateVoxelGrid object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_ApproximateVoxelGrid", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":324
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_47make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_46make_passthrough_filter[] = "PointCloud.make_passthrough_filter(self)\n\n        Return a pcl.PassThroughFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_47make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_passthrough_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_46make_passthrough_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_46make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_PassThrough_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_passthrough_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":328
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ *         """
+ *         fil = PassThroughFilter()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PassThroughFilter), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 328, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":329
+ *         """
+ *         fil = PassThroughFilter()
+ *         cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_PassThrough_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":330
+ *         fil = PassThroughFilter()
+ *         cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":331
+ *         cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_moving_least_squares(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":324
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_passthrough_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":333
+ *         return fil
+ * 
+ *     def make_moving_least_squares(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_49make_moving_least_squares(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_48make_moving_least_squares[] = "PointCloud.make_moving_least_squares(self)\n\n        Return a pcl.MovingLeastSquares object with this object as input cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_49make_moving_least_squares(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_moving_least_squares (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_48make_moving_least_squares(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_48make_moving_least_squares(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *__pyx_v_mls = NULL;
+  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_t *__pyx_v_cmls;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_moving_least_squares", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":337
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ *         """
+ *         mls = MovingLeastSquares()             # <<<<<<<<<<<<<<
+ *         cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_MovingLeastSquares), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 337, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_mls = ((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":338
+ *         """
+ *         mls = MovingLeastSquares()
+ *         cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me             # <<<<<<<<<<<<<<
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return mls
+ */
+  __pyx_v_cmls = ((__pyx_t_3pcl_11pcl_surface_MovingLeastSquares_t *)__pyx_v_mls->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":339
+ *         mls = MovingLeastSquares()
+ *         cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return mls
+ * 
+ */
+  __pyx_v_cmls->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":340
+ *         cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return mls             # <<<<<<<<<<<<<<
+ * 
+ *     def make_kdtree(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_mls));
+  __pyx_r = ((PyObject *)__pyx_v_mls);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":333
+ *         return fil
+ * 
+ *     def make_moving_least_squares(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_moving_least_squares", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_mls);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":342
+ *         return mls
+ * 
+ *     def make_kdtree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTree object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_51make_kdtree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_50make_kdtree[] = "PointCloud.make_kdtree(self)\n\n        Return a pcl.kdTree object with this object set as the input-cloud\n        \n        Deprecated: use the pcl.KdTree constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_51make_kdtree(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_kdtree (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_50make_kdtree(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_50make_kdtree(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_kdtree", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":348
+ *         Deprecated: use the pcl.KdTree constructor on this cloud.
+ *         """
+ *         return KdTree(self)             # <<<<<<<<<<<<<<
+ * 
+ *     def make_kdtree_flann(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 348, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_KdTree), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 348, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":342
+ *         return mls
+ * 
+ *     def make_kdtree(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTree object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_kdtree", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":350
+ *         return KdTree(self)
+ * 
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_53make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_52make_kdtree_flann[] = "PointCloud.make_kdtree_flann(self)\n\n        Return a pcl.kdTreeFLANN object with this object set as the input-cloud\n        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_53make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_kdtree_flann (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_52make_kdtree_flann(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_52make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_kdtree_flann", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":355
+ *         Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+ *         """
+ *         return KdTreeFLANN(self)             # <<<<<<<<<<<<<<
+ * 
+ *     def make_octree(self, double resolution):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_KdTreeFLANN), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 355, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":350
+ *         return KdTree(self)
+ * 
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_kdtree_flann", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":357
+ *         return KdTreeFLANN(self)
+ * 
+ *     def make_octree(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.octree object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_55make_octree(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_54make_octree[] = "PointCloud.make_octree(self, double resolution)\n\n        Return a pcl.octree object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_55make_octree(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution) {
+  double __pyx_v_resolution;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_octree (wrapper)", 0);
+  assert(__pyx_arg_resolution); {
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(__pyx_arg_resolution); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 357, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_octree", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_54make_octree(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((double)__pyx_v_resolution));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_54make_octree(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, double __pyx_v_resolution) {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *__pyx_v_octree = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("make_octree", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":361
+ *         Return a pcl.octree object with this object set as the input-cloud
+ *         """
+ *         octree = OctreePointCloud(resolution)             # <<<<<<<<<<<<<<
+ *         octree.set_input_cloud(self)
+ *         return octree
+ */
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 361, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 361, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_OctreePointCloud), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 361, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_octree = ((struct __pyx_obj_3pcl_4_pcl_OctreePointCloud *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":362
+ *         """
+ *         octree = OctreePointCloud(resolution)
+ *         octree.set_input_cloud(self)             # <<<<<<<<<<<<<<
+ *         return octree
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_octree), __pyx_n_s_set_input_cloud); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 362, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 362, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 362, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 362, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 362, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, ((PyObject *)__pyx_v_self));
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 362, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":363
+ *         octree = OctreePointCloud(resolution)
+ *         octree.set_input_cloud(self)
+ *         return octree             # <<<<<<<<<<<<<<
+ * 
+ *     def make_octreeSearch(self, double resolution):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_octree));
+  __pyx_r = ((PyObject *)__pyx_v_octree);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":357
+ *         return KdTreeFLANN(self)
+ * 
+ *     def make_octree(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.octree object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_octree", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_octree);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":365
+ *         return octree
+ * 
+ *     def make_octreeSearch(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.make_octreeSearch object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_57make_octreeSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_56make_octreeSearch[] = "PointCloud.make_octreeSearch(self, double resolution)\n\n        Return a pcl.make_octreeSearch object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_57make_octreeSearch(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution) {
+  double __pyx_v_resolution;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_octreeSearch (wrapper)", 0);
+  assert(__pyx_arg_resolution); {
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(__pyx_arg_resolution); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 365, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_octreeSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_56make_octreeSearch(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((double)__pyx_v_resolution));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_56make_octreeSearch(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, double __pyx_v_resolution) {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *__pyx_v_octreeSearch = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("make_octreeSearch", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":369
+ *         Return a pcl.make_octreeSearch object with this object set as the input-cloud
+ *         """
+ *         octreeSearch = OctreePointCloudSearch(resolution)             # <<<<<<<<<<<<<<
+ *         octreeSearch.set_input_cloud(self)
+ *         return octreeSearch
+ */
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 369, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 369, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 369, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_octreeSearch = ((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":370
+ *         """
+ *         octreeSearch = OctreePointCloudSearch(resolution)
+ *         octreeSearch.set_input_cloud(self)             # <<<<<<<<<<<<<<
+ *         return octreeSearch
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_octreeSearch), __pyx_n_s_set_input_cloud); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 370, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 370, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 370, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 370, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 370, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, ((PyObject *)__pyx_v_self));
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 370, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":371
+ *         octreeSearch = OctreePointCloudSearch(resolution)
+ *         octreeSearch.set_input_cloud(self)
+ *         return octreeSearch             # <<<<<<<<<<<<<<
+ * 
+ *     # pcl 1.7.2, 1.8.0 (octree_pointcloud_changedetector.h(->octree_pointcloud.h) include headerfile comment octree2buf_base.h)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_octreeSearch));
+  __pyx_r = ((PyObject *)__pyx_v_octreeSearch);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":365
+ *         return octree
+ * 
+ *     def make_octreeSearch(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.make_octreeSearch object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_octreeSearch", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_octreeSearch);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":374
+ * 
+ *     # pcl 1.7.2, 1.8.0 (octree_pointcloud_changedetector.h(->octree_pointcloud.h) include headerfile comment octree2buf_base.h)
+ *     def make_octreeChangeDetector(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.make_octreeSearch object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_59make_octreeChangeDetector(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_58make_octreeChangeDetector[] = "PointCloud.make_octreeChangeDetector(self, double resolution)\n\n        Return a pcl.make_octreeSearch object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_59make_octreeChangeDetector(PyObject *__pyx_v_self, PyObject *__pyx_arg_resolution) {
+  double __pyx_v_resolution;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_octreeChangeDetector (wrapper)", 0);
+  assert(__pyx_arg_resolution); {
+    __pyx_v_resolution = __pyx_PyFloat_AsDouble(__pyx_arg_resolution); if (unlikely((__pyx_v_resolution == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 374, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_octreeChangeDetector", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_58make_octreeChangeDetector(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((double)__pyx_v_resolution));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_58make_octreeChangeDetector(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, double __pyx_v_resolution) {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *__pyx_v_octreeChangeDetector = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("make_octreeChangeDetector", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":378
+ *         Return a pcl.make_octreeSearch object with this object set as the input-cloud
+ *         """
+ *         octreeChangeDetector = OctreePointCloudChangeDetector(resolution)             # <<<<<<<<<<<<<<
+ *         octreeChangeDetector.set_input_cloud(self)
+ *         return octreeChangeDetector
+ */
+  __pyx_t_1 = PyFloat_FromDouble(__pyx_v_resolution); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 378, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_octreeChangeDetector = ((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":379
+ *         """
+ *         octreeChangeDetector = OctreePointCloudChangeDetector(resolution)
+ *         octreeChangeDetector.set_input_cloud(self)             # <<<<<<<<<<<<<<
+ *         return octreeChangeDetector
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_octreeChangeDetector), __pyx_n_s_set_input_cloud); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 379, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 379, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 379, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_3, ((PyObject *)__pyx_v_self)};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 379, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+    } else
+    #endif
+    {
+      __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 379, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
+      __Pyx_INCREF(((PyObject *)__pyx_v_self));
+      __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+      PyTuple_SET_ITEM(__pyx_t_4, 0+1, ((PyObject *)__pyx_v_self));
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 379, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":380
+ *         octreeChangeDetector = OctreePointCloudChangeDetector(resolution)
+ *         octreeChangeDetector.set_input_cloud(self)
+ *         return octreeChangeDetector             # <<<<<<<<<<<<<<
+ * 
+ *     def make_crophull(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_octreeChangeDetector));
+  __pyx_r = ((PyObject *)__pyx_v_octreeChangeDetector);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":374
+ * 
+ *     # pcl 1.7.2, 1.8.0 (octree_pointcloud_changedetector.h(->octree_pointcloud.h) include headerfile comment octree2buf_base.h)
+ *     def make_octreeChangeDetector(self, double resolution):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.make_octreeSearch object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_octreeChangeDetector", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_octreeChangeDetector);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":382
+ *         return octreeChangeDetector
+ * 
+ *     def make_crophull(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.CropHull object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_61make_crophull(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_60make_crophull[] = "PointCloud.make_crophull(self)\n\n        Return a pcl.CropHull object with this object set as the input-cloud\n\n        Deprecated: use the pcl.Vertices constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_61make_crophull(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_crophull (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_60make_crophull(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_60make_crophull(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_crophull", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":388
+ *         Deprecated: use the pcl.Vertices constructor on this cloud.
+ *         """
+ *         return CropHull(self)             # <<<<<<<<<<<<<<
+ * 
+ *     def make_cropbox(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 388, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_CropHull), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 388, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":382
+ *         return octreeChangeDetector
+ * 
+ *     def make_crophull(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.CropHull object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_crophull", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":390
+ *         return CropHull(self)
+ * 
+ *     def make_cropbox(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.CropBox object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_63make_cropbox(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_62make_cropbox[] = "PointCloud.make_cropbox(self)\n\n        Return a pcl.CropBox object with this object set as the input-cloud\n        Deprecated: use the pcl.Vertices constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_63make_cropbox(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_cropbox (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_62make_cropbox(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_62make_cropbox(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_cropbox", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":395
+ *         Deprecated: use the pcl.Vertices constructor on this cloud.
+ *         """
+ *         return CropBox(self)             # <<<<<<<<<<<<<<
+ * 
+ *     def make_IntegralImageNormalEstimation(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_CropBox), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 395, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":390
+ *         return CropHull(self)
+ * 
+ *     def make_cropbox(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.CropBox object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_cropbox", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":397
+ *         return CropBox(self)
+ * 
+ *     def make_IntegralImageNormalEstimation(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.IntegralImageNormalEstimation object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_65make_IntegralImageNormalEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_64make_IntegralImageNormalEstimation[] = "PointCloud.make_IntegralImageNormalEstimation(self)\n\n        Return a pcl.IntegralImageNormalEstimation object with this object set as the input-cloud\n        Deprecated: use the pcl.Vertices constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_65make_IntegralImageNormalEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_IntegralImageNormalEstimation (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_64make_IntegralImageNormalEstimation(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_64make_IntegralImageNormalEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_IntegralImageNormalEstimation", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":402
+ *         Deprecated: use the pcl.Vertices constructor on this cloud.
+ *         """
+ *         return IntegralImageNormalEstimation(self)             # <<<<<<<<<<<<<<
+ * 
+ *     def extract(self, pyindices, bool negative=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 402, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_IntegralImageNormalEstimation), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 402, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":397
+ *         return CropBox(self)
+ * 
+ *     def make_IntegralImageNormalEstimation(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.IntegralImageNormalEstimation object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_IntegralImageNormalEstimation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":404
+ *         return IntegralImageNormalEstimation(self)
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_67extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_66extract[] = "PointCloud.extract(self, pyindices, bool negative=False)\n\n        Given a list of indices of points in the pointcloud, return a \n        new pointcloud containing only those points.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_67extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_pyindices = 0;
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("extract (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyindices,&__pyx_n_s_negative,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyindices)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_negative);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "extract") < 0)) __PYX_ERR(3, 404, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pyindices = values[0];
+    if (values[1]) {
+      __pyx_v_negative = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(3, 404, __pyx_L3_error)
+    } else {
+      __pyx_v_negative = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("extract", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 404, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_66extract(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), __pyx_v_pyindices, __pyx_v_negative);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_66extract(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_result = 0;
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_v_ind;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  __Pyx_RefNannySetupContext("extract", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":410
+ *         """
+ *         cdef PointCloud result
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()             # <<<<<<<<<<<<<<
+ * 
+ *         for i in pyindices:
+ */
+  try {
+    __pyx_t_1 = new __pyx_t_3pcl_8pcl_defs_PointIndices_t();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 410, __pyx_L1_error)
+  }
+  __pyx_v_ind = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":412
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ * 
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ * 
+ */
+  if (likely(PyList_CheckExact(__pyx_v_pyindices)) || PyTuple_CheckExact(__pyx_v_pyindices)) {
+    __pyx_t_2 = __pyx_v_pyindices; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_pyindices); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 412, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 412, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(3, 412, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 412, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(3, 412, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 412, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(3, 412, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":413
+ * 
+ *         for i in pyindices:
+ *             ind.indices.push_back(i)             # <<<<<<<<<<<<<<
+ * 
+ *         result = PointCloud()
+ */
+    __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 413, __pyx_L1_error)
+    try {
+      __pyx_v_ind->indices.push_back(__pyx_t_6);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(3, 413, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":412
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ * 
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":415
+ *             ind.indices.push_back(i)
+ * 
+ *         result = PointCloud()             # <<<<<<<<<<<<<<
+ *         # result = ExtractIndices()
+ *         # (<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr())
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 415, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_result = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":418
+ *         # result = ExtractIndices()
+ *         # (<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr())
+ *         mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)             # <<<<<<<<<<<<<<
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ * 
+ */
+  try {
+    mpcl_extract(__pyx_v_self->thisptr_shared, __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_result), __pyx_v_ind, __pyx_v_negative);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 418, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":421
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     def make_ProjectInliers(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":404
+ *         return IntegralImageNormalEstimation(self)
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":423
+ *         return result
+ * 
+ *     def make_ProjectInliers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pclfil.ProjectInliers object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_69make_ProjectInliers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_68make_ProjectInliers[] = "PointCloud.make_ProjectInliers(self)\n\n        Return a pclfil.ProjectInliers object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_69make_ProjectInliers(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_ProjectInliers (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_68make_ProjectInliers(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_68make_ProjectInliers(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_ProjectInliers *__pyx_v_proj = NULL;
+  __pyx_t_3pcl_11pcl_filters_ProjectInliers_t *__pyx_v_cproj;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_ProjectInliers", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":446
+ *         # proj.me = projInliers
+ *         # return proj
+ *         proj = ProjectInliers()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me
+ *         # mpcl_ProjectInliers_setModelCoefficients(cproj)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_ProjectInliers), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 446, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_proj = ((struct __pyx_obj_3pcl_4_pcl_ProjectInliers *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":447
+ *         # return proj
+ *         proj = ProjectInliers()
+ *         cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me             # <<<<<<<<<<<<<<
+ *         # mpcl_ProjectInliers_setModelCoefficients(cproj)
+ *         mpcl_ProjectInliers_setModelCoefficients(deref(cproj))
+ */
+  __pyx_v_cproj = ((__pyx_t_3pcl_11pcl_filters_ProjectInliers_t *)__pyx_v_proj->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":449
+ *         cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me
+ *         # mpcl_ProjectInliers_setModelCoefficients(cproj)
+ *         mpcl_ProjectInliers_setModelCoefficients(deref(cproj))             # <<<<<<<<<<<<<<
+ *         cproj.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return proj
+ */
+  try {
+    mpcl_ProjectInliers_setModelCoefficients((*__pyx_v_cproj));
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(3, 449, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":450
+ *         # mpcl_ProjectInliers_setModelCoefficients(cproj)
+ *         mpcl_ProjectInliers_setModelCoefficients(deref(cproj))
+ *         cproj.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return proj
+ * 
+ */
+  __pyx_v_cproj->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":451
+ *         mpcl_ProjectInliers_setModelCoefficients(deref(cproj))
+ *         cproj.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return proj             # <<<<<<<<<<<<<<
+ * 
+ *     def make_RadiusOutlierRemoval(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_proj));
+  __pyx_r = ((PyObject *)__pyx_v_proj);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":423
+ *         return result
+ * 
+ *     def make_ProjectInliers(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pclfil.ProjectInliers object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_ProjectInliers", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_proj);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":453
+ *         return proj
+ * 
+ *     def make_RadiusOutlierRemoval(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_71make_RadiusOutlierRemoval(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_70make_RadiusOutlierRemoval[] = "PointCloud.make_RadiusOutlierRemoval(self)\n\n        Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_71make_RadiusOutlierRemoval(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_RadiusOutlierRemoval (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_70make_RadiusOutlierRemoval(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_70make_RadiusOutlierRemoval(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_RadiusOutlierRemoval", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":457
+ *         Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud
+ *         """
+ *         fil = RadiusOutlierRemoval()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_RadiusOutlierRemoval), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 457, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":458
+ *         """
+ *         fil = RadiusOutlierRemoval()
+ *         cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_RadiusOutlierRemoval_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":459
+ *         fil = RadiusOutlierRemoval()
+ *         cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":460
+ *         cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_ConditionAnd(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":453
+ *         return proj
+ * 
+ *     def make_RadiusOutlierRemoval(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_RadiusOutlierRemoval", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":462
+ *         return fil
+ * 
+ *     def make_ConditionAnd(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ConditionAnd object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_73make_ConditionAnd(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_72make_ConditionAnd[] = "PointCloud.make_ConditionAnd(self)\n\n        Return a pcl.ConditionAnd object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_73make_ConditionAnd(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_ConditionAnd (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_72make_ConditionAnd(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_72make_ConditionAnd(CYTHON_UNUSED struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_condAnd = NULL;
+  CYTHON_UNUSED __pyx_t_3pcl_11pcl_filters_ConditionAnd_t *__pyx_v_cCondAnd;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_ConditionAnd", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":466
+ *         Return a pcl.ConditionAnd object with this object set as the input-cloud
+ *         """
+ *         condAnd = ConditionAnd()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.ConditionAnd_t *cCondAnd = <pclfil.ConditionAnd_t *>condAnd.me
+ *         return condAnd
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_ConditionAnd), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 466, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_condAnd = ((struct __pyx_obj_3pcl_4_pcl_ConditionAnd *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":467
+ *         """
+ *         condAnd = ConditionAnd()
+ *         cdef pclfil.ConditionAnd_t *cCondAnd = <pclfil.ConditionAnd_t *>condAnd.me             # <<<<<<<<<<<<<<
+ *         return condAnd
+ * 
+ */
+  __pyx_v_cCondAnd = ((__pyx_t_3pcl_11pcl_filters_ConditionAnd_t *)__pyx_v_condAnd->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":468
+ *         condAnd = ConditionAnd()
+ *         cdef pclfil.ConditionAnd_t *cCondAnd = <pclfil.ConditionAnd_t *>condAnd.me
+ *         return condAnd             # <<<<<<<<<<<<<<
+ * 
+ *     def make_ConditionalRemoval(self, ConditionAnd range_conf):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_condAnd));
+  __pyx_r = ((PyObject *)__pyx_v_condAnd);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":462
+ *         return fil
+ * 
+ *     def make_ConditionAnd(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ConditionAnd object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_ConditionAnd", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_condAnd);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":470
+ *         return condAnd
+ * 
+ *     def make_ConditionalRemoval(self, ConditionAnd range_conf):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_75make_ConditionalRemoval(PyObject *__pyx_v_self, PyObject *__pyx_v_range_conf); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_74make_ConditionalRemoval[] = "PointCloud.make_ConditionalRemoval(self, ConditionAnd range_conf)\n\n        Return a pcl.ConditionalRemoval object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_75make_ConditionalRemoval(PyObject *__pyx_v_self, PyObject *__pyx_v_range_conf) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_ConditionalRemoval (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_range_conf), __pyx_ptype_3pcl_4_pcl_ConditionAnd, 1, "range_conf", 0))) __PYX_ERR(3, 470, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_74make_ConditionalRemoval(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self), ((struct __pyx_obj_3pcl_4_pcl_ConditionAnd *)__pyx_v_range_conf));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_74make_ConditionalRemoval(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self, struct __pyx_obj_3pcl_4_pcl_ConditionAnd *__pyx_v_range_conf) {
+  struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *__pyx_v_condRemoval = NULL;
+  __pyx_t_3pcl_11pcl_filters_ConditionalRemoval_t *__pyx_v_cCondRemoval;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_ConditionalRemoval", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":474
+ *         Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+ *         """
+ *         condRemoval = ConditionalRemoval(range_conf)             # <<<<<<<<<<<<<<
+ *         cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me
+ *         cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_range_conf));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_range_conf));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_range_conf));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_ConditionalRemoval), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 474, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_condRemoval = ((struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":475
+ *         """
+ *         condRemoval = ConditionalRemoval(range_conf)
+ *         cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me             # <<<<<<<<<<<<<<
+ *         cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return condRemoval
+ */
+  __pyx_v_cCondRemoval = ((__pyx_t_3pcl_11pcl_filters_ConditionalRemoval_t *)__pyx_v_condRemoval->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":476
+ *         condRemoval = ConditionalRemoval(range_conf)
+ *         cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me
+ *         cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return condRemoval
+ * 
+ */
+  __pyx_v_cCondRemoval->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":477
+ *         cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me
+ *         cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return condRemoval             # <<<<<<<<<<<<<<
+ * 
+ *     def make_ConcaveHull(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_condRemoval));
+  __pyx_r = ((PyObject *)__pyx_v_condRemoval);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":470
+ *         return condAnd
+ * 
+ *     def make_ConditionalRemoval(self, ConditionAnd range_conf):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_ConditionalRemoval", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_condRemoval);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":479
+ *         return condRemoval
+ * 
+ *     def make_ConcaveHull(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_77make_ConcaveHull(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_76make_ConcaveHull[] = "PointCloud.make_ConcaveHull(self)\n\n        Return a pcl.ConditionalRemoval object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_77make_ConcaveHull(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_ConcaveHull (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_76make_ConcaveHull(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_76make_ConcaveHull(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_ConcaveHull *__pyx_v_concaveHull = NULL;
+  __pyx_t_3pcl_11pcl_surface_ConcaveHull_t *__pyx_v_cConcaveHull;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_ConcaveHull", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":483
+ *         Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+ *         """
+ *         concaveHull = ConcaveHull()             # <<<<<<<<<<<<<<
+ *         cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me
+ *         cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_ConcaveHull), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 483, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_concaveHull = ((struct __pyx_obj_3pcl_4_pcl_ConcaveHull *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":484
+ *         """
+ *         concaveHull = ConcaveHull()
+ *         cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me             # <<<<<<<<<<<<<<
+ *         cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return concaveHull
+ */
+  __pyx_v_cConcaveHull = ((__pyx_t_3pcl_11pcl_surface_ConcaveHull_t *)__pyx_v_concaveHull->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":485
+ *         concaveHull = ConcaveHull()
+ *         cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me
+ *         cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return concaveHull
+ * 
+ */
+  __pyx_v_cConcaveHull->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":486
+ *         cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me
+ *         cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return concaveHull             # <<<<<<<<<<<<<<
+ * 
+ *     def make_HarrisKeypoint3D(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_concaveHull));
+  __pyx_r = ((PyObject *)__pyx_v_concaveHull);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":479
+ *         return condRemoval
+ * 
+ *     def make_ConcaveHull(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_ConcaveHull", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_concaveHull);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":488
+ *         return concaveHull
+ * 
+ *     def make_HarrisKeypoint3D(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PointCloud object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_79make_HarrisKeypoint3D(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_78make_HarrisKeypoint3D[] = "PointCloud.make_HarrisKeypoint3D(self)\n\n        Return a pcl.PointCloud object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_79make_HarrisKeypoint3D(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_HarrisKeypoint3D (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_78make_HarrisKeypoint3D(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_78make_HarrisKeypoint3D(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *__pyx_v_harris = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_HarrisKeypoint3D", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":492
+ *         Return a pcl.PointCloud object with this object set as the input-cloud
+ *         """
+ *         harris = HarrisKeypoint3D(self)             # <<<<<<<<<<<<<<
+ *         # harris = HarrisKeypoint3D()
+ *         # cdef keypt.HarrisKeypoint3D_t *charris = <keypt.HarrisKeypoint3D_t *>harris.me
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 492, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_HarrisKeypoint3D), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 492, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_harris = ((struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":496
+ *         # cdef keypt.HarrisKeypoint3D_t *charris = <keypt.HarrisKeypoint3D_t *>harris.me
+ *         # charris.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return harris             # <<<<<<<<<<<<<<
+ * 
+ *     def make_NormalEstimation(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_harris));
+  __pyx_r = ((PyObject *)__pyx_v_harris);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":488
+ *         return concaveHull
+ * 
+ *     def make_HarrisKeypoint3D(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PointCloud object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_HarrisKeypoint3D", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_harris);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":498
+ *         return harris
+ * 
+ *     def make_NormalEstimation(self):             # <<<<<<<<<<<<<<
+ *         normalEstimation = NormalEstimation()
+ *         cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_81make_NormalEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_80make_NormalEstimation[] = "PointCloud.make_NormalEstimation(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_81make_NormalEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_NormalEstimation (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_80make_NormalEstimation(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_80make_NormalEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_NormalEstimation *__pyx_v_normalEstimation = NULL;
+  __pyx_t_3pcl_16pcl_features_180_NormalEstimation_t *__pyx_v_cNormalEstimation;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_NormalEstimation", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":499
+ * 
+ *     def make_NormalEstimation(self):
+ *         normalEstimation = NormalEstimation()             # <<<<<<<<<<<<<<
+ *         cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me
+ *         cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_NormalEstimation), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 499, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_normalEstimation = ((struct __pyx_obj_3pcl_4_pcl_NormalEstimation *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":500
+ *     def make_NormalEstimation(self):
+ *         normalEstimation = NormalEstimation()
+ *         cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me             # <<<<<<<<<<<<<<
+ *         cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return normalEstimation
+ */
+  __pyx_v_cNormalEstimation = ((__pyx_t_3pcl_16pcl_features_180_NormalEstimation_t *)__pyx_v_normalEstimation->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":501
+ *         normalEstimation = NormalEstimation()
+ *         cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me
+ *         cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return normalEstimation
+ * 
+ */
+  __pyx_v_cNormalEstimation->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":502
+ *         cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me
+ *         cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return normalEstimation             # <<<<<<<<<<<<<<
+ * 
+ *     def make_VFHEstimation(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_normalEstimation));
+  __pyx_r = ((PyObject *)__pyx_v_normalEstimation);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":498
+ *         return harris
+ * 
+ *     def make_NormalEstimation(self):             # <<<<<<<<<<<<<<
+ *         normalEstimation = NormalEstimation()
+ *         cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_NormalEstimation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_normalEstimation);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":504
+ *         return normalEstimation
+ * 
+ *     def make_VFHEstimation(self):             # <<<<<<<<<<<<<<
+ *         vfhEstimation = VFHEstimation()
+ *         normalEstimation = self.make_NormalEstimation()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_83make_VFHEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_82make_VFHEstimation[] = "PointCloud.make_VFHEstimation(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_83make_VFHEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_VFHEstimation (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_82make_VFHEstimation(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_82make_VFHEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_VFHEstimation *__pyx_v_vfhEstimation = NULL;
+  PyObject *__pyx_v_normalEstimation = NULL;
+  CYTHON_UNUSED PyObject *__pyx_v_cloud_normals = NULL;
+  __pyx_t_3pcl_16pcl_features_180_VFHEstimation_t *__pyx_v_cVFHEstimation;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("make_VFHEstimation", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":505
+ * 
+ *     def make_VFHEstimation(self):
+ *         vfhEstimation = VFHEstimation()             # <<<<<<<<<<<<<<
+ *         normalEstimation = self.make_NormalEstimation()
+ *         cloud_normals = normalEstimation.Compute()
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_VFHEstimation), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 505, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_vfhEstimation = ((struct __pyx_obj_3pcl_4_pcl_VFHEstimation *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":506
+ *     def make_VFHEstimation(self):
+ *         vfhEstimation = VFHEstimation()
+ *         normalEstimation = self.make_NormalEstimation()             # <<<<<<<<<<<<<<
+ *         cloud_normals = normalEstimation.Compute()
+ *         # features
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_make_NormalEstimation); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 506, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 506, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 506, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_normalEstimation = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":507
+ *         vfhEstimation = VFHEstimation()
+ *         normalEstimation = self.make_NormalEstimation()
+ *         cloud_normals = normalEstimation.Compute()             # <<<<<<<<<<<<<<
+ *         # features
+ *         cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_normalEstimation, __pyx_n_s_Compute); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 507, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 507, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 507, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_v_cloud_normals = __pyx_t_1;
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":509
+ *         cloud_normals = normalEstimation.Compute()
+ *         # features
+ *         cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me             # <<<<<<<<<<<<<<
+ *         cVFHEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return vfhEstimation
+ */
+  __pyx_v_cVFHEstimation = ((__pyx_t_3pcl_16pcl_features_180_VFHEstimation_t *)__pyx_v_vfhEstimation->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":510
+ *         # features
+ *         cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me
+ *         cVFHEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return vfhEstimation
+ * 
+ */
+  __pyx_v_cVFHEstimation->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":511
+ *         cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me
+ *         cVFHEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return vfhEstimation             # <<<<<<<<<<<<<<
+ * 
+ *     def make_RangeImage(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_vfhEstimation));
+  __pyx_r = ((PyObject *)__pyx_v_vfhEstimation);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":504
+ *         return normalEstimation
+ * 
+ *     def make_VFHEstimation(self):             # <<<<<<<<<<<<<<
+ *         vfhEstimation = VFHEstimation()
+ *         normalEstimation = self.make_NormalEstimation()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_VFHEstimation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_vfhEstimation);
+  __Pyx_XDECREF(__pyx_v_normalEstimation);
+  __Pyx_XDECREF(__pyx_v_cloud_normals);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":513
+ *         return vfhEstimation
+ * 
+ *     def make_RangeImage(self):             # <<<<<<<<<<<<<<
+ *         rangeImages = RangeImages(self)
+ *         # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_85make_RangeImage(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_84make_RangeImage[] = "PointCloud.make_RangeImage(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_85make_RangeImage(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_RangeImage (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_84make_RangeImage(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_84make_RangeImage(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_rangeImages = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_RangeImage", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":514
+ * 
+ *     def make_RangeImage(self):
+ *         rangeImages = RangeImages(self)             # <<<<<<<<<<<<<<
+ *         # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me
+ *         return rangeImages
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 514, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_RangeImages), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 514, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_rangeImages = ((struct __pyx_obj_3pcl_4_pcl_RangeImages *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":516
+ *         rangeImages = RangeImages(self)
+ *         # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me
+ *         return rangeImages             # <<<<<<<<<<<<<<
+ * 
+ *     def make_EuclideanClusterExtraction(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_rangeImages));
+  __pyx_r = ((PyObject *)__pyx_v_rangeImages);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":513
+ *         return vfhEstimation
+ * 
+ *     def make_RangeImage(self):             # <<<<<<<<<<<<<<
+ *         rangeImages = RangeImages(self)
+ *         # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_RangeImage", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_rangeImages);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":518
+ *         return rangeImages
+ * 
+ *     def make_EuclideanClusterExtraction(self):             # <<<<<<<<<<<<<<
+ *         euclideanclusterextraction = EuclideanClusterExtraction(self)
+ *         cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_87make_EuclideanClusterExtraction(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_86make_EuclideanClusterExtraction[] = "PointCloud.make_EuclideanClusterExtraction(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_87make_EuclideanClusterExtraction(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_EuclideanClusterExtraction (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_86make_EuclideanClusterExtraction(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_86make_EuclideanClusterExtraction(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *__pyx_v_euclideanclusterextraction = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_t *__pyx_v_cEuclideanClusterExtraction;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_EuclideanClusterExtraction", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":519
+ * 
+ *     def make_EuclideanClusterExtraction(self):
+ *         euclideanclusterextraction = EuclideanClusterExtraction(self)             # <<<<<<<<<<<<<<
+ *         cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me
+ *         cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 519, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_EuclideanClusterExtraction), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 519, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_euclideanclusterextraction = ((struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":520
+ *     def make_EuclideanClusterExtraction(self):
+ *         euclideanclusterextraction = EuclideanClusterExtraction(self)
+ *         cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me             # <<<<<<<<<<<<<<
+ *         cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return euclideanclusterextraction
+ */
+  __pyx_v_cEuclideanClusterExtraction = ((__pyx_t_3pcl_20pcl_segmentation_180_EuclideanClusterExtraction_t *)__pyx_v_euclideanclusterextraction->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":521
+ *         euclideanclusterextraction = EuclideanClusterExtraction(self)
+ *         cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me
+ *         cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return euclideanclusterextraction
+ * 
+ */
+  __pyx_v_cEuclideanClusterExtraction->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":522
+ *         cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me
+ *         cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return euclideanclusterextraction             # <<<<<<<<<<<<<<
+ * 
+ *     def make_GeneralizedIterativeClosestPoint(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_euclideanclusterextraction));
+  __pyx_r = ((PyObject *)__pyx_v_euclideanclusterextraction);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":518
+ *         return rangeImages
+ * 
+ *     def make_EuclideanClusterExtraction(self):             # <<<<<<<<<<<<<<
+ *         euclideanclusterextraction = EuclideanClusterExtraction(self)
+ *         cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_EuclideanClusterExtraction", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_euclideanclusterextraction);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":524
+ *         return euclideanclusterextraction
+ * 
+ *     def make_GeneralizedIterativeClosestPoint(self):             # <<<<<<<<<<<<<<
+ *         generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_89make_GeneralizedIterativeClosestPoint(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_88make_GeneralizedIterativeClosestPoint[] = "PointCloud.make_GeneralizedIterativeClosestPoint(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_89make_GeneralizedIterativeClosestPoint(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_GeneralizedIterativeClosestPoint (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_88make_GeneralizedIterativeClosestPoint(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_88make_GeneralizedIterativeClosestPoint(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *__pyx_v_generalizedIterativeClosestPoint = NULL;
+  __pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_t *__pyx_v_cGeneralizedIterativeClosestPoint;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_GeneralizedIterativeClosestPoint", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":525
+ * 
+ *     def make_GeneralizedIterativeClosestPoint(self):
+ *         generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)             # <<<<<<<<<<<<<<
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me
+ *         cGeneralizedIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 525, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_GeneralizedIterativeClosestPoint), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 525, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_generalizedIterativeClosestPoint = ((struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":526
+ *     def make_GeneralizedIterativeClosestPoint(self):
+ *         generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me             # <<<<<<<<<<<<<<
+ *         cGeneralizedIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return generalizedIterativeClosestPoint
+ */
+  __pyx_v_cGeneralizedIterativeClosestPoint = ((__pyx_t_3pcl_20pcl_registration_180_GeneralizedIterativeClosestPoint_t *)__pyx_v_generalizedIterativeClosestPoint->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":527
+ *         generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me
+ *         cGeneralizedIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return generalizedIterativeClosestPoint
+ * 
+ */
+  __pyx_v_cGeneralizedIterativeClosestPoint->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":528
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me
+ *         cGeneralizedIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return generalizedIterativeClosestPoint             # <<<<<<<<<<<<<<
+ * 
+ *     def make_IterativeClosestPointNonLinear(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_generalizedIterativeClosestPoint));
+  __pyx_r = ((PyObject *)__pyx_v_generalizedIterativeClosestPoint);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":524
+ *         return euclideanclusterextraction
+ * 
+ *     def make_GeneralizedIterativeClosestPoint(self):             # <<<<<<<<<<<<<<
+ *         generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)
+ *         cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_GeneralizedIterativeClosestPoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_generalizedIterativeClosestPoint);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":530
+ *         return generalizedIterativeClosestPoint
+ * 
+ *     def make_IterativeClosestPointNonLinear(self):             # <<<<<<<<<<<<<<
+ *         iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_91make_IterativeClosestPointNonLinear(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_90make_IterativeClosestPointNonLinear[] = "PointCloud.make_IterativeClosestPointNonLinear(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_91make_IterativeClosestPointNonLinear(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_IterativeClosestPointNonLinear (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_90make_IterativeClosestPointNonLinear(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_90make_IterativeClosestPointNonLinear(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *__pyx_v_iterativeClosestPointNonLinear = NULL;
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_t *__pyx_v_cIterativeClosestPointNonLinear;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_IterativeClosestPointNonLinear", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":531
+ * 
+ *     def make_IterativeClosestPointNonLinear(self):
+ *         iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)             # <<<<<<<<<<<<<<
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me
+ *         cIterativeClosestPointNonLinear.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 531, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_IterativeClosestPointNonLinear), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 531, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_iterativeClosestPointNonLinear = ((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":532
+ *     def make_IterativeClosestPointNonLinear(self):
+ *         iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me             # <<<<<<<<<<<<<<
+ *         cIterativeClosestPointNonLinear.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return iterativeClosestPointNonLinear
+ */
+  __pyx_v_cIterativeClosestPointNonLinear = ((__pyx_t_3pcl_20pcl_registration_180_IterativeClosestPointNonLinear_t *)__pyx_v_iterativeClosestPointNonLinear->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":533
+ *         iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me
+ *         cIterativeClosestPointNonLinear.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return iterativeClosestPointNonLinear
+ * 
+ */
+  __pyx_v_cIterativeClosestPointNonLinear->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":534
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me
+ *         cIterativeClosestPointNonLinear.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return iterativeClosestPointNonLinear             # <<<<<<<<<<<<<<
+ * 
+ *     def make_IterativeClosestPoint(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_iterativeClosestPointNonLinear));
+  __pyx_r = ((PyObject *)__pyx_v_iterativeClosestPointNonLinear);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":530
+ *         return generalizedIterativeClosestPoint
+ * 
+ *     def make_IterativeClosestPointNonLinear(self):             # <<<<<<<<<<<<<<
+ *         iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)
+ *         cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_IterativeClosestPointNonLinear", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_iterativeClosestPointNonLinear);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":536
+ *         return iterativeClosestPointNonLinear
+ * 
+ *     def make_IterativeClosestPoint(self):             # <<<<<<<<<<<<<<
+ *         iterativeClosestPoint = IterativeClosestPoint(self)
+ *         cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_93make_IterativeClosestPoint(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_92make_IterativeClosestPoint[] = "PointCloud.make_IterativeClosestPoint(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_93make_IterativeClosestPoint(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_IterativeClosestPoint (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_92make_IterativeClosestPoint(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_92make_IterativeClosestPoint(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *__pyx_v_iterativeClosestPoint = NULL;
+  __pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_t *__pyx_v_cIterativeClosestPoint;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_IterativeClosestPoint", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":537
+ * 
+ *     def make_IterativeClosestPoint(self):
+ *         iterativeClosestPoint = IterativeClosestPoint(self)             # <<<<<<<<<<<<<<
+ *         cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me
+ *         cIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 537, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_IterativeClosestPoint), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 537, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_iterativeClosestPoint = ((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":538
+ *     def make_IterativeClosestPoint(self):
+ *         iterativeClosestPoint = IterativeClosestPoint(self)
+ *         cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me             # <<<<<<<<<<<<<<
+ *         cIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return iterativeClosestPoint
+ */
+  __pyx_v_cIterativeClosestPoint = ((__pyx_t_3pcl_20pcl_registration_180_IterativeClosestPoint_t *)__pyx_v_iterativeClosestPoint->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":539
+ *         iterativeClosestPoint = IterativeClosestPoint(self)
+ *         cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me
+ *         cIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return iterativeClosestPoint
+ * 
+ */
+  __pyx_v_cIterativeClosestPoint->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":540
+ *         cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me
+ *         cIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return iterativeClosestPoint             # <<<<<<<<<<<<<<
+ * 
+ *     def make_MomentOfInertiaEstimation(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_iterativeClosestPoint));
+  __pyx_r = ((PyObject *)__pyx_v_iterativeClosestPoint);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":536
+ *         return iterativeClosestPointNonLinear
+ * 
+ *     def make_IterativeClosestPoint(self):             # <<<<<<<<<<<<<<
+ *         iterativeClosestPoint = IterativeClosestPoint(self)
+ *         cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_IterativeClosestPoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_iterativeClosestPoint);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZ_180.pxi":542
+ *         return iterativeClosestPoint
+ * 
+ *     def make_MomentOfInertiaEstimation(self):             # <<<<<<<<<<<<<<
+ *         momentofinertiaestimation = MomentOfInertiaEstimation(self)
+ *         cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_95make_MomentOfInertiaEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_10PointCloud_94make_MomentOfInertiaEstimation[] = "PointCloud.make_MomentOfInertiaEstimation(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_10PointCloud_95make_MomentOfInertiaEstimation(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_MomentOfInertiaEstimation (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_10PointCloud_94make_MomentOfInertiaEstimation(((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_10PointCloud_94make_MomentOfInertiaEstimation(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *__pyx_v_momentofinertiaestimation = NULL;
+  __pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_t *__pyx_v_cMomentOfInertiaEstimation;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_MomentOfInertiaEstimation", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":543
+ * 
+ *     def make_MomentOfInertiaEstimation(self):
+ *         momentofinertiaestimation = MomentOfInertiaEstimation(self)             # <<<<<<<<<<<<<<
+ *         cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me
+ *         cMomentOfInertiaEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 543, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_MomentOfInertiaEstimation), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 543, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_v_momentofinertiaestimation = ((struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":544
+ *     def make_MomentOfInertiaEstimation(self):
+ *         momentofinertiaestimation = MomentOfInertiaEstimation(self)
+ *         cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me             # <<<<<<<<<<<<<<
+ *         cMomentOfInertiaEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return momentofinertiaestimation
+ */
+  __pyx_v_cMomentOfInertiaEstimation = ((__pyx_t_3pcl_16pcl_features_180_MomentOfInertiaEstimation_t *)__pyx_v_momentofinertiaestimation->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":545
+ *         momentofinertiaestimation = MomentOfInertiaEstimation(self)
+ *         cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me
+ *         cMomentOfInertiaEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return momentofinertiaestimation
+ * 
+ */
+  __pyx_v_cMomentOfInertiaEstimation->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZ> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":546
+ *         cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me
+ *         cMomentOfInertiaEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+ *         return momentofinertiaestimation             # <<<<<<<<<<<<<<
+ * 
+ *     # registration - icp?
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_momentofinertiaestimation));
+  __pyx_r = ((PyObject *)__pyx_v_momentofinertiaestimation);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":542
+ *         return iterativeClosestPoint
+ * 
+ *     def make_MomentOfInertiaEstimation(self):             # <<<<<<<<<<<<<<
+ *         momentofinertiaestimation = MomentOfInertiaEstimation(self)
+ *         cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud.make_MomentOfInertiaEstimation", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_momentofinertiaestimation);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":54
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointXYZI other
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_init = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_init,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_init);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(41, 54, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_init = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(41, 54, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI___cinit__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), __pyx_v_init);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyObject *__pyx_v_init) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_other = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  pcl::PointCloud<struct pcl::PointXYZI>  *__pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":57
+ *         cdef PointCloud_PointXYZI other
+ * 
+ *         self._view_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+ */
+  __pyx_v_self->_view_count = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":61
+ *         # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+ *         # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())             # <<<<<<<<<<<<<<
+ * 
+ *         if init is None:
+ */
+  try {
+    __pyx_t_1 = new pcl::PointCloud<struct pcl::PointXYZI> ();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 61, __pyx_L1_error)
+  }
+  sp_assign<pcl::PointCloud<struct pcl::PointXYZI> >(__pyx_v_self->thisptr_shared, __pyx_t_1);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":63
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  __pyx_t_2 = (__pyx_v_init == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":64
+ * 
+ *         if init is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":63
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":65
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Integral); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_integer); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 65, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); 
+  __pyx_t_7 = (__pyx_t_2 != 0);
+  if (!__pyx_t_7) {
+  } else {
+    __pyx_t_3 = __pyx_t_7;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_7 = PyObject_IsInstance(__pyx_v_init, __pyx_t_6); 
+  __pyx_t_2 = (__pyx_t_7 != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":66
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 66, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 66, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 66, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 66, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(41, 66, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 66, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":65
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":67
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_init, __pyx_ptype_5numpy_ndarray); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":68
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_8) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 68, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 68, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 68, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 68, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 68, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":67
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":69
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 69, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(41, 69, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":70
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_list); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 70, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 70, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 70, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 70, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(41, 70, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 70, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":69
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":71
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(41, 71, __pyx_L1_error)
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":72
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ *             other = init             # <<<<<<<<<<<<<<
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ */
+    if (!(likely(((__pyx_v_init) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_init, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI))))) __PYX_ERR(41, 72, __pyx_L1_error)
+    __pyx_t_5 = __pyx_v_init;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_v_other = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":73
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ */
+    (__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)[0]) = (__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_other)[0]);
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":71
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":75
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+  /*else*/ {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":76
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ *                             % type(init))             # <<<<<<<<<<<<<<
+ * 
+ *     property width:
+ */
+    __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, ((PyObject *)Py_TYPE(__pyx_v_init))); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 76, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":75
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+    __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(41, 75, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":54
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointXYZI other
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_other);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":80
+ *     property width:
+ *         """ property containing the width of the point cloud """
+ *         def __get__(self): return self.thisptr().width             # <<<<<<<<<<<<<<
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_5width_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_5width_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_5width___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->width); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 80, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.width.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":83
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ *         def __get__(self): return self.thisptr().height             # <<<<<<<<<<<<<<
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_6height_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_6height_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_6height___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->height); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 83, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.height.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":86
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ *         def __get__(self): return self.thisptr().size()             # <<<<<<<<<<<<<<
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_4size_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_4size___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 86, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":89
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ *         def __get__(self): return self.thisptr().is_dense             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_8is_dense_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_8is_dense_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_8is_dense___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->is_dense); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.is_dense.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":91
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_2__repr__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":92
+ * 
+ *     def __repr__(self):
+ *         return "<PointCloud of %d points>" % self.size             # <<<<<<<<<<<<<<
+ * 
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_PointCloud_of_d_points, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 92, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":91
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":96
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_4__getbuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags) {
+  Py_ssize_t __pyx_v_npoints;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  struct pcl::PointXYZI *__pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_buffer != NULL) {
+    __pyx_v_buffer->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_buffer->obj);
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":98
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._view_count == 0:
+ */
+  __pyx_v_npoints = __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":100
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":101
+ * 
+ *         if self._view_count == 0:
+ *             self._view_count += 1             # <<<<<<<<<<<<<<
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 4
+ */
+    __pyx_v_self->_view_count = (__pyx_v_self->_view_count + 1);
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":102
+ *         if self._view_count == 0:
+ *             self._view_count += 1
+ *             self._shape[0] = npoints             # <<<<<<<<<<<<<<
+ *             self._shape[1] = 4
+ * 
+ */
+    (__pyx_v_self->_shape[0]) = __pyx_v_npoints;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":103
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 4             # <<<<<<<<<<<<<<
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ */
+    (__pyx_v_self->_shape[1]) = 4;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":100
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":105
+ *             self._shape[1] = 4
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)             # <<<<<<<<<<<<<<
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ */
+  try {
+    __pyx_t_2 = getptr_at<struct pcl::PointXYZI>(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self), 0);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 105, __pyx_L1_error)
+  }
+  __pyx_v_buffer->buf = ((char *)(&__pyx_t_2->x));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":106
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'             # <<<<<<<<<<<<<<
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ */
+  __pyx_v_buffer->format = ((char *)"f");
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":107
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL             # <<<<<<<<<<<<<<
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)
+ */
+  __pyx_v_buffer->internal = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":108
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2
+ */
+  __pyx_v_buffer->itemsize = (sizeof(float));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":109
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ */
+  __pyx_v_buffer->len = ((__pyx_v_npoints * 4) * (sizeof(float)));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":110
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2             # <<<<<<<<<<<<<<
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ */
+  __pyx_v_buffer->ndim = 2;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":111
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2
+ *         buffer.obj = self             # <<<<<<<<<<<<<<
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  __Pyx_GOTREF(__pyx_v_buffer->obj);
+  __Pyx_DECREF(__pyx_v_buffer->obj);
+  __pyx_v_buffer->obj = ((PyObject *)__pyx_v_self);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":112
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ *         buffer.readonly = 0             # <<<<<<<<<<<<<<
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides_xyzi_4
+ */
+  __pyx_v_buffer->readonly = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":113
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape             # <<<<<<<<<<<<<<
+ *         buffer.strides = _strides_xyzi_4
+ *         buffer.suboffsets = NULL
+ */
+  __pyx_t_3 = __pyx_v_self->_shape;
+  __pyx_v_buffer->shape = __pyx_t_3;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":114
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides_xyzi_4             # <<<<<<<<<<<<<<
+ *         buffer.suboffsets = NULL
+ * 
+ */
+  __pyx_v_buffer->strides = __pyx_v_3pcl_4_pcl__strides_xyzi_4;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":115
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides_xyzi_4
+ *         buffer.suboffsets = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ */
+  __pyx_v_buffer->suboffsets = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":96
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_buffer->obj);
+    __Pyx_DECREF(__pyx_v_buffer->obj); __pyx_v_buffer->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_buffer->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":117
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_6__releasebuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":118
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ *         self._view_count -= 1             # <<<<<<<<<<<<<<
+ * 
+ *     # Pickle support. XXX this copies the entire pointcloud; it would be nice
+ */
+  __pyx_v_self->_view_count = (__pyx_v_self->_view_count - 1);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":117
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":123
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_8__reduce__[] = "PointCloud_PointXYZI.__reduce__(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_8__reduce__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__reduce__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":124
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):
+ *         return type(self), (self.to_array(),)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_origin:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 124, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 124, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":123
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":127
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_13sensor_origin_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_13sensor_origin_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_13sensor_origin___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  Eigen::Vector4f __pyx_v_origin;
+  float *__pyx_v_data;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Vector4f __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":128
+ *     property sensor_origin:
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_             # <<<<<<<<<<<<<<
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->sensor_origin_;
+  __pyx_v_origin = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":129
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()             # <<<<<<<<<<<<<<
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)
+ */
+  __pyx_v_data = __pyx_v_origin.data();
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":130
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble((__pyx_v_data[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyFloat_FromDouble((__pyx_v_data[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble((__pyx_v_data[2])); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble((__pyx_v_data[3])); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyList_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_7, 3, __pyx_t_6);
+  __pyx_t_2 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":131
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_orientation:
+ */
+  __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(41, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 131, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(41, 131, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":130
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":127
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.sensor_origin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":134
+ * 
+ *     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_
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_18sensor_orientation_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_18sensor_orientation_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_18sensor_orientation___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  Eigen::Quaternionf __pyx_v_o;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Quaternionf __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":136
+ *         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()])
+ * 
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->sensor_orientation_;
+  __pyx_v_o = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":137
+ *             # 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()])             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_o.w()); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_o.x()); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_o.y()); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_o.z()); if (unlikely(!__pyx_t_7)) __PYX_ERR(41, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyList_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(41, 137, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyList_SET_ITEM(__pyx_t_8, 3, __pyx_t_7);
+  __pyx_t_3 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (!__pyx_t_7) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 137, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 137, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 137, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 137, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_8);
+      __pyx_t_8 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 137, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":134
+ * 
+ *     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_
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.sensor_orientation.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":140
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_10from_array[] = "PointCloud_PointXYZI.from_array(self, ndarray arr)\n\n        Fill this object from a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_array (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arr), __pyx_ptype_5numpy_ndarray, 0, "arr", 0))) __PYX_ERR(41, 140, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_10from_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((PyArrayObject *)__pyx_v_arr));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyArrayObject *__pyx_v_arr) {
+  npy_intp __pyx_v_npts;
+  struct pcl::PointXYZI *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_arr;
+  __Pyx_Buffer __pyx_pybuffer_arr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  npy_intp __pyx_t_6;
+  npy_intp __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  __pyx_t_5numpy_float32_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  __pyx_t_5numpy_float32_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  __pyx_t_5numpy_float32_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  unsigned long __pyx_t_19;
+  __Pyx_RefNannySetupContext("from_array", 0);
+  __pyx_pybuffer_arr.pybuffer.buf = NULL;
+  __pyx_pybuffer_arr.refcount = 0;
+  __pyx_pybuffernd_arr.data = NULL;
+  __pyx_pybuffernd_arr.rcbuffer = &__pyx_pybuffer_arr;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arr.rcbuffer->pybuffer, (PyObject*)__pyx_v_arr, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(41, 140, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_arr.diminfo[0].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arr.diminfo[0].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_arr.diminfo[1].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_arr.diminfo[1].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[1];
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":144
+ *         Fill this object from a 2D numpy array (float32)
+ *         """
+ *         assert arr.shape[1] == 4             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!(((__pyx_v_arr->dimensions[1]) == 4) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(41, 144, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":146
+ *         assert arr.shape[1] == 4
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ */
+  __pyx_v_npts = (__pyx_v_arr->dimensions[0]);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":147
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_npts); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 147, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 147, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 147, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 147, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 147, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":148
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ * 
+ */
+  __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":149
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cpp.PointXYZI *p
+ */
+  __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":152
+ * 
+ *         cdef cpp.PointXYZI *p
+ *         for i in range(npts):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.intensity = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+ */
+  __pyx_t_6 = __pyx_v_npts;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":153
+ *         cdef cpp.PointXYZI *p
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             p.x, p.y, p.z, p.intensity = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+ * 
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZI>(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":154
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.intensity = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_t_9 = 0;
+    if (__pyx_t_8 < 0) __pyx_t_8 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_9 < 0) __pyx_t_9 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_10 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = 1;
+    if (__pyx_t_11 < 0) __pyx_t_11 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_12 < 0) __pyx_t_12 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_13 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 2;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_16 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_17 = __pyx_v_i;
+    __pyx_t_18 = 3;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_19 = ((unsigned long)(*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_arr.diminfo[1].strides)));
+    __pyx_v_p->x = __pyx_t_10;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_16;
+    __pyx_v_p->intensity = __pyx_t_19;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":140
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.from_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":157
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_12to_array[] = "PointCloud_PointXYZI.to_array(self)\n\n        Return this object as a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_array (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_12to_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  npy_intp __pyx_v_n;
+  PyArrayObject *__pyx_v_result = 0;
+  struct pcl::PointXYZI *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_result;
+  __Pyx_Buffer __pyx_pybuffer_result;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  npy_intp __pyx_t_11;
+  npy_intp __pyx_t_12;
+  float __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  Py_ssize_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  __Pyx_RefNannySetupContext("to_array", 0);
+  __pyx_pybuffer_result.pybuffer.buf = NULL;
+  __pyx_pybuffer_result.refcount = 0;
+  __pyx_pybuffernd_result.data = NULL;
+  __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":162
+ *         """
+ *         cdef float x,y,z
+ *         cdef cnp.npy_intp n = self.thisptr().size()             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ *         cdef cpp.PointXYZI *p
+ */
+  __pyx_v_n = __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":166
+ *         cdef cpp.PointXYZI *p
+ * 
+ *         result = np.empty((n, 4), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_4);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 166, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(41, 166, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+    __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_7 < 0)) {
+      PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      }
+    }
+    __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_result.diminfo[1].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_result.diminfo[1].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(41, 166, __pyx_L1_error)
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_result = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":167
+ * 
+ *         result = np.empty((n, 4), dtype=np.float32)
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ */
+  __pyx_t_11 = __pyx_v_n;
+  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":168
+ *         result = np.empty((n, 4), dtype=np.float32)
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZI>(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":169
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x             # <<<<<<<<<<<<<<
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ */
+    __pyx_t_13 = __pyx_v_p->x;
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 0;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":170
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y             # <<<<<<<<<<<<<<
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.intensity
+ */
+    __pyx_t_13 = __pyx_v_p->y;
+    __pyx_t_16 = __pyx_v_i;
+    __pyx_t_17 = 1;
+    if (__pyx_t_16 < 0) __pyx_t_16 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":171
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z             # <<<<<<<<<<<<<<
+ *             result[i, 3] = p.intensity
+ *         return result
+ */
+    __pyx_t_13 = __pyx_v_p->z;
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_19 = 2;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_19 < 0) __pyx_t_19 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_19, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":172
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.intensity             # <<<<<<<<<<<<<<
+ *         return result
+ * 
+ */
+    __pyx_t_13 = __pyx_v_p->intensity;
+    __pyx_t_20 = __pyx_v_i;
+    __pyx_t_21 = 3;
+    if (__pyx_t_20 < 0) __pyx_t_20 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_21 < 0) __pyx_t_21 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":173
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.intensity
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":157
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":176
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 4-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_14from_list[] = "PointCloud_PointXYZI.from_list(self, _list)\n\n        Fill this pointcloud from a list of 4-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_14from_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((PyObject *)__pyx_v__list));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyObject *__pyx_v__list) {
+  Py_ssize_t __pyx_v_npts;
+  struct pcl::PointXYZI *__pyx_v_p;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_l = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *(*__pyx_t_11)(PyObject *);
+  float __pyx_t_12;
+  float __pyx_t_13;
+  float __pyx_t_14;
+  float __pyx_t_15;
+  __Pyx_RefNannySetupContext("from_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":180
+ *         Fill this pointcloud from a list of 4-tuples
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZI* p
+ *         self.resize(npts)
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v__list); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(41, 180, __pyx_L1_error)
+  __pyx_v_npts = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":182
+ *         cdef Py_ssize_t npts = len(_list)
+ *         cdef cpp.PointXYZI* p
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_npts); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 182, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 182, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 182, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 182, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 182, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":183
+ *         cdef cpp.PointXYZI* p
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ *         # OK
+ */
+  __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":184
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ *         # OK
+ *         # p = idx.getptr(self.thisptr(), 1)
+ */
+  __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":188
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.intensity = l
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v__list)) || PyTuple_CheckExact(__pyx_v__list)) {
+    __pyx_t_3 = __pyx_v__list; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v__list); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 188, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(41, 188, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(41, 188, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 188, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(41, 188, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 188, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      }
+    } else {
+      __pyx_t_6 = __pyx_t_7(__pyx_t_3);
+      if (unlikely(!__pyx_t_6)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(41, 188, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_6);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 188, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_6;
+    __pyx_t_6 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":189
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)             # <<<<<<<<<<<<<<
+ *              p.x, p.y, p.z, p.intensity = l
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(41, 189, __pyx_L1_error)
+    __pyx_v_p = getptr<struct pcl::PointXYZI>(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self), ((int)__pyx_t_8));
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":190
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.intensity = l             # <<<<<<<<<<<<<<
+ * 
+ *     def to_list(self):
+ */
+    if ((likely(PyTuple_CheckExact(__pyx_v_l))) || (PyList_CheckExact(__pyx_v_l))) {
+      PyObject* sequence = __pyx_v_l;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 4)) {
+        if (size > 4) __Pyx_RaiseTooManyValuesError(4);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(41, 190, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 3); 
+      } else {
+        __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyList_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyList_GET_ITEM(sequence, 3); 
+      }
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_9);
+      #else
+      {
+        Py_ssize_t i;
+        PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9};
+        for (i=0; i < 4; i++) {
+          PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(41, 190, __pyx_L1_error)
+          __Pyx_GOTREF(item);
+          *(temps[i]) = item;
+        }
+      }
+      #endif
+    } else {
+      Py_ssize_t index = -1;
+      PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9};
+      __pyx_t_10 = PyObject_GetIter(__pyx_v_l); if (unlikely(!__pyx_t_10)) __PYX_ERR(41, 190, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext;
+      for (index=0; index < 4; index++) {
+        PyObject* item = __pyx_t_11(__pyx_t_10); if (unlikely(!item)) goto __pyx_L5_unpacking_failed;
+        __Pyx_GOTREF(item);
+        *(temps[index]) = item;
+      }
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 4) < 0) __PYX_ERR(41, 190, __pyx_L1_error)
+      __pyx_t_11 = NULL;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      goto __pyx_L6_unpacking_done;
+      __pyx_L5_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __pyx_t_11 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(41, 190, __pyx_L1_error)
+      __pyx_L6_unpacking_done:;
+    }
+    __pyx_t_12 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_12 == (float)-1) && PyErr_Occurred())) __PYX_ERR(41, 190, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_13 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_13 == (float)-1) && PyErr_Occurred())) __PYX_ERR(41, 190, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_14 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_14 == (float)-1) && PyErr_Occurred())) __PYX_ERR(41, 190, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_15 = __pyx_PyFloat_AsFloat(__pyx_t_9); if (unlikely((__pyx_t_15 == (float)-1) && PyErr_Occurred())) __PYX_ERR(41, 190, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_v_p->x = __pyx_t_12;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_14;
+    __pyx_v_p->intensity = __pyx_t_15;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":188
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.intensity = l
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":176
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 4-tuples
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.from_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_l);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":192
+ *              p.x, p.y, p.z, p.intensity = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_16to_list[] = "PointCloud_PointXYZI.to_list(self)\n\n        Return this object as a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_16to_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("to_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":196
+ *         Return this object as a list of 3-tuples
+ *         """
+ *         return self.to_array().tolist()             # <<<<<<<<<<<<<<
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 196, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 196, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 196, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 196, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 196, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":192
+ *              p.x, p.y, p.z, p.intensity = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.to_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":198
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_18resize[] = "PointCloud_PointXYZI.resize(self, npy_intp x)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x) {
+  npy_intp __pyx_v_x;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
+  assert(__pyx_arg_x); {
+    __pyx_v_x = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_x); if (unlikely((__pyx_v_x == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(41, 198, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_18resize(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((npy_intp)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, npy_intp __pyx_v_x) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("resize", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":199
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":200
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 200, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(41, 200, __pyx_L1_error)
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":199
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":202
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+ */
+  try {
+    __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)->resize(__pyx_v_x);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 202, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":198
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":204
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_20get_point[] = "PointCloud_PointXYZI.get_point(self, npy_intp row, npy_intp col)\n\n        Return a point (3-tuple) at the given row/column\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  npy_intp __pyx_v_row;
+  npy_intp __pyx_v_col;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_col,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_row)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_col)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, 1); __PYX_ERR(41, 204, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_point") < 0)) __PYX_ERR(41, 204, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_row = __Pyx_PyInt_As_Py_intptr_t(values[0]); if (unlikely((__pyx_v_row == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(41, 204, __pyx_L3_error)
+    __pyx_v_col = __Pyx_PyInt_As_Py_intptr_t(values[1]); if (unlikely((__pyx_v_col == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(41, 204, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(41, 204, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_20get_point(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), __pyx_v_row, __pyx_v_col);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col) {
+  struct pcl::PointXYZI *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZI *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("get_point", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":208
+ *         Return a point (3-tuple) at the given row/column
+ *         """
+ *         cdef cpp.PointXYZI *p = idx.getptr_at2(self.thisptr(), row, col)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.intensity
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at2<struct pcl::PointXYZI>(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self), __pyx_v_row, __pyx_v_col);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 208, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":209
+ *         """
+ *         cdef cpp.PointXYZI *p = idx.getptr_at2(self.thisptr(), row, col)
+ *         return p.x, p.y, p.z, p.intensity             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->intensity); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 209, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":204
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":211
+ *         return p.x, p.y, p.z, p.intensity
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZI *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.intensity
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx) {
+  npy_intp __pyx_v_nmidx;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  assert(__pyx_arg_nmidx); {
+    __pyx_v_nmidx = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_nmidx); if (unlikely((__pyx_v_nmidx == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(41, 211, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_22__getitem__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((npy_intp)__pyx_v_nmidx));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, npy_intp __pyx_v_nmidx) {
+  struct pcl::PointXYZI *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZI *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":212
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZI *p = idx.getptr_at(self.thisptr(), nmidx)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.intensity
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at<struct pcl::PointXYZI>(__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self), __pyx_v_nmidx);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 212, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":213
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZI *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.intensity             # <<<<<<<<<<<<<<
+ * 
+ *     def from_file(self, char *f):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->intensity); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 213, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":211
+ *         return p.x, p.y, p.z, p.intensity
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZI *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.intensity
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":215
+ *         return p.x, p.y, p.z, p.intensity
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_24from_file[] = "PointCloud_PointXYZI.from_file(self, char *f)\n\n        Fill this pointcloud from a file (a local path).\n        Only pcd files supported currently.\n        \n        Deprecated; use pcl.load instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  char *__pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_file (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __Pyx_PyObject_AsString(__pyx_arg_f); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(41, 215, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_24from_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((char *)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char *__pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("from_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":222
+ *         Deprecated; use pcl.load instead.
+ *         """
+ *         return self._from_pcd_file(f)             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 222, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 222, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 222, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 222, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 222, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":215
+ *         return p.x, p.y, p.z, p.intensity
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":224
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_26_from_pcd_file[] = "PointCloud_PointXYZI._from_pcd_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_pcd_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(41, 224, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_26_from_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_error;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":225
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":226
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":229
+ *             # NG
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *         return error
+ * 
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(41, 229, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPCDFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(41, 229, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":226
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":230
+ *             # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_ply_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 230, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":224
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":232
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_28_from_ply_file[] = "PointCloud_PointXYZI._from_ply_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_ply_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(41, 232, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_28_from_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_ok;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":233
+ * 
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  __pyx_v_ok = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":234
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":237
+ *             # NG
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *         return ok
+ * 
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(41, 237, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPLYFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(41, 237, __pyx_L4_error)
+        }
+        __pyx_v_ok = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":234
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":238
+ *             # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *         return ok             # <<<<<<<<<<<<<<
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_ok); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 238, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":232
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":240
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_30to_file[] = "PointCloud_PointXYZI.to_file(self, const char *fname, bool ascii=True)\nSave pointcloud to a file in PCD format.\n\n        Deprecated: use pcl.save instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_fname;
+  bool __pyx_v_ascii;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fname,&__pyx_n_s_ascii,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fname)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ascii);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "to_file") < 0)) __PYX_ERR(41, 240, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_fname = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_fname) && PyErr_Occurred())) __PYX_ERR(41, 240, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_ascii = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_ascii == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(41, 240, __pyx_L3_error)
+    } else {
+      __pyx_v_ascii = ((bool)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("to_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(41, 240, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_30to_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), __pyx_v_fname, __pyx_v_ascii);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("to_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":245
+ *         Deprecated: use pcl.save instead.
+ *         """
+ *         return self._to_pcd_file(fname, not ascii)             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_fname); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyBool_FromLong((!(__pyx_v_ascii != 0))); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 245, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 245, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 245, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(41, 245, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_5) {
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 245, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":240
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":247
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_32_to_pcd_file[] = "PointCloud_PointXYZI._to_pcd_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_pcd_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_pcd_file") < 0)) __PYX_ERR(41, 247, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(41, 247, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(41, 247, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_pcd_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(41, 247, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_32_to_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":248
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":249
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 249, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":250
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":254
+ *             # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+ *             # OK
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *             # pclio.PointCloud[cpp.PointXYZI] *p = self.thisptr()
+ *             # error = pclio.savePCDFile(s, p, binary)
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePCDFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(41, 254, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":250
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":257
+ *             # pclio.PointCloud[cpp.PointXYZI] *p = self.thisptr()
+ *             # error = pclio.savePCDFile(s, p, binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 257, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":247
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":259
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_34_to_ply_file[] = "PointCloud_PointXYZI._to_ply_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_ply_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_ply_file") < 0)) __PYX_ERR(41, 259, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(41, 259, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(41, 259, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_ply_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(41, 259, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_34_to_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":260
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":261
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             # NG
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 261, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":262
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":265
+ *             # NG
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *         return error
+ * 
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePLYFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(41, 265, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":262
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             # NG
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":266
+ *             # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(41, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":259
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":268
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_36make_segmenter[] = "PointCloud_PointXYZI.make_segmenter(self)\n\n        Return a pcl.Segmentation object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_36make_segmenter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZI_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":272
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ *         """
+ *         seg = Segmentation_PointXYZI()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentation_PointXYZI_t *cseg = <pclseg.SACSegmentation_PointXYZI_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 272, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":273
+ *         """
+ *         seg = Segmentation_PointXYZI()
+ *         cdef pclseg.SACSegmentation_PointXYZI_t *cseg = <pclseg.SACSegmentation_PointXYZI_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZI_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":274
+ *         seg = Segmentation_PointXYZI()
+ *         cdef pclseg.SACSegmentation_PointXYZI_t *cseg = <pclseg.SACSegmentation_PointXYZI_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":275
+ *         cdef pclseg.SACSegmentation_PointXYZI_t *cseg = <pclseg.SACSegmentation_PointXYZI_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":268
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.make_segmenter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":277
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_38make_segmenter_normals[] = "PointCloud_PointXYZI.make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0)\n\n        Return a pcl.SegmentationNormal object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_v_ksearch;
+  double __pyx_v_searchRadius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter_normals (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksearch,&__pyx_n_s_searchRadius,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ksearch);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_searchRadius);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_segmenter_normals") < 0)) __PYX_ERR(41, 277, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    if (values[0]) {
+      __pyx_v_ksearch = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_ksearch == (int)-1) && PyErr_Occurred())) __PYX_ERR(41, 277, __pyx_L3_error)
+    } else {
+      __pyx_v_ksearch = ((int)-1);
+    }
+    if (values[1]) {
+      __pyx_v_searchRadius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_searchRadius == (double)-1) && PyErr_Occurred())) __PYX_ERR(41, 277, __pyx_L3_error)
+    } else {
+      __pyx_v_searchRadius = ((double)-1.0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("make_segmenter_normals", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(41, 277, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_38make_segmenter_normals(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), __pyx_v_ksearch, __pyx_v_searchRadius);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius) {
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t __pyx_v_normals;
+  struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZI_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter_normals", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":282
+ *         """
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         mpcl_compute_normals_PointXYZI(<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), ksearch, searchRadius, normals)             # <<<<<<<<<<<<<<
+ *         # p = self.thisptr()
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ */
+  try {
+    mpcl_compute_normals_PointXYZI(((pcl::PointCloud<struct pcl::PointXYZI> )(*__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_self))), __pyx_v_ksearch, __pyx_v_searchRadius, __pyx_v_normals);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 282, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":285
+ *         # p = self.thisptr()
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZI_Normal()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZI_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZI_Normal), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 285, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":286
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZI_Normal()
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZI_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZI_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":287
+ *         seg = Segmentation_PointXYZI_Normal()
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZI_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":288
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZI_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputNormals(__pyx_v_normals.makeShared());
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":289
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_statistical_outlier_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":277
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":291
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_40make_statistical_outlier_filter[] = "PointCloud_PointXYZI.make_statistical_outlier_filter(self)\n\n        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_40make_statistical_outlier_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZI_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":295
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ *         """
+ *         fil = StatisticalOutlierRemovalFilter_PointXYZI()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 295, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":296
+ *         """
+ *         fil = StatisticalOutlierRemovalFilter_PointXYZI()
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZI_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZI_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":297
+ *         fil = StatisticalOutlierRemovalFilter_PointXYZI()
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZI> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":298
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_voxel_grid_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":291
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.make_statistical_outlier_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":300
+ *         return fil
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_42make_voxel_grid_filter[] = "PointCloud_PointXYZI.make_voxel_grid_filter(self)\n\n        Return a pcl.VoxelGridFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_42make_voxel_grid_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZI_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":304
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ *         """
+ *         fil = VoxelGridFilter_PointXYZI()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.VoxelGrid_PointXYZI_t *cfil = <pclfil.VoxelGrid_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 304, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":305
+ *         """
+ *         fil = VoxelGridFilter_PointXYZI()
+ *         cdef pclfil.VoxelGrid_PointXYZI_t *cfil = <pclfil.VoxelGrid_PointXYZI_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZI_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":306
+ *         fil = VoxelGridFilter_PointXYZI()
+ *         cdef pclfil.VoxelGrid_PointXYZI_t *cfil = <pclfil.VoxelGrid_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZI> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":307
+ *         cdef pclfil.VoxelGrid_PointXYZI_t *cfil = <pclfil.VoxelGrid_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_passthrough_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":300
+ *         return fil
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.make_voxel_grid_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":309
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_45make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_44make_passthrough_filter[] = "PointCloud_PointXYZI.make_passthrough_filter(self)\n\n        Return a pcl.PassThroughFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_45make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_passthrough_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_44make_passthrough_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_44make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZI_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_passthrough_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":313
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ *         """
+ *         fil = PassThroughFilter_PointXYZI()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.PassThrough_PointXYZI_t *cfil = <pclfil.PassThrough_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 313, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":314
+ *         """
+ *         fil = PassThroughFilter_PointXYZI()
+ *         cdef pclfil.PassThrough_PointXYZI_t *cfil = <pclfil.PassThrough_PointXYZI_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZI_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":315
+ *         fil = PassThroughFilter_PointXYZI()
+ *         cdef pclfil.PassThrough_PointXYZI_t *cfil = <pclfil.PassThrough_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZI> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":316
+ *         cdef pclfil.PassThrough_PointXYZI_t *cfil = <pclfil.PassThrough_PointXYZI_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ * # Error(PointXYZI use?)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":309
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.make_passthrough_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":328
+ * #         return mls
+ * #
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_47make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_46make_kdtree_flann[] = "PointCloud_PointXYZI.make_kdtree_flann(self)\n\n        Return a pcl.kdTreeFLANN object with this object set as the input-cloud\n\n        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_47make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_kdtree_flann (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_46make_kdtree_flann(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_46make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_kdtree_flann", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":334
+ *         Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+ *         """
+ *         return KdTreeFLANN_PointXYZI(self)             # <<<<<<<<<<<<<<
+ * 
+ * #     def make_octree(self, double resolution):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 334, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZI), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 334, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":328
+ * #         return mls
+ * #
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.make_kdtree_flann", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZI_180.pxi":360
+ * #         return CropBox(self)
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_49extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_48extract[] = "PointCloud_PointXYZI.extract(self, pyindices, bool negative=False)\n\n        Given a list of indices of points in the pointcloud, return a \n        new pointcloud containing only those points.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_49extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_pyindices = 0;
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("extract (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyindices,&__pyx_n_s_negative,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyindices)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_negative);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "extract") < 0)) __PYX_ERR(41, 360, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pyindices = values[0];
+    if (values[1]) {
+      __pyx_v_negative = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(41, 360, __pyx_L3_error)
+    } else {
+      __pyx_v_negative = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("extract", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(41, 360, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_48extract(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_v_self), __pyx_v_pyindices, __pyx_v_negative);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_20PointCloud_PointXYZI_48extract(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_result = 0;
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_v_ind;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  __Pyx_RefNannySetupContext("extract", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":366
+ *         """
+ *         cdef PointCloud_PointXYZI result
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()             # <<<<<<<<<<<<<<
+ * 
+ *         for i in pyindices:
+ */
+  try {
+    __pyx_t_1 = new __pyx_t_3pcl_8pcl_defs_PointIndices_t();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 366, __pyx_L1_error)
+  }
+  __pyx_v_ind = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":368
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ * 
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ * 
+ */
+  if (likely(PyList_CheckExact(__pyx_v_pyindices)) || PyTuple_CheckExact(__pyx_v_pyindices)) {
+    __pyx_t_2 = __pyx_v_pyindices; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_pyindices); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 368, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 368, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(41, 368, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 368, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(41, 368, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 368, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(41, 368, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":369
+ * 
+ *         for i in pyindices:
+ *             ind.indices.push_back(i)             # <<<<<<<<<<<<<<
+ * 
+ *         result = PointCloud_PointXYZI()
+ */
+    __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(41, 369, __pyx_L1_error)
+    try {
+      __pyx_v_ind->indices.push_back(__pyx_t_6);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(41, 369, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":368
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ * 
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":371
+ *             ind.indices.push_back(i)
+ * 
+ *         result = PointCloud_PointXYZI()             # <<<<<<<<<<<<<<
+ *         # (<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr())
+ *         mpcl_extract_PointXYZI(self.thisptr_shared, result.thisptr(), ind, negative)
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 371, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_result = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":373
+ *         result = PointCloud_PointXYZI()
+ *         # (<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr())
+ *         mpcl_extract_PointXYZI(self.thisptr_shared, result.thisptr(), ind, negative)             # <<<<<<<<<<<<<<
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ * 
+ */
+  try {
+    mpcl_extract_PointXYZI(__pyx_v_self->thisptr_shared, __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_result), __pyx_v_ind, __pyx_v_negative);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(41, 373, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":376
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * ###
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":360
+ * #         return CropBox(self)
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZI.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":54
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointXYZRGB other
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_init = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_init,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_init);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(42, 54, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_init = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(42, 54, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB___cinit__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), __pyx_v_init);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_init) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_other = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  pcl::PointCloud<struct pcl::PointXYZRGB>  *__pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":57
+ *         cdef PointCloud_PointXYZRGB other
+ * 
+ *         self._view_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+ */
+  __pyx_v_self->_view_count = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":60
+ * 
+ *         # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())             # <<<<<<<<<<<<<<
+ * 
+ *         if init is None:
+ */
+  try {
+    __pyx_t_1 = new pcl::PointCloud<struct pcl::PointXYZRGB> ();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 60, __pyx_L1_error)
+  }
+  sp_assign<pcl::PointCloud<struct pcl::PointXYZRGB> >(__pyx_v_self->thisptr_shared, __pyx_t_1);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":62
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  __pyx_t_2 = (__pyx_v_init == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":63
+ * 
+ *         if init is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":62
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":64
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Integral); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_integer); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); 
+  __pyx_t_7 = (__pyx_t_2 != 0);
+  if (!__pyx_t_7) {
+  } else {
+    __pyx_t_3 = __pyx_t_7;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_7 = PyObject_IsInstance(__pyx_v_init, __pyx_t_6); 
+  __pyx_t_2 = (__pyx_t_7 != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":65
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 65, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 65, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 65, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 65, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(42, 65, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 65, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":64
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":66
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_init, __pyx_ptype_5numpy_ndarray); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":67
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_8) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 67, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 67, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 67, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 67, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 67, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":66
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":68
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(42, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":69
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_list); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 69, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 69, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 69, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 69, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(42, 69, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 69, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":68
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":70
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(42, 70, __pyx_L1_error)
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":71
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ *             other = init             # <<<<<<<<<<<<<<
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ */
+    if (!(likely(((__pyx_v_init) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_init, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB))))) __PYX_ERR(42, 71, __pyx_L1_error)
+    __pyx_t_5 = __pyx_v_init;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_v_other = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":72
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ */
+    (__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)[0]) = (__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_other)[0]);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":70
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":74
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+  /*else*/ {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":75
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ *                             % type(init))             # <<<<<<<<<<<<<<
+ * 
+ *     property width:
+ */
+    __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, ((PyObject *)Py_TYPE(__pyx_v_init))); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":74
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+    __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 74, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 74, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(42, 74, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":54
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointXYZRGB other
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_other);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":79
+ *     property width:
+ *         """ property containing the width of the point cloud """
+ *         def __get__(self): return self.thisptr().width             # <<<<<<<<<<<<<<
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_5width_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_5width_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_5width___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->width); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.width.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":82
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ *         def __get__(self): return self.thisptr().height             # <<<<<<<<<<<<<<
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_6height_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_6height_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_6height___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->height); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.height.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":85
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ *         def __get__(self): return self.thisptr().size()             # <<<<<<<<<<<<<<
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_4size_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_4size___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":88
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ *         def __get__(self): return self.thisptr().is_dense             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_8is_dense_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_8is_dense_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_8is_dense___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->is_dense); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.is_dense.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":90
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_2__repr__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":91
+ * 
+ *     def __repr__(self):
+ *         return "<PointCloud of %d points>" % self.size             # <<<<<<<<<<<<<<
+ * 
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_PointCloud_of_d_points, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":90
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":95
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_4__getbuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags) {
+  Py_ssize_t __pyx_v_npoints;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  struct pcl::PointXYZRGB *__pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_buffer != NULL) {
+    __pyx_v_buffer->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_buffer->obj);
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":97
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._view_count == 0:
+ */
+  __pyx_v_npoints = __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":99
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":100
+ * 
+ *         if self._view_count == 0:
+ *             self._view_count += 1             # <<<<<<<<<<<<<<
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 4
+ */
+    __pyx_v_self->_view_count = (__pyx_v_self->_view_count + 1);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":101
+ *         if self._view_count == 0:
+ *             self._view_count += 1
+ *             self._shape[0] = npoints             # <<<<<<<<<<<<<<
+ *             self._shape[1] = 4
+ * 
+ */
+    (__pyx_v_self->_shape[0]) = __pyx_v_npoints;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":102
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 4             # <<<<<<<<<<<<<<
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ */
+    (__pyx_v_self->_shape[1]) = 4;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":99
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":104
+ *             self._shape[1] = 4
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)             # <<<<<<<<<<<<<<
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ */
+  try {
+    __pyx_t_2 = getptr_at<struct pcl::PointXYZRGB>(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self), 0);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 104, __pyx_L1_error)
+  }
+  __pyx_v_buffer->buf = ((char *)(&__pyx_t_2->x));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":105
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'             # <<<<<<<<<<<<<<
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ */
+  __pyx_v_buffer->format = ((char *)"f");
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":106
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL             # <<<<<<<<<<<<<<
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)
+ */
+  __pyx_v_buffer->internal = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":107
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2
+ */
+  __pyx_v_buffer->itemsize = (sizeof(float));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":108
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ */
+  __pyx_v_buffer->len = ((__pyx_v_npoints * 4) * (sizeof(float)));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":109
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2             # <<<<<<<<<<<<<<
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ */
+  __pyx_v_buffer->ndim = 2;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":110
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2
+ *         buffer.obj = self             # <<<<<<<<<<<<<<
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  __Pyx_GOTREF(__pyx_v_buffer->obj);
+  __Pyx_DECREF(__pyx_v_buffer->obj);
+  __pyx_v_buffer->obj = ((PyObject *)__pyx_v_self);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":111
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ *         buffer.readonly = 0             # <<<<<<<<<<<<<<
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides_xyzrgb_3
+ */
+  __pyx_v_buffer->readonly = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":112
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape             # <<<<<<<<<<<<<<
+ *         buffer.strides = _strides_xyzrgb_3
+ *         buffer.suboffsets = NULL
+ */
+  __pyx_t_3 = __pyx_v_self->_shape;
+  __pyx_v_buffer->shape = __pyx_t_3;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":113
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides_xyzrgb_3             # <<<<<<<<<<<<<<
+ *         buffer.suboffsets = NULL
+ * 
+ */
+  __pyx_v_buffer->strides = __pyx_v_3pcl_4_pcl__strides_xyzrgb_3;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":114
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides_xyzrgb_3
+ *         buffer.suboffsets = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ */
+  __pyx_v_buffer->suboffsets = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":95
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_buffer->obj);
+    __Pyx_DECREF(__pyx_v_buffer->obj); __pyx_v_buffer->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_buffer->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":116
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_6__releasebuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":117
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ *         self._view_count -= 1             # <<<<<<<<<<<<<<
+ * 
+ *     # Pickle support. XXX this copies the entire pointcloud; it would be nice
+ */
+  __pyx_v_self->_view_count = (__pyx_v_self->_view_count - 1);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":116
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":122
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_8__reduce__[] = "PointCloud_PointXYZRGB.__reduce__(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_8__reduce__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__reduce__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":123
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):
+ *         return type(self), (self.to_array(),)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_origin:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 123, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 123, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":122
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":126
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_13sensor_origin_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_13sensor_origin_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_13sensor_origin___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  Eigen::Vector4f __pyx_v_origin;
+  float *__pyx_v_data;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Vector4f __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":127
+ *     property sensor_origin:
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_             # <<<<<<<<<<<<<<
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->sensor_origin_;
+  __pyx_v_origin = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":128
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()             # <<<<<<<<<<<<<<
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)
+ */
+  __pyx_v_data = __pyx_v_origin.data();
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":129
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble((__pyx_v_data[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyFloat_FromDouble((__pyx_v_data[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble((__pyx_v_data[2])); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble((__pyx_v_data[3])); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyList_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_7, 3, __pyx_t_6);
+  __pyx_t_2 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":130
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_orientation:
+ */
+  __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(42, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(42, 130, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":129
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":126
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.sensor_origin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":133
+ * 
+ *     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_
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_18sensor_orientation_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_18sensor_orientation_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_18sensor_orientation___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  Eigen::Quaternionf __pyx_v_o;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Quaternionf __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":135
+ *         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()])
+ * 
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->sensor_orientation_;
+  __pyx_v_o = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":136
+ *             # 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()])             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_o.w()); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_o.x()); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_o.y()); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_o.z()); if (unlikely(!__pyx_t_7)) __PYX_ERR(42, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyList_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(42, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyList_SET_ITEM(__pyx_t_8, 3, __pyx_t_7);
+  __pyx_t_3 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (!__pyx_t_7) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 136, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 136, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 136, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 136, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_8);
+      __pyx_t_8 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 136, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":133
+ * 
+ *     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_
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.sensor_orientation.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":139
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_10from_array[] = "PointCloud_PointXYZRGB.from_array(self, ndarray arr)\n\n        Fill this object from a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_array (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arr), __pyx_ptype_5numpy_ndarray, 0, "arr", 0))) __PYX_ERR(42, 139, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_10from_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((PyArrayObject *)__pyx_v_arr));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyArrayObject *__pyx_v_arr) {
+  npy_intp __pyx_v_npts;
+  struct pcl::PointXYZRGB *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_arr;
+  __Pyx_Buffer __pyx_pybuffer_arr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  npy_intp __pyx_t_6;
+  npy_intp __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  __pyx_t_5numpy_float32_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  __pyx_t_5numpy_float32_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  __pyx_t_5numpy_float32_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  unsigned long __pyx_t_19;
+  __Pyx_RefNannySetupContext("from_array", 0);
+  __pyx_pybuffer_arr.pybuffer.buf = NULL;
+  __pyx_pybuffer_arr.refcount = 0;
+  __pyx_pybuffernd_arr.data = NULL;
+  __pyx_pybuffernd_arr.rcbuffer = &__pyx_pybuffer_arr;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arr.rcbuffer->pybuffer, (PyObject*)__pyx_v_arr, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(42, 139, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_arr.diminfo[0].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arr.diminfo[0].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_arr.diminfo[1].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_arr.diminfo[1].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[1];
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":143
+ *         Fill this object from a 2D numpy array (float32)
+ *         """
+ *         assert arr.shape[1] == 4             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!(((__pyx_v_arr->dimensions[1]) == 4) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(42, 143, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":145
+ *         assert arr.shape[1] == 4
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ */
+  __pyx_v_npts = (__pyx_v_arr->dimensions[0]);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":146
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_npts); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 146, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":147
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ * 
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":148
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cpp.PointXYZRGB *p
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":151
+ * 
+ *         cdef cpp.PointXYZRGB *p
+ *         for i in range(npts):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.rgb = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+ */
+  __pyx_t_6 = __pyx_v_npts;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":152
+ *         cdef cpp.PointXYZRGB *p
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             p.x, p.y, p.z, p.rgb = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+ * 
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZRGB>(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":153
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.rgb = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_t_9 = 0;
+    if (__pyx_t_8 < 0) __pyx_t_8 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_9 < 0) __pyx_t_9 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_10 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = 1;
+    if (__pyx_t_11 < 0) __pyx_t_11 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_12 < 0) __pyx_t_12 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_13 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 2;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_16 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_17 = __pyx_v_i;
+    __pyx_t_18 = 3;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_19 = ((unsigned long)(*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_arr.diminfo[1].strides)));
+    __pyx_v_p->x = __pyx_t_10;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_16;
+    __pyx_v_p->rgb = __pyx_t_19;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":139
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.from_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":156
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_12to_array[] = "PointCloud_PointXYZRGB.to_array(self)\n\n        Return this object as a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_array (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_12to_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  npy_intp __pyx_v_n;
+  PyArrayObject *__pyx_v_result = 0;
+  struct pcl::PointXYZRGB *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_result;
+  __Pyx_Buffer __pyx_pybuffer_result;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  npy_intp __pyx_t_11;
+  npy_intp __pyx_t_12;
+  float __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  Py_ssize_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  __Pyx_RefNannySetupContext("to_array", 0);
+  __pyx_pybuffer_result.pybuffer.buf = NULL;
+  __pyx_pybuffer_result.refcount = 0;
+  __pyx_pybuffernd_result.data = NULL;
+  __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":161
+ *         """
+ *         cdef float x,y,z
+ *         cdef cnp.npy_intp n = self.thisptr().size()             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ *         cdef cpp.PointXYZRGB *p
+ */
+  __pyx_v_n = __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":165
+ *         cdef cpp.PointXYZRGB *p
+ * 
+ *         result = np.empty((n, 4), dtype=np.float32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n):
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_4);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(42, 165, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+    __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_7 < 0)) {
+      PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      }
+    }
+    __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_result.diminfo[1].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_result.diminfo[1].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(42, 165, __pyx_L1_error)
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_result = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":167
+ *         result = np.empty((n, 4), dtype=np.float32)
+ * 
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ */
+  __pyx_t_11 = __pyx_v_n;
+  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":168
+ * 
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZRGB>(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":169
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x             # <<<<<<<<<<<<<<
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ */
+    __pyx_t_13 = __pyx_v_p->x;
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 0;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":170
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y             # <<<<<<<<<<<<<<
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.rgb
+ */
+    __pyx_t_13 = __pyx_v_p->y;
+    __pyx_t_16 = __pyx_v_i;
+    __pyx_t_17 = 1;
+    if (__pyx_t_16 < 0) __pyx_t_16 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":171
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z             # <<<<<<<<<<<<<<
+ *             result[i, 3] = p.rgb
+ *         return result
+ */
+    __pyx_t_13 = __pyx_v_p->z;
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_19 = 2;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_19 < 0) __pyx_t_19 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_19, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":172
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.rgb             # <<<<<<<<<<<<<<
+ *         return result
+ * 
+ */
+    __pyx_t_13 = __pyx_v_p->rgb;
+    __pyx_t_20 = __pyx_v_i;
+    __pyx_t_21 = 3;
+    if (__pyx_t_20 < 0) __pyx_t_20 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_21 < 0) __pyx_t_21 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":173
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.rgb
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":156
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":176
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 4-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_14from_list[] = "PointCloud_PointXYZRGB.from_list(self, _list)\n\n        Fill this pointcloud from a list of 4-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_14from_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((PyObject *)__pyx_v__list));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v__list) {
+  Py_ssize_t __pyx_v_npts;
+  struct pcl::PointXYZRGB *__pyx_v_p;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_l = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *(*__pyx_t_11)(PyObject *);
+  float __pyx_t_12;
+  float __pyx_t_13;
+  float __pyx_t_14;
+  float __pyx_t_15;
+  __Pyx_RefNannySetupContext("from_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":180
+ *         Fill this pointcloud from a list of 4-tuples
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZRGB *p
+ *         self.resize(npts)
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v__list); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(42, 180, __pyx_L1_error)
+  __pyx_v_npts = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":182
+ *         cdef Py_ssize_t npts = len(_list)
+ *         cdef cpp.PointXYZRGB *p
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_npts); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 182, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 182, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 182, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 182, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 182, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":183
+ *         cdef cpp.PointXYZRGB *p
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ *         for i, l in enumerate(_list):
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":184
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ *         for i, l in enumerate(_list):
+ *             p = idx.getptr(self.thisptr(), <int> i)
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":185
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), <int> i)
+ *             p.x, p.y, p.z, p.rgb = l
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v__list)) || PyTuple_CheckExact(__pyx_v__list)) {
+    __pyx_t_3 = __pyx_v__list; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v__list); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(42, 185, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(42, 185, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(42, 185, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      }
+    } else {
+      __pyx_t_6 = __pyx_t_7(__pyx_t_3);
+      if (unlikely(!__pyx_t_6)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(42, 185, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_6);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_6;
+    __pyx_t_6 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":186
+ *         self.thisptr().height = 1
+ *         for i, l in enumerate(_list):
+ *             p = idx.getptr(self.thisptr(), <int> i)             # <<<<<<<<<<<<<<
+ *             p.x, p.y, p.z, p.rgb = l
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(42, 186, __pyx_L1_error)
+    __pyx_v_p = getptr<struct pcl::PointXYZRGB>(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self), ((int)__pyx_t_8));
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":187
+ *         for i, l in enumerate(_list):
+ *             p = idx.getptr(self.thisptr(), <int> i)
+ *             p.x, p.y, p.z, p.rgb = l             # <<<<<<<<<<<<<<
+ * 
+ *     def to_list(self):
+ */
+    if ((likely(PyTuple_CheckExact(__pyx_v_l))) || (PyList_CheckExact(__pyx_v_l))) {
+      PyObject* sequence = __pyx_v_l;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 4)) {
+        if (size > 4) __Pyx_RaiseTooManyValuesError(4);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(42, 187, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 3); 
+      } else {
+        __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyList_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyList_GET_ITEM(sequence, 3); 
+      }
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_9);
+      #else
+      {
+        Py_ssize_t i;
+        PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9};
+        for (i=0; i < 4; i++) {
+          PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(42, 187, __pyx_L1_error)
+          __Pyx_GOTREF(item);
+          *(temps[i]) = item;
+        }
+      }
+      #endif
+    } else {
+      Py_ssize_t index = -1;
+      PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9};
+      __pyx_t_10 = PyObject_GetIter(__pyx_v_l); if (unlikely(!__pyx_t_10)) __PYX_ERR(42, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext;
+      for (index=0; index < 4; index++) {
+        PyObject* item = __pyx_t_11(__pyx_t_10); if (unlikely(!item)) goto __pyx_L5_unpacking_failed;
+        __Pyx_GOTREF(item);
+        *(temps[index]) = item;
+      }
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 4) < 0) __PYX_ERR(42, 187, __pyx_L1_error)
+      __pyx_t_11 = NULL;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      goto __pyx_L6_unpacking_done;
+      __pyx_L5_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __pyx_t_11 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(42, 187, __pyx_L1_error)
+      __pyx_L6_unpacking_done:;
+    }
+    __pyx_t_12 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_12 == (float)-1) && PyErr_Occurred())) __PYX_ERR(42, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_13 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_13 == (float)-1) && PyErr_Occurred())) __PYX_ERR(42, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_14 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_14 == (float)-1) && PyErr_Occurred())) __PYX_ERR(42, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_15 = __pyx_PyFloat_AsFloat(__pyx_t_9); if (unlikely((__pyx_t_15 == (float)-1) && PyErr_Occurred())) __PYX_ERR(42, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_v_p->x = __pyx_t_12;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_14;
+    __pyx_v_p->rgb = __pyx_t_15;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":185
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), <int> i)
+ *             p.x, p.y, p.z, p.rgb = l
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":176
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 4-tuples
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.from_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_l);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":189
+ *             p.x, p.y, p.z, p.rgb = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_16to_list[] = "PointCloud_PointXYZRGB.to_list(self)\n\n        Return this object as a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_16to_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("to_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":193
+ *         Return this object as a list of 3-tuples
+ *         """
+ *         return self.to_array().tolist()             # <<<<<<<<<<<<<<
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 193, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 193, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 193, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 193, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":189
+ *             p.x, p.y, p.z, p.rgb = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.to_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":195
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_18resize[] = "PointCloud_PointXYZRGB.resize(self, npy_intp x)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x) {
+  npy_intp __pyx_v_x;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
+  assert(__pyx_arg_x); {
+    __pyx_v_x = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_x); if (unlikely((__pyx_v_x == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(42, 195, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_18resize(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((npy_intp)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, npy_intp __pyx_v_x) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("resize", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":196
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":197
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 197, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(42, 197, __pyx_L1_error)
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":196
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":199
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+ */
+  try {
+    __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)->resize(__pyx_v_x);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 199, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":195
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":201
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_20get_point[] = "PointCloud_PointXYZRGB.get_point(self, npy_intp row, npy_intp col)\n\n        Return a point (3-tuple) at the given row/column\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  npy_intp __pyx_v_row;
+  npy_intp __pyx_v_col;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_col,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_row)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_col)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, 1); __PYX_ERR(42, 201, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_point") < 0)) __PYX_ERR(42, 201, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_row = __Pyx_PyInt_As_Py_intptr_t(values[0]); if (unlikely((__pyx_v_row == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(42, 201, __pyx_L3_error)
+    __pyx_v_col = __Pyx_PyInt_As_Py_intptr_t(values[1]); if (unlikely((__pyx_v_col == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(42, 201, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(42, 201, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_20get_point(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), __pyx_v_row, __pyx_v_col);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col) {
+  struct pcl::PointXYZRGB *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZRGB *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("get_point", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":205
+ *         Return a point (3-tuple) at the given row/column
+ *         """
+ *         cdef cpp.PointXYZRGB *p = idx.getptr_at2(self.thisptr(), row, col)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.rgb
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at2<struct pcl::PointXYZRGB>(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self), __pyx_v_row, __pyx_v_col);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 205, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":206
+ *         """
+ *         cdef cpp.PointXYZRGB *p = idx.getptr_at2(self.thisptr(), row, col)
+ *         return p.x, p.y, p.z, p.rgb             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->rgb); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":201
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":208
+ *         return p.x, p.y, p.z, p.rgb
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZRGB *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.rgb
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx) {
+  npy_intp __pyx_v_nmidx;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  assert(__pyx_arg_nmidx); {
+    __pyx_v_nmidx = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_nmidx); if (unlikely((__pyx_v_nmidx == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(42, 208, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_22__getitem__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((npy_intp)__pyx_v_nmidx));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, npy_intp __pyx_v_nmidx) {
+  struct pcl::PointXYZRGB *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZRGB *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":209
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZRGB *p = idx.getptr_at(self.thisptr(), nmidx)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.rgb
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at<struct pcl::PointXYZRGB>(__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self), __pyx_v_nmidx);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 209, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":210
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZRGB *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.rgb             # <<<<<<<<<<<<<<
+ * 
+ *     def from_file(self, char *f):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->rgb); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":208
+ *         return p.x, p.y, p.z, p.rgb
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZRGB *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.rgb
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":212
+ *         return p.x, p.y, p.z, p.rgb
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_24from_file[] = "PointCloud_PointXYZRGB.from_file(self, char *f)\n\n        Fill this pointcloud from a file (a local path).\n        Only pcd files supported currently.\n\n        Deprecated; use pcl.load instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  char *__pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_file (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __Pyx_PyObject_AsString(__pyx_arg_f); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(42, 212, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_24from_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((char *)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char *__pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("from_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":219
+ *         Deprecated; use pcl.load instead.
+ *         """
+ *         return self._from_pcd_file(f)             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 219, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 219, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 219, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 219, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 219, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":212
+ *         return p.x, p.y, p.z, p.rgb
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":221
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_26_from_pcd_file[] = "PointCloud_PointXYZRGB._from_pcd_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_pcd_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(42, 221, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_26_from_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_error;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":222
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":223
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":224
+ *         cdef int error = 0
+ *         with nogil:
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ *             # error = cpp.loadPCDFile(string(s), p)
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(42, 224, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPCDFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(42, 224, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":223
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":227
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ *             # error = cpp.loadPCDFile(string(s), p)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_ply_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":221
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":229
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_28_from_ply_file[] = "PointCloud_PointXYZRGB._from_ply_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_ply_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(42, 229, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_28_from_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_ok;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":230
+ * 
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ */
+  __pyx_v_ok = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":231
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":232
+ *         cdef int ok = 0
+ *         with nogil:
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ *             # ok = cpp.loadPLYFile(string(s), p)
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(42, 232, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPLYFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(42, 232, __pyx_L4_error)
+        }
+        __pyx_v_ok = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":231
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":235
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ *             # ok = cpp.loadPLYFile(string(s), p)
+ *         return ok             # <<<<<<<<<<<<<<
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_ok); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":229
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":237
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_30to_file[] = "PointCloud_PointXYZRGB.to_file(self, const char *fname, bool ascii=True)\nSave pointcloud to a file in PCD format.\n\n        Deprecated: use pcl.save instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_fname;
+  bool __pyx_v_ascii;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fname,&__pyx_n_s_ascii,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fname)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ascii);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "to_file") < 0)) __PYX_ERR(42, 237, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_fname = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_fname) && PyErr_Occurred())) __PYX_ERR(42, 237, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_ascii = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_ascii == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(42, 237, __pyx_L3_error)
+    } else {
+      __pyx_v_ascii = ((bool)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("to_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(42, 237, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_30to_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), __pyx_v_fname, __pyx_v_ascii);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("to_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":242
+ *         Deprecated: use pcl.save instead.
+ *         """
+ *         return self._to_pcd_file(fname, not ascii)             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_fname); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyBool_FromLong((!(__pyx_v_ascii != 0))); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(42, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_5) {
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":237
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":244
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_32_to_pcd_file[] = "PointCloud_PointXYZRGB._to_pcd_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_pcd_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_pcd_file") < 0)) __PYX_ERR(42, 244, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(42, 244, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(42, 244, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_pcd_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(42, 244, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_32_to_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":245
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":246
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 246, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":247
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":248
+ *         cdef string s = string(f)
+ *         with nogil:
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *
+ *             # error = cpp.savePCDFile(s, p, binary)
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePCDFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(42, 248, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":247
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":251
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *
+ *             # error = cpp.savePCDFile(s, p, binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 251, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":244
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":253
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_34_to_ply_file[] = "PointCloud_PointXYZRGB._to_ply_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_ply_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_ply_file") < 0)) __PYX_ERR(42, 253, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(42, 253, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(42, 253, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_ply_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(42, 253, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_34_to_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":254
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":255
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 255, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":256
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":257
+ *         cdef string s = string(f)
+ *         with nogil:
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ *             # error = cpp.savePLYFile(s, p, binary)
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePLYFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(42, 257, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":256
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":260
+ *             # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+ *             # error = cpp.savePLYFile(s, p, binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(42, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":253
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":262
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_36make_segmenter[] = "PointCloud_PointXYZRGB.make_segmenter(self)\n\n        Return a pcl.Segmentation object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_36make_segmenter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGB_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":266
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ *         """
+ *         seg = Segmentation_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentation_PointXYZRGB_t *cseg = <pclseg.SACSegmentation_PointXYZRGB_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":267
+ *         """
+ *         seg = Segmentation_PointXYZRGB()
+ *         cdef pclseg.SACSegmentation_PointXYZRGB_t *cseg = <pclseg.SACSegmentation_PointXYZRGB_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGB_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":268
+ *         seg = Segmentation_PointXYZRGB()
+ *         cdef pclseg.SACSegmentation_PointXYZRGB_t *cseg = <pclseg.SACSegmentation_PointXYZRGB_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":269
+ *         cdef pclseg.SACSegmentation_PointXYZRGB_t *cseg = <pclseg.SACSegmentation_PointXYZRGB_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":262
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_segmenter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":271
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_38make_segmenter_normals[] = "PointCloud_PointXYZRGB.make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0)\n\n        Return a pcl.SegmentationNormal object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_v_ksearch;
+  double __pyx_v_searchRadius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter_normals (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksearch,&__pyx_n_s_searchRadius,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ksearch);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_searchRadius);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_segmenter_normals") < 0)) __PYX_ERR(42, 271, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    if (values[0]) {
+      __pyx_v_ksearch = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_ksearch == (int)-1) && PyErr_Occurred())) __PYX_ERR(42, 271, __pyx_L3_error)
+    } else {
+      __pyx_v_ksearch = ((int)-1);
+    }
+    if (values[1]) {
+      __pyx_v_searchRadius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_searchRadius == (double)-1) && PyErr_Occurred())) __PYX_ERR(42, 271, __pyx_L3_error)
+    } else {
+      __pyx_v_searchRadius = ((double)-1.0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("make_segmenter_normals", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(42, 271, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_38make_segmenter_normals(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), __pyx_v_ksearch, __pyx_v_searchRadius);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius) {
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t __pyx_v_normals;
+  CYTHON_UNUSED pcl::PointCloud<struct pcl::PointXYZRGB>  *__pyx_v_p;
+  struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGB_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter_normals", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":276
+ *         """
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         p = self.thisptr()             # <<<<<<<<<<<<<<
+ *         mpcl_compute_normals_PointXYZRGB(<cpp.PointCloud[cpp.PointXYZRGB]> deref(self.thisptr()), ksearch, searchRadius, normals)
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ */
+  __pyx_v_p = __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":277
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         p = self.thisptr()
+ *         mpcl_compute_normals_PointXYZRGB(<cpp.PointCloud[cpp.PointXYZRGB]> deref(self.thisptr()), ksearch, searchRadius, normals)             # <<<<<<<<<<<<<<
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZRGB_Normal()
+ */
+  try {
+    mpcl_compute_normals_PointXYZRGB(((pcl::PointCloud<struct pcl::PointXYZRGB> )(*__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_self))), __pyx_v_ksearch, __pyx_v_searchRadius, __pyx_v_normals);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 277, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":279
+ *         mpcl_compute_normals_PointXYZRGB(<cpp.PointCloud[cpp.PointXYZRGB]> deref(self.thisptr()), ksearch, searchRadius, normals)
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZRGB_Normal()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGB_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 279, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":280
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZRGB_Normal()
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGB_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGB_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":281
+ *         seg = Segmentation_PointXYZRGB_Normal()
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGB_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":282
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGB_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputNormals(__pyx_v_normals.makeShared());
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":283
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_statistical_outlier_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":271
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":285
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_40make_statistical_outlier_filter[] = "PointCloud_PointXYZRGB.make_statistical_outlier_filter(self)\n\n        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_40make_statistical_outlier_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGB_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":289
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ *         """
+ *         fil = StatisticalOutlierRemovalFilter_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":290
+ *         """
+ *         fil = StatisticalOutlierRemovalFilter_PointXYZRGB()
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGB_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":291
+ *         fil = StatisticalOutlierRemovalFilter_PointXYZRGB()
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGB> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":292
+ *         cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_voxel_grid_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":285
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_statistical_outlier_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":294
+ *         return fil
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_42make_voxel_grid_filter[] = "PointCloud_PointXYZRGB.make_voxel_grid_filter(self)\n\n        Return a pcl.VoxelGridFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_42make_voxel_grid_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGB_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":298
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ *         """
+ *         fil = VoxelGridFilter_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.VoxelGrid_PointXYZRGB_t *cfil = <pclfil.VoxelGrid_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":299
+ *         """
+ *         fil = VoxelGridFilter_PointXYZRGB()
+ *         cdef pclfil.VoxelGrid_PointXYZRGB_t *cfil = <pclfil.VoxelGrid_PointXYZRGB_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGB_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":300
+ *         fil = VoxelGridFilter_PointXYZRGB()
+ *         cdef pclfil.VoxelGrid_PointXYZRGB_t *cfil = <pclfil.VoxelGrid_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGB> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":301
+ *         cdef pclfil.VoxelGrid_PointXYZRGB_t *cfil = <pclfil.VoxelGrid_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_passthrough_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":294
+ *         return fil
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_voxel_grid_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":303
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_45make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_44make_passthrough_filter[] = "PointCloud_PointXYZRGB.make_passthrough_filter(self)\n\n        Return a pcl.PassThroughFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_45make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_passthrough_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_44make_passthrough_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_44make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGB_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_passthrough_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":307
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ *         """
+ *         fil = PassThroughFilter_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.PassThrough_PointXYZRGB_t *cfil = <pclfil.PassThrough_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":308
+ *         """
+ *         fil = PassThroughFilter_PointXYZRGB()
+ *         cdef pclfil.PassThrough_PointXYZRGB_t *cfil = <pclfil.PassThrough_PointXYZRGB_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGB_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":309
+ *         fil = PassThroughFilter_PointXYZRGB()
+ *         cdef pclfil.PassThrough_PointXYZRGB_t *cfil = <pclfil.PassThrough_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGB> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":310
+ *         cdef pclfil.PassThrough_PointXYZRGB_t *cfil = <pclfil.PassThrough_PointXYZRGB_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_moving_least_squares(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":303
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_passthrough_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":312
+ *         return fil
+ * 
+ *     def make_moving_least_squares(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_47make_moving_least_squares(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_46make_moving_least_squares[] = "PointCloud_PointXYZRGB.make_moving_least_squares(self)\n\n        Return a pcl.MovingLeastSquares object with this object as input cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_47make_moving_least_squares(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_moving_least_squares (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_46make_moving_least_squares(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_46make_moving_least_squares(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *__pyx_v_mls = NULL;
+  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGB_t *__pyx_v_cmls;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_moving_least_squares", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":316
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ *         """
+ *         mls = MovingLeastSquares_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGB_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGB_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_mls = ((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":317
+ *         """
+ *         mls = MovingLeastSquares_PointXYZRGB()
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGB_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGB_t *>mls.me             # <<<<<<<<<<<<<<
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return mls
+ */
+  __pyx_v_cmls = ((__pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGB_t *)__pyx_v_mls->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":318
+ *         mls = MovingLeastSquares_PointXYZRGB()
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGB_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGB_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return mls
+ * 
+ */
+  __pyx_v_cmls->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGB> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":319
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGB_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGB_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+ *         return mls             # <<<<<<<<<<<<<<
+ * 
+ *     def make_kdtree_flann(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_mls));
+  __pyx_r = ((PyObject *)__pyx_v_mls);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":312
+ *         return fil
+ * 
+ *     def make_moving_least_squares(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_moving_least_squares", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_mls);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":321
+ *         return mls
+ * 
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_49make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_48make_kdtree_flann[] = "PointCloud_PointXYZRGB.make_kdtree_flann(self)\n\n        Return a pcl.kdTreeFLANN object with this object set as the input-cloud\n        \n        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_49make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_kdtree_flann (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_48make_kdtree_flann(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_48make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_kdtree_flann", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":327
+ *         Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+ *         """
+ *         return KdTreeFLANN_PointXYZRGB(self)             # <<<<<<<<<<<<<<
+ * 
+ * #     def make_octree(self, double resolution):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 327, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 327, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":321
+ *         return mls
+ * 
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.make_kdtree_flann", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":337
+ * #         return octree
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_51extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_50extract[] = "PointCloud_PointXYZRGB.extract(self, pyindices, bool negative=False)\n\n        Given a list of indices of points in the pointcloud, return a \n        new pointcloud containing only those points.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_51extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_pyindices = 0;
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("extract (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyindices,&__pyx_n_s_negative,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyindices)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_negative);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "extract") < 0)) __PYX_ERR(42, 337, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pyindices = values[0];
+    if (values[1]) {
+      __pyx_v_negative = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(42, 337, __pyx_L3_error)
+    } else {
+      __pyx_v_negative = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("extract", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(42, 337, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_50extract(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_v_self), __pyx_v_pyindices, __pyx_v_negative);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointXYZRGB_50extract(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_result = 0;
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_v_ind;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  __Pyx_RefNannySetupContext("extract", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":343
+ *         """
+ *         cdef PointCloud_PointXYZRGB result
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()             # <<<<<<<<<<<<<<
+ * 
+ *         for i in pyindices:
+ */
+  try {
+    __pyx_t_1 = new __pyx_t_3pcl_8pcl_defs_PointIndices_t();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 343, __pyx_L1_error)
+  }
+  __pyx_v_ind = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":345
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ * 
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ * 
+ */
+  if (likely(PyList_CheckExact(__pyx_v_pyindices)) || PyTuple_CheckExact(__pyx_v_pyindices)) {
+    __pyx_t_2 = __pyx_v_pyindices; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_pyindices); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 345, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 345, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(42, 345, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 345, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(42, 345, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 345, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(42, 345, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":346
+ * 
+ *         for i in pyindices:
+ *             ind.indices.push_back(i)             # <<<<<<<<<<<<<<
+ * 
+ *         result = PointCloud_PointXYZRGB()
+ */
+    __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(42, 346, __pyx_L1_error)
+    try {
+      __pyx_v_ind->indices.push_back(__pyx_t_6);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(42, 346, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":345
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ * 
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ * 
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":348
+ *             ind.indices.push_back(i)
+ * 
+ *         result = PointCloud_PointXYZRGB()             # <<<<<<<<<<<<<<
+ *         mpcl_extract_PointXYZRGB(self.thisptr_shared, result.thisptr(), ind, negative)
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 348, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_result = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":349
+ * 
+ *         result = PointCloud_PointXYZRGB()
+ *         mpcl_extract_PointXYZRGB(self.thisptr_shared, result.thisptr(), ind, negative)             # <<<<<<<<<<<<<<
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ * 
+ */
+  try {
+    mpcl_extract_PointXYZRGB(__pyx_v_self->thisptr_shared, __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_result), __pyx_v_ind, __pyx_v_negative);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(42, 349, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":352
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ * 
+ *         return result             # <<<<<<<<<<<<<<
+ * ###
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":337
+ * #         return octree
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGB.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":54
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointXYZRGBA other
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_init = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_init,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_init);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(43, 54, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_init = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(43, 54, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA___cinit__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), __pyx_v_init);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_init) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_other = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  pcl::PointCloud<struct pcl::PointXYZRGBA>  *__pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":57
+ *         cdef PointCloud_PointXYZRGBA other
+ * 
+ *         self._view_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+ */
+  __pyx_v_self->_view_count = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":60
+ * 
+ *         # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())             # <<<<<<<<<<<<<<
+ * 
+ *         if init is None:
+ */
+  try {
+    __pyx_t_1 = new pcl::PointCloud<struct pcl::PointXYZRGBA> ();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 60, __pyx_L1_error)
+  }
+  sp_assign<pcl::PointCloud<struct pcl::PointXYZRGBA> >(__pyx_v_self->thisptr_shared, __pyx_t_1);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":62
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  __pyx_t_2 = (__pyx_v_init == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":63
+ * 
+ *         if init is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":62
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":64
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Integral); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_integer); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); 
+  __pyx_t_7 = (__pyx_t_2 != 0);
+  if (!__pyx_t_7) {
+  } else {
+    __pyx_t_3 = __pyx_t_7;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_7 = PyObject_IsInstance(__pyx_v_init, __pyx_t_6); 
+  __pyx_t_2 = (__pyx_t_7 != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":65
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 65, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 65, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 65, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 65, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(43, 65, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 65, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":64
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":66
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_init, __pyx_ptype_5numpy_ndarray); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":67
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 67, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_8) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 67, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 67, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 67, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 67, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 67, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":66
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":68
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(43, 68, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":69
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_list); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 69, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 69, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 69, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 69, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(43, 69, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 69, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":68
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":70
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(43, 70, __pyx_L1_error)
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":71
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ *             other = init             # <<<<<<<<<<<<<<
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ */
+    if (!(likely(((__pyx_v_init) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_init, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA))))) __PYX_ERR(43, 71, __pyx_L1_error)
+    __pyx_t_5 = __pyx_v_init;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_v_other = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":72
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ */
+    (__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)[0]) = (__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_other)[0]);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":70
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":74
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+  /*else*/ {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":75
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ *                             % type(init))             # <<<<<<<<<<<<<<
+ * 
+ *     property width:
+ */
+    __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, ((PyObject *)Py_TYPE(__pyx_v_init))); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 75, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":74
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+    __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 74, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 74, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(43, 74, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":54
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointXYZRGBA other
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_other);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":79
+ *     property width:
+ *         """ property containing the width of the point cloud """
+ *         def __get__(self): return self.thisptr().width             # <<<<<<<<<<<<<<
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5width_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5width_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5width___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->width); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 79, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.width.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":82
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ *         def __get__(self): return self.thisptr().height             # <<<<<<<<<<<<<<
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6height_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6height_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6height___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->height); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 82, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.height.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":85
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ *         def __get__(self): return self.thisptr().size()             # <<<<<<<<<<<<<<
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4size_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4size___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 85, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":88
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ *         def __get__(self): return self.thisptr().is_dense             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8is_dense_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8is_dense_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8is_dense___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->is_dense); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 88, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.is_dense.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":90
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_2__repr__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":91
+ * 
+ *     def __repr__(self):
+ *         return "<PointCloud of %d points>" % self.size             # <<<<<<<<<<<<<<
+ * 
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_PointCloud_of_d_points, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 91, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":90
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":95
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4__getbuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4__getbuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, Py_buffer *__pyx_v_buffer, CYTHON_UNUSED int __pyx_v_flags) {
+  Py_ssize_t __pyx_v_npoints;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  struct pcl::PointXYZRGBA *__pyx_t_2;
+  Py_ssize_t *__pyx_t_3;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_buffer != NULL) {
+    __pyx_v_buffer->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_buffer->obj);
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":97
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()             # <<<<<<<<<<<<<<
+ * 
+ *         if self._view_count == 0:
+ */
+  __pyx_v_npoints = __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":99
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count == 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":100
+ * 
+ *         if self._view_count == 0:
+ *             self._view_count += 1             # <<<<<<<<<<<<<<
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 4
+ */
+    __pyx_v_self->_view_count = (__pyx_v_self->_view_count + 1);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":101
+ *         if self._view_count == 0:
+ *             self._view_count += 1
+ *             self._shape[0] = npoints             # <<<<<<<<<<<<<<
+ *             self._shape[1] = 4
+ * 
+ */
+    (__pyx_v_self->_shape[0]) = __pyx_v_npoints;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":102
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ *             self._shape[1] = 4             # <<<<<<<<<<<<<<
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ */
+    (__pyx_v_self->_shape[1]) = 4;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":99
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ * 
+ *         if self._view_count == 0:             # <<<<<<<<<<<<<<
+ *             self._view_count += 1
+ *             self._shape[0] = npoints
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":104
+ *             self._shape[1] = 4
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)             # <<<<<<<<<<<<<<
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ */
+  try {
+    __pyx_t_2 = getptr_at<struct pcl::PointXYZRGBA>(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self), 0);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 104, __pyx_L1_error)
+  }
+  __pyx_v_buffer->buf = ((char *)(&__pyx_t_2->x));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":105
+ * 
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'             # <<<<<<<<<<<<<<
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ */
+  __pyx_v_buffer->format = ((char *)"f");
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":106
+ *         buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL             # <<<<<<<<<<<<<<
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)
+ */
+  __pyx_v_buffer->internal = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":107
+ *         buffer.format = 'f'
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2
+ */
+  __pyx_v_buffer->itemsize = (sizeof(float));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":108
+ *         buffer.internal = NULL
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)             # <<<<<<<<<<<<<<
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ */
+  __pyx_v_buffer->len = ((__pyx_v_npoints * 4) * (sizeof(float)));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":109
+ *         buffer.itemsize = sizeof(float)
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2             # <<<<<<<<<<<<<<
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ */
+  __pyx_v_buffer->ndim = 2;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":110
+ *         buffer.len = npoints * 4 * sizeof(float)
+ *         buffer.ndim = 2
+ *         buffer.obj = self             # <<<<<<<<<<<<<<
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ */
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  __Pyx_GOTREF(__pyx_v_buffer->obj);
+  __Pyx_DECREF(__pyx_v_buffer->obj);
+  __pyx_v_buffer->obj = ((PyObject *)__pyx_v_self);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":111
+ *         buffer.ndim = 2
+ *         buffer.obj = self
+ *         buffer.readonly = 0             # <<<<<<<<<<<<<<
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides
+ */
+  __pyx_v_buffer->readonly = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":112
+ *         buffer.obj = self
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape             # <<<<<<<<<<<<<<
+ *         buffer.strides = _strides
+ *         buffer.suboffsets = NULL
+ */
+  __pyx_t_3 = __pyx_v_self->_shape;
+  __pyx_v_buffer->shape = __pyx_t_3;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":113
+ *         buffer.readonly = 0
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides             # <<<<<<<<<<<<<<
+ *         buffer.suboffsets = NULL
+ * 
+ */
+  __pyx_v_buffer->strides = __pyx_v_3pcl_4_pcl__strides;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":114
+ *         buffer.shape = self._shape
+ *         buffer.strides = _strides
+ *         buffer.suboffsets = NULL             # <<<<<<<<<<<<<<
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ */
+  __pyx_v_buffer->suboffsets = NULL;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":95
+ *     # Buffer protocol support. Taking a view locks the pointcloud for
+ *     # resizing, because that can move it around in memory.
+ *     def __getbuffer__(self, Py_buffer *buffer, int flags):             # <<<<<<<<<<<<<<
+ *         # TODO parse flags
+ *         cdef Py_ssize_t npoints = self.thisptr().size()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_buffer->obj);
+    __Pyx_DECREF(__pyx_v_buffer->obj); __pyx_v_buffer->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_buffer != NULL && __pyx_v_buffer->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_buffer->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":116
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_7__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6__releasebuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":117
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ *         self._view_count -= 1             # <<<<<<<<<<<<<<
+ * 
+ *     # Pickle support. XXX this copies the entire pointcloud; it would be nice
+ */
+  __pyx_v_self->_view_count = (__pyx_v_self->_view_count - 1);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":116
+ *         buffer.suboffsets = NULL
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":122
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8__reduce__[] = "PointCloud_PointXYZRGBA.__reduce__(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_9__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8__reduce__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__reduce__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":123
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):
+ *         return type(self), (self.to_array(),)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_origin:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 123, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 123, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":122
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":126
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13sensor_origin_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13sensor_origin_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13sensor_origin___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13sensor_origin___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  Eigen::Vector4f __pyx_v_origin;
+  float *__pyx_v_data;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Vector4f __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":127
+ *     property sensor_origin:
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_             # <<<<<<<<<<<<<<
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->sensor_origin_;
+  __pyx_v_origin = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":128
+ *         def __get__(self):
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()             # <<<<<<<<<<<<<<
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)
+ */
+  __pyx_v_data = __pyx_v_origin.data();
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":129
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyFloat_FromDouble((__pyx_v_data[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_4 = PyFloat_FromDouble((__pyx_v_data[1])); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble((__pyx_v_data[2])); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble((__pyx_v_data[3])); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyList_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_7, 3, __pyx_t_6);
+  __pyx_t_2 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
+  __pyx_t_7 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":130
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],
+ *                             dtype=np.float32)             # <<<<<<<<<<<<<<
+ * 
+ *     property sensor_orientation:
+ */
+  __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(43, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_float32); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_dtype, __pyx_t_4) < 0) __PYX_ERR(43, 130, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":129
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ *             return np.array([data[0], data[1], data[2], data[3]],             # <<<<<<<<<<<<<<
+ *                             dtype=np.float32)
+ * 
+ */
+  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_4;
+  __pyx_t_4 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":126
+ * 
+ *     property sensor_origin:
+ *         def __get__(self):             # <<<<<<<<<<<<<<
+ *             cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+ *             cdef float *data = origin.data()
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.sensor_origin.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":133
+ * 
+ *     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_
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18sensor_orientation_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18sensor_orientation_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18sensor_orientation___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18sensor_orientation___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  Eigen::Quaternionf __pyx_v_o;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Eigen::Quaternionf __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":135
+ *         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()])
+ * 
+ */
+  __pyx_t_1 = __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->sensor_orientation_;
+  __pyx_v_o = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":136
+ *             # 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()])             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_o.w()); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_o.x()); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_o.y()); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_o.z()); if (unlikely(!__pyx_t_7)) __PYX_ERR(43, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyList_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(43, 136, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyList_SET_ITEM(__pyx_t_8, 0, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyList_SET_ITEM(__pyx_t_8, 1, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_8, 2, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyList_SET_ITEM(__pyx_t_8, 3, __pyx_t_7);
+  __pyx_t_3 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_t_7 = NULL;
+  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
+    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
+    if (likely(__pyx_t_7)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_7);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_4, function);
+    }
+  }
+  if (!__pyx_t_7) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 136, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 136, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_8};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 136, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 136, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
+      __Pyx_GIVEREF(__pyx_t_8);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_8);
+      __pyx_t_8 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 136, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":133
+ * 
+ *     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_
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.sensor_orientation.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":139
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_10from_array[] = "PointCloud_PointXYZRGBA.from_array(self, ndarray arr)\n\n        Fill this object from a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_11from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_array (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arr), __pyx_ptype_5numpy_ndarray, 0, "arr", 0))) __PYX_ERR(43, 139, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_10from_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((PyArrayObject *)__pyx_v_arr));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_10from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyArrayObject *__pyx_v_arr) {
+  npy_intp __pyx_v_npts;
+  struct pcl::PointXYZRGBA *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_arr;
+  __Pyx_Buffer __pyx_pybuffer_arr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  npy_intp __pyx_t_6;
+  npy_intp __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  __pyx_t_5numpy_float32_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  __pyx_t_5numpy_float32_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  __pyx_t_5numpy_float32_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  unsigned long __pyx_t_19;
+  __Pyx_RefNannySetupContext("from_array", 0);
+  __pyx_pybuffer_arr.pybuffer.buf = NULL;
+  __pyx_pybuffer_arr.refcount = 0;
+  __pyx_pybuffernd_arr.data = NULL;
+  __pyx_pybuffernd_arr.rcbuffer = &__pyx_pybuffer_arr;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arr.rcbuffer->pybuffer, (PyObject*)__pyx_v_arr, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(43, 139, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_arr.diminfo[0].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arr.diminfo[0].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_arr.diminfo[1].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_arr.diminfo[1].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[1];
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":143
+ *         Fill this object from a 2D numpy array (float32)
+ *         """
+ *         assert arr.shape[1] == 4             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!(((__pyx_v_arr->dimensions[1]) == 4) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(43, 143, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":145
+ *         assert arr.shape[1] == 4
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ */
+  __pyx_v_npts = (__pyx_v_arr->dimensions[0]);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":146
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_npts); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 146, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 146, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 146, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":147
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ * 
+ */
+  __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":148
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cpp.PointXYZRGBA *p
+ */
+  __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":151
+ * 
+ *         cdef cpp.PointXYZRGBA *p
+ *         for i in range(npts):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.rgba = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+ */
+  __pyx_t_6 = __pyx_v_npts;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":152
+ *         cdef cpp.PointXYZRGBA *p
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             p.x, p.y, p.z, p.rgba = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+ * 
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZRGBA>(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":153
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.rgba = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_t_9 = 0;
+    if (__pyx_t_8 < 0) __pyx_t_8 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_9 < 0) __pyx_t_9 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_10 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = 1;
+    if (__pyx_t_11 < 0) __pyx_t_11 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_12 < 0) __pyx_t_12 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_13 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 2;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_16 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_17 = __pyx_v_i;
+    __pyx_t_18 = 3;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_19 = ((unsigned long)(*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_arr.diminfo[1].strides)));
+    __pyx_v_p->x = __pyx_t_10;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_16;
+    __pyx_v_p->rgba = __pyx_t_19;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":139
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.from_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":156
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_12to_array[] = "PointCloud_PointXYZRGBA.to_array(self)\n\n        Return this object as a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_array (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_12to_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_12to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  npy_intp __pyx_v_n;
+  PyArrayObject *__pyx_v_result = 0;
+  struct pcl::PointXYZRGBA *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_result;
+  __Pyx_Buffer __pyx_pybuffer_result;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  npy_intp __pyx_t_11;
+  npy_intp __pyx_t_12;
+  float __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  Py_ssize_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  __Pyx_RefNannySetupContext("to_array", 0);
+  __pyx_pybuffer_result.pybuffer.buf = NULL;
+  __pyx_pybuffer_result.refcount = 0;
+  __pyx_pybuffernd_result.data = NULL;
+  __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":161
+ *         """
+ *         cdef float x,y,z
+ *         cdef cnp.npy_intp n = self.thisptr().size()             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ *         cdef cpp.PointXYZRGBA *p
+ */
+  __pyx_v_n = __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":165
+ *         cdef cpp.PointXYZRGBA *p
+ * 
+ *         result = np.empty((n, 4), dtype=np.float32)             # <<<<<<<<<<<<<<
+ * 
+ *         for i in range(n):
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_4);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 165, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(43, 165, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+    __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_7 < 0)) {
+      PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      }
+    }
+    __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_result.diminfo[1].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_result.diminfo[1].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(43, 165, __pyx_L1_error)
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_result = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":167
+ *         result = np.empty((n, 4), dtype=np.float32)
+ * 
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ */
+  __pyx_t_11 = __pyx_v_n;
+  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":168
+ * 
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ */
+    __pyx_v_p = getptr<struct pcl::PointXYZRGBA>(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":169
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x             # <<<<<<<<<<<<<<
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ */
+    __pyx_t_13 = __pyx_v_p->x;
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 0;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":170
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y             # <<<<<<<<<<<<<<
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.rgba
+ */
+    __pyx_t_13 = __pyx_v_p->y;
+    __pyx_t_16 = __pyx_v_i;
+    __pyx_t_17 = 1;
+    if (__pyx_t_16 < 0) __pyx_t_16 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":171
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z             # <<<<<<<<<<<<<<
+ *             result[i, 3] = p.rgba
+ *         return result
+ */
+    __pyx_t_13 = __pyx_v_p->z;
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_19 = 2;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_19 < 0) __pyx_t_19 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_19, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":172
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.rgba             # <<<<<<<<<<<<<<
+ *         return result
+ * 
+ */
+    __pyx_t_13 = __pyx_v_p->rgba;
+    __pyx_t_20 = __pyx_v_i;
+    __pyx_t_21 = 3;
+    if (__pyx_t_20 < 0) __pyx_t_20 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_21 < 0) __pyx_t_21 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":173
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.rgba
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":156
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":176
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *        """
+ *        Fill this pointcloud from a list of 4-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_14from_list[] = "PointCloud_PointXYZRGBA.from_list(self, _list)\n\n       Fill this pointcloud from a list of 4-tuples\n       ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_15from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_14from_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((PyObject *)__pyx_v__list));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_14from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v__list) {
+  Py_ssize_t __pyx_v_npts;
+  struct pcl::PointXYZRGBA *__pyx_v_p;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_l = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *(*__pyx_t_11)(PyObject *);
+  float __pyx_t_12;
+  float __pyx_t_13;
+  float __pyx_t_14;
+  float __pyx_t_15;
+  __Pyx_RefNannySetupContext("from_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":180
+ *        Fill this pointcloud from a list of 4-tuples
+ *        """
+ *        cdef Py_ssize_t npts = len(_list)             # <<<<<<<<<<<<<<
+ *        cdef cpp.PointXYZRGBA *p
+ *        self.resize(npts)
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v__list); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(43, 180, __pyx_L1_error)
+  __pyx_v_npts = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":182
+ *        cdef Py_ssize_t npts = len(_list)
+ *        cdef cpp.PointXYZRGBA *p
+ *        self.resize(npts)             # <<<<<<<<<<<<<<
+ *        self.thisptr().width = npts
+ *        self.thisptr().height = 1
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_npts); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 182, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 182, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 182, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 182, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 182, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 182, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":183
+ *        cdef cpp.PointXYZRGBA *p
+ *        self.resize(npts)
+ *        self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *        self.thisptr().height = 1
+ *        for i, l in enumerate(_list):
+ */
+  __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":184
+ *        self.resize(npts)
+ *        self.thisptr().width = npts
+ *        self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ *        for i, l in enumerate(_list):
+ *            p = idx.getptr(self.thisptr(), <int> i)
+ */
+  __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":185
+ *        self.thisptr().width = npts
+ *        self.thisptr().height = 1
+ *        for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *            p = idx.getptr(self.thisptr(), <int> i)
+ *            p.x, p.y, p.z, p.rgba = l
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v__list)) || PyTuple_CheckExact(__pyx_v__list)) {
+    __pyx_t_3 = __pyx_v__list; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v__list); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(43, 185, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(43, 185, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(43, 185, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 185, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      }
+    } else {
+      __pyx_t_6 = __pyx_t_7(__pyx_t_3);
+      if (unlikely(!__pyx_t_6)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(43, 185, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_6);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 185, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_6;
+    __pyx_t_6 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":186
+ *        self.thisptr().height = 1
+ *        for i, l in enumerate(_list):
+ *            p = idx.getptr(self.thisptr(), <int> i)             # <<<<<<<<<<<<<<
+ *            p.x, p.y, p.z, p.rgba = l
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(43, 186, __pyx_L1_error)
+    __pyx_v_p = getptr<struct pcl::PointXYZRGBA>(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self), ((int)__pyx_t_8));
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":187
+ *        for i, l in enumerate(_list):
+ *            p = idx.getptr(self.thisptr(), <int> i)
+ *            p.x, p.y, p.z, p.rgba = l             # <<<<<<<<<<<<<<
+ * 
+ *     def to_list(self):
+ */
+    if ((likely(PyTuple_CheckExact(__pyx_v_l))) || (PyList_CheckExact(__pyx_v_l))) {
+      PyObject* sequence = __pyx_v_l;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 4)) {
+        if (size > 4) __Pyx_RaiseTooManyValuesError(4);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(43, 187, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 3); 
+      } else {
+        __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyList_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyList_GET_ITEM(sequence, 3); 
+      }
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_9);
+      #else
+      {
+        Py_ssize_t i;
+        PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9};
+        for (i=0; i < 4; i++) {
+          PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(43, 187, __pyx_L1_error)
+          __Pyx_GOTREF(item);
+          *(temps[i]) = item;
+        }
+      }
+      #endif
+    } else {
+      Py_ssize_t index = -1;
+      PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9};
+      __pyx_t_10 = PyObject_GetIter(__pyx_v_l); if (unlikely(!__pyx_t_10)) __PYX_ERR(43, 187, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_10);
+      __pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext;
+      for (index=0; index < 4; index++) {
+        PyObject* item = __pyx_t_11(__pyx_t_10); if (unlikely(!item)) goto __pyx_L5_unpacking_failed;
+        __Pyx_GOTREF(item);
+        *(temps[index]) = item;
+      }
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 4) < 0) __PYX_ERR(43, 187, __pyx_L1_error)
+      __pyx_t_11 = NULL;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      goto __pyx_L6_unpacking_done;
+      __pyx_L5_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+      __pyx_t_11 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(43, 187, __pyx_L1_error)
+      __pyx_L6_unpacking_done:;
+    }
+    __pyx_t_12 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_12 == (float)-1) && PyErr_Occurred())) __PYX_ERR(43, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_13 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_13 == (float)-1) && PyErr_Occurred())) __PYX_ERR(43, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_14 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_14 == (float)-1) && PyErr_Occurred())) __PYX_ERR(43, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_15 = __pyx_PyFloat_AsFloat(__pyx_t_9); if (unlikely((__pyx_t_15 == (float)-1) && PyErr_Occurred())) __PYX_ERR(43, 187, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_v_p->x = __pyx_t_12;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_14;
+    __pyx_v_p->rgba = __pyx_t_15;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":185
+ *        self.thisptr().width = npts
+ *        self.thisptr().height = 1
+ *        for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *            p = idx.getptr(self.thisptr(), <int> i)
+ *            p.x, p.y, p.z, p.rgba = l
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":176
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *        """
+ *        Fill this pointcloud from a list of 4-tuples
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.from_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_l);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":189
+ *            p.x, p.y, p.z, p.rgba = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_16to_list[] = "PointCloud_PointXYZRGBA.to_list(self)\n\n        Return this object as a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_17to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_16to_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_16to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("to_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":193
+ *         Return this object as a list of 3-tuples
+ *         """
+ *         return self.to_array().tolist()             # <<<<<<<<<<<<<<
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 193, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 193, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 193, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 193, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 193, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":189
+ *            p.x, p.y, p.z, p.rgba = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.to_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":195
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18resize[] = "PointCloud_PointXYZRGBA.resize(self, npy_intp x)";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_19resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x) {
+  npy_intp __pyx_v_x;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
+  assert(__pyx_arg_x); {
+    __pyx_v_x = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_x); if (unlikely((__pyx_v_x == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(43, 195, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18resize(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((npy_intp)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, npy_intp __pyx_v_x) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("resize", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":196
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":197
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 197, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(43, 197, __pyx_L1_error)
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":196
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":199
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+ */
+  try {
+    __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)->resize(__pyx_v_x);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 199, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":195
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":201
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_20get_point[] = "PointCloud_PointXYZRGBA.get_point(self, npy_intp row, npy_intp col)\n\n        Return a point (3-tuple) at the given row/column\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_21get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  npy_intp __pyx_v_row;
+  npy_intp __pyx_v_col;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_col,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_row)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_col)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, 1); __PYX_ERR(43, 201, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_point") < 0)) __PYX_ERR(43, 201, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_row = __Pyx_PyInt_As_Py_intptr_t(values[0]); if (unlikely((__pyx_v_row == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(43, 201, __pyx_L3_error)
+    __pyx_v_col = __Pyx_PyInt_As_Py_intptr_t(values[1]); if (unlikely((__pyx_v_col == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(43, 201, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(43, 201, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_20get_point(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), __pyx_v_row, __pyx_v_col);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_20get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col) {
+  struct pcl::PointXYZRGBA *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZRGBA *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("get_point", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":205
+ *         Return a point (3-tuple) at the given row/column
+ *         """
+ *         cdef cpp.PointXYZRGBA *p = idx.getptr_at2(self.thisptr(), row, col)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.rgba
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at2<struct pcl::PointXYZRGBA>(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self), __pyx_v_row, __pyx_v_col);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 205, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":206
+ *         """
+ *         cdef cpp.PointXYZRGBA *p = idx.getptr_at2(self.thisptr(), row, col)
+ *         return p.x, p.y, p.z, p.rgba             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->rgba); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 206, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":201
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":208
+ *         return p.x, p.y, p.z, p.rgba
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZRGBA *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.rgba
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_23__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx) {
+  npy_intp __pyx_v_nmidx;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  assert(__pyx_arg_nmidx); {
+    __pyx_v_nmidx = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_nmidx); if (unlikely((__pyx_v_nmidx == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(43, 208, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_22__getitem__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((npy_intp)__pyx_v_nmidx));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_22__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, npy_intp __pyx_v_nmidx) {
+  struct pcl::PointXYZRGBA *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointXYZRGBA *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":209
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZRGBA *p = idx.getptr_at(self.thisptr(), nmidx)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.rgba
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at<struct pcl::PointXYZRGBA>(__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self), __pyx_v_nmidx);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 209, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":210
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointXYZRGBA *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.rgba             # <<<<<<<<<<<<<<
+ * 
+ *     def from_file(self, char *f):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->rgba); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 210, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_5);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_r = __pyx_t_6;
+  __pyx_t_6 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":208
+ *         return p.x, p.y, p.z, p.rgba
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointXYZRGBA *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.rgba
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":212
+ *         return p.x, p.y, p.z, p.rgba
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_24from_file[] = "PointCloud_PointXYZRGBA.from_file(self, char *f)\n\n        Fill this pointcloud from a file (a local path).\n        Only pcd files supported currently.\n\n        Deprecated; use pcl.load instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_25from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  char *__pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_file (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __Pyx_PyObject_AsString(__pyx_arg_f); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(43, 212, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_24from_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((char *)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_24from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char *__pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("from_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":219
+ *         Deprecated; use pcl.load instead.
+ *         """
+ *         return self._from_pcd_file(f)             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 219, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 219, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 219, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 219, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 219, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 219, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":212
+ *         return p.x, p.y, p.z, p.rgba
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":221
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_26_from_pcd_file[] = "PointCloud_PointXYZRGBA._from_pcd_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_27_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_pcd_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(43, 221, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_26_from_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_26_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_error;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":222
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":223
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":224
+ *         cdef int error = 0
+ *         with nogil:
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ *             # error = cpp.loadPCDFile(string(s), p)
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(43, 224, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPCDFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(43, 224, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":223
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":227
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ *             # error = cpp.loadPCDFile(string(s), p)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_ply_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 227, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":221
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":229
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_28_from_ply_file[] = "PointCloud_PointXYZRGBA._from_ply_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_29_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_ply_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(43, 229, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_28_from_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_28_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_ok;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":230
+ * 
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ */
+  __pyx_v_ok = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":231
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":232
+ *         cdef int ok = 0
+ *         with nogil:
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ *             # ok = cpp.loadPLYFile(string(s), p)
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(43, 232, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPLYFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(43, 232, __pyx_L4_error)
+        }
+        __pyx_v_ok = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":231
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":235
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ *             # ok = cpp.loadPLYFile(string(s), p)
+ *         return ok             # <<<<<<<<<<<<<<
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_ok); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 235, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":229
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":237
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_30to_file[] = "PointCloud_PointXYZRGBA.to_file(self, const char *fname, bool ascii=True)\nSave pointcloud to a file in PCD format.\n\n        Deprecated: use pcl.save instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_31to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_fname;
+  bool __pyx_v_ascii;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fname,&__pyx_n_s_ascii,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fname)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ascii);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "to_file") < 0)) __PYX_ERR(43, 237, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_fname = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_fname) && PyErr_Occurred())) __PYX_ERR(43, 237, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_ascii = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_ascii == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(43, 237, __pyx_L3_error)
+    } else {
+      __pyx_v_ascii = ((bool)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("to_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(43, 237, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_30to_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), __pyx_v_fname, __pyx_v_ascii);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_30to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("to_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":242
+ *         Deprecated: use pcl.save instead.
+ *         """
+ *         return self._to_pcd_file(fname, not ascii)             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_fname); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyBool_FromLong((!(__pyx_v_ascii != 0))); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 242, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 242, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(43, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_5) {
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 242, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":237
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """Save pointcloud to a file in PCD format.
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":244
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_32_to_pcd_file[] = "PointCloud_PointXYZRGBA._to_pcd_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_33_to_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_pcd_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_pcd_file") < 0)) __PYX_ERR(43, 244, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(43, 244, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(43, 244, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_pcd_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(43, 244, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_32_to_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_32_to_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":245
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":246
+ *     def _to_pcd_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 246, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":247
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":248
+ *         cdef string s = string(f)
+ *         with nogil:
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *
+ *             # error = cpp.savePCDFile(s, p, binary)
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePCDFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(43, 248, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":247
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":251
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *
+ *             # error = cpp.savePCDFile(s, p, binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 251, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":244
+ *         return self._to_pcd_file(fname, not ascii)
+ * 
+ *     def _to_pcd_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._to_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":253
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_34_to_ply_file[] = "PointCloud_PointXYZRGBA._to_ply_file(self, const char *f, bool binary=False)";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_35_to_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_f;
+  bool __pyx_v_binary;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_to_ply_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_f,&__pyx_n_s_binary,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_f)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_binary);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_to_ply_file") < 0)) __PYX_ERR(43, 253, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_f = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(43, 253, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_binary = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_binary == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(43, 253, __pyx_L3_error)
+    } else {
+      __pyx_v_binary = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("_to_ply_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(43, 253, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_34_to_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), __pyx_v_f, __pyx_v_binary);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_34_to_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, char const *__pyx_v_f, bool __pyx_v_binary) {
+  int __pyx_v_error;
+  std::string __pyx_v_s;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_to_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":254
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         cdef string s = string(f)
+ *         with nogil:
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":255
+ *     def _to_ply_file(self, const char *f, bool binary=False):
+ *         cdef int error = 0
+ *         cdef string s = string(f)             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ */
+  try {
+    __pyx_t_1 = std::string(__pyx_v_f);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 255, __pyx_L1_error)
+  }
+  __pyx_v_s = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":256
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":257
+ *         cdef string s = string(f)
+ *         with nogil:
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)             # <<<<<<<<<<<<<<
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ *             # error = cpp.savePLYFile(s, p, binary)
+ */
+        try {
+          __pyx_t_2 = pcl::io::savePLYFile(__pyx_v_s, (*__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self)), __pyx_v_binary);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(43, 257, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":256
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":260
+ *             # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+ *             # error = cpp.savePLYFile(s, p, binary)
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(43, 260, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":253
+ *         return error
+ * 
+ *     def _to_ply_file(self, const char *f, bool binary=False):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         cdef string s = string(f)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA._to_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":262
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_36make_segmenter[] = "PointCloud_PointXYZRGBA.make_segmenter(self)\n\n        Return a pcl.Segmentation object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_37make_segmenter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_36make_segmenter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_36make_segmenter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGBA_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":266
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ *         """
+ *         seg = Segmentation_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentation_PointXYZRGBA_t *cseg = <pclseg.SACSegmentation_PointXYZRGBA_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 266, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":267
+ *         """
+ *         seg = Segmentation_PointXYZRGBA()
+ *         cdef pclseg.SACSegmentation_PointXYZRGBA_t *cseg = <pclseg.SACSegmentation_PointXYZRGBA_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentation_PointXYZRGBA_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":268
+ *         seg = Segmentation_PointXYZRGBA()
+ *         cdef pclseg.SACSegmentation_PointXYZRGBA_t *cseg = <pclseg.SACSegmentation_PointXYZRGBA_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":269
+ *         cdef pclseg.SACSegmentation_PointXYZRGBA_t *cseg = <pclseg.SACSegmentation_PointXYZRGBA_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":262
+ *         return error
+ * 
+ *     def make_segmenter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.Segmentation object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_segmenter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":271
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_38make_segmenter_normals[] = "PointCloud_PointXYZRGBA.make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0)\n\n        Return a pcl.SegmentationNormal object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_39make_segmenter_normals(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  int __pyx_v_ksearch;
+  double __pyx_v_searchRadius;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_segmenter_normals (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ksearch,&__pyx_n_s_searchRadius,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ksearch);
+          if (value) { values[0] = value; kw_args--; }
+        }
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_searchRadius);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "make_segmenter_normals") < 0)) __PYX_ERR(43, 271, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    if (values[0]) {
+      __pyx_v_ksearch = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_ksearch == (int)-1) && PyErr_Occurred())) __PYX_ERR(43, 271, __pyx_L3_error)
+    } else {
+      __pyx_v_ksearch = ((int)-1);
+    }
+    if (values[1]) {
+      __pyx_v_searchRadius = __pyx_PyFloat_AsDouble(values[1]); if (unlikely((__pyx_v_searchRadius == (double)-1) && PyErr_Occurred())) __PYX_ERR(43, 271, __pyx_L3_error)
+    } else {
+      __pyx_v_searchRadius = ((double)-1.0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("make_segmenter_normals", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(43, 271, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_38make_segmenter_normals(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), __pyx_v_ksearch, __pyx_v_searchRadius);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_38make_segmenter_normals(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, int __pyx_v_ksearch, double __pyx_v_searchRadius) {
+  __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_t __pyx_v_normals;
+  CYTHON_UNUSED pcl::PointCloud<struct pcl::PointXYZRGBA>  *__pyx_v_p;
+  struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *__pyx_v_seg = NULL;
+  __pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGBA_t *__pyx_v_cseg;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_segmenter_normals", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":276
+ *         """
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         p = self.thisptr()             # <<<<<<<<<<<<<<
+ *         mpcl_compute_normals_PointXYZRGBA(<cpp.PointCloud[cpp.PointXYZRGBA]> deref(self.thisptr()), ksearch, searchRadius, normals)
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ */
+  __pyx_v_p = __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":277
+ *         cdef cpp.PointCloud_Normal_t normals
+ *         p = self.thisptr()
+ *         mpcl_compute_normals_PointXYZRGBA(<cpp.PointCloud[cpp.PointXYZRGBA]> deref(self.thisptr()), ksearch, searchRadius, normals)             # <<<<<<<<<<<<<<
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZRGBA_Normal()
+ */
+  try {
+    mpcl_compute_normals_PointXYZRGBA(((pcl::PointCloud<struct pcl::PointXYZRGBA> )(*__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_self))), __pyx_v_ksearch, __pyx_v_searchRadius, __pyx_v_normals);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 277, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":279
+ *         mpcl_compute_normals_PointXYZRGBA(<cpp.PointCloud[cpp.PointXYZRGBA]> deref(self.thisptr()), ksearch, searchRadius, normals)
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZRGBA_Normal()             # <<<<<<<<<<<<<<
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 279, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_seg = ((struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":280
+ *         # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+ *         seg = Segmentation_PointXYZRGBA_Normal()
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *>seg.me             # <<<<<<<<<<<<<<
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ */
+  __pyx_v_cseg = ((__pyx_t_3pcl_20pcl_segmentation_180_SACSegmentationFromNormals_PointXYZRGBA_t *)__pyx_v_seg->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":281
+ *         seg = Segmentation_PointXYZRGBA_Normal()
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg
+ */
+  __pyx_v_cseg->setInputCloud(__pyx_v_self->thisptr_shared);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":282
+ *         cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *>seg.me
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());             # <<<<<<<<<<<<<<
+ *         return seg
+ * 
+ */
+  __pyx_v_cseg->setInputNormals(__pyx_v_normals.makeShared());
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":283
+ *         cseg.setInputCloud(self.thisptr_shared)
+ *         cseg.setInputNormals (normals.makeShared());
+ *         return seg             # <<<<<<<<<<<<<<
+ * 
+ *     def make_statistical_outlier_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_seg));
+  __pyx_r = ((PyObject *)__pyx_v_seg);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":271
+ *         return seg
+ * 
+ *     def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.SegmentationNormal object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_segmenter_normals", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_seg);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":285
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *          """
+ *          Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_40make_statistical_outlier_filter[] = "PointCloud_PointXYZRGBA.make_statistical_outlier_filter(self)\n\n         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud\n         ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_41make_statistical_outlier_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_40make_statistical_outlier_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_40make_statistical_outlier_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGBA_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_statistical_outlier_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":289
+ *          Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ *          """
+ *          fil = StatisticalOutlierRemovalFilter_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *          cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *>fil.me
+ *          cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 289, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":290
+ *          """
+ *          fil = StatisticalOutlierRemovalFilter_PointXYZRGBA()
+ *          cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *>fil.me             # <<<<<<<<<<<<<<
+ *          cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *          return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_StatisticalOutlierRemoval_PointXYZRGBA_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":291
+ *          fil = StatisticalOutlierRemovalFilter_PointXYZRGBA()
+ *          cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *>fil.me
+ *          cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *          return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGBA> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":292
+ *          cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *>fil.me
+ *          cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *          return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_voxel_grid_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":285
+ *         return seg
+ * 
+ *     def make_statistical_outlier_filter(self):             # <<<<<<<<<<<<<<
+ *          """
+ *          Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_statistical_outlier_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":294
+ *          return fil
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_42make_voxel_grid_filter[] = "PointCloud_PointXYZRGBA.make_voxel_grid_filter(self)\n\n        Return a pcl.VoxelGridFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_43make_voxel_grid_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_42make_voxel_grid_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_42make_voxel_grid_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGBA_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_voxel_grid_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":298
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ *         """
+ *         fil = VoxelGridFilter()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.VoxelGrid_PointXYZRGBA_t *cfil = <pclfil.VoxelGrid_PointXYZRGBA_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_VoxelGridFilter), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 298, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":299
+ *         """
+ *         fil = VoxelGridFilter()
+ *         cdef pclfil.VoxelGrid_PointXYZRGBA_t *cfil = <pclfil.VoxelGrid_PointXYZRGBA_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_VoxelGrid_PointXYZRGBA_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":300
+ *         fil = VoxelGridFilter()
+ *         cdef pclfil.VoxelGrid_PointXYZRGBA_t *cfil = <pclfil.VoxelGrid_PointXYZRGBA_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGBA> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":301
+ *         cdef pclfil.VoxelGrid_PointXYZRGBA_t *cfil = <pclfil.VoxelGrid_PointXYZRGBA_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_passthrough_filter(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":294
+ *          return fil
+ * 
+ *     def make_voxel_grid_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_voxel_grid_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":303
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_45make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_44make_passthrough_filter[] = "PointCloud_PointXYZRGBA.make_passthrough_filter(self)\n\n        Return a pcl.PassThroughFilter object with this object set as the input-cloud\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_45make_passthrough_filter(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_passthrough_filter (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_44make_passthrough_filter(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_44make_passthrough_filter(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *__pyx_v_fil = NULL;
+  __pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGBA_t *__pyx_v_cfil;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_passthrough_filter", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":307
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ *         """
+ *         fil = PassThroughFilter()             # <<<<<<<<<<<<<<
+ *         cdef pclfil.PassThrough_PointXYZRGBA_t *cfil = <pclfil.PassThrough_PointXYZRGBA_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PassThroughFilter), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 307, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_fil = ((struct __pyx_obj_3pcl_4_pcl_PassThroughFilter *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":308
+ *         """
+ *         fil = PassThroughFilter()
+ *         cdef pclfil.PassThrough_PointXYZRGBA_t *cfil = <pclfil.PassThrough_PointXYZRGBA_t *>fil.me             # <<<<<<<<<<<<<<
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *         return fil
+ */
+  __pyx_v_cfil = ((__pyx_t_3pcl_11pcl_filters_PassThrough_PointXYZRGBA_t *)__pyx_v_fil->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":309
+ *         fil = PassThroughFilter()
+ *         cdef pclfil.PassThrough_PointXYZRGBA_t *cfil = <pclfil.PassThrough_PointXYZRGBA_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return fil
+ * 
+ */
+  __pyx_v_cfil->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGBA> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":310
+ *         cdef pclfil.PassThrough_PointXYZRGBA_t *cfil = <pclfil.PassThrough_PointXYZRGBA_t *>fil.me
+ *         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *         return fil             # <<<<<<<<<<<<<<
+ * 
+ *     def make_moving_least_squares(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_fil));
+  __pyx_r = ((PyObject *)__pyx_v_fil);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":303
+ *         return fil
+ * 
+ *     def make_passthrough_filter(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.PassThroughFilter object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_passthrough_filter", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_fil);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":312
+ *         return fil
+ * 
+ *     def make_moving_least_squares(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_47make_moving_least_squares(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_46make_moving_least_squares[] = "PointCloud_PointXYZRGBA.make_moving_least_squares(self)\n\n        Return a pcl.MovingLeastSquares object with this object as input cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_47make_moving_least_squares(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_moving_least_squares (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_46make_moving_least_squares(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_46make_moving_least_squares(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *__pyx_v_mls = NULL;
+  __pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGBA_t *__pyx_v_cmls;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("make_moving_least_squares", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":316
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ *         """
+ *         mls = MovingLeastSquares_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGBA_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ */
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 316, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_v_mls = ((struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA *)__pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":317
+ *         """
+ *         mls = MovingLeastSquares_PointXYZRGBA()
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGBA_t *>mls.me             # <<<<<<<<<<<<<<
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *         return mls
+ */
+  __pyx_v_cmls = ((__pyx_t_3pcl_11pcl_surface_MovingLeastSquares_PointXYZRGBA_t *)__pyx_v_mls->me);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":318
+ *         mls = MovingLeastSquares_PointXYZRGBA()
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGBA_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)             # <<<<<<<<<<<<<<
+ *         return mls
+ * 
+ */
+  __pyx_v_cmls->setInputCloud(((boost::shared_ptr<pcl::PointCloud<struct pcl::PointXYZRGBA> > )__pyx_v_self->thisptr_shared));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":319
+ *         cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGBA_t *>mls.me
+ *         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+ *         return mls             # <<<<<<<<<<<<<<
+ * 
+ *     def make_kdtree_flann(self):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_mls));
+  __pyx_r = ((PyObject *)__pyx_v_mls);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":312
+ *         return fil
+ * 
+ *     def make_moving_least_squares(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.MovingLeastSquares object with this object as input cloud.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_moving_least_squares", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_mls);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":321
+ *         return mls
+ * 
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_49make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_48make_kdtree_flann[] = "PointCloud_PointXYZRGBA.make_kdtree_flann(self)\n\n        Return a pcl.kdTreeFLANN object with this object set as the input-cloud\n\n        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_49make_kdtree_flann(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("make_kdtree_flann (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_48make_kdtree_flann(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_48make_kdtree_flann(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("make_kdtree_flann", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":327
+ *         Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+ *         """
+ *         return KdTreeFLANN_PointXYZRGBA(self)             # <<<<<<<<<<<<<<
+ * 
+ * #     def make_octree(self, double resolution):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 327, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)__pyx_v_self));
+  __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 327, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":321
+ *         return mls
+ * 
+ *     def make_kdtree_flann(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.make_kdtree_flann", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":337
+ * #         return octree
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_51extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_50extract[] = "PointCloud_PointXYZRGBA.extract(self, pyindices, bool negative=False)\n\n        Given a list of indices of points in the pointcloud, return a \n        new pointcloud containing only those points.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_51extract(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_pyindices = 0;
+  bool __pyx_v_negative;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("extract (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyindices,&__pyx_n_s_negative,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pyindices)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_negative);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "extract") < 0)) __PYX_ERR(43, 337, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_pyindices = values[0];
+    if (values[1]) {
+      __pyx_v_negative = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_negative == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(43, 337, __pyx_L3_error)
+    } else {
+      __pyx_v_negative = ((bool)0);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("extract", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(43, 337, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_50extract(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_v_self), __pyx_v_pyindices, __pyx_v_negative);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_23PointCloud_PointXYZRGBA_50extract(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self, PyObject *__pyx_v_pyindices, bool __pyx_v_negative) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_result = 0;
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_v_ind;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  __pyx_t_3pcl_8pcl_defs_PointIndices_t *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  Py_ssize_t __pyx_t_3;
+  PyObject *(*__pyx_t_4)(PyObject *);
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  __Pyx_RefNannySetupContext("extract", 0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":343
+ *         """
+ *         cdef PointCloud_PointXYZRGBA result
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()             # <<<<<<<<<<<<<<
+ *         for i in pyindices:
+ *             ind.indices.push_back(i)
+ */
+  try {
+    __pyx_t_1 = new __pyx_t_3pcl_8pcl_defs_PointIndices_t();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 343, __pyx_L1_error)
+  }
+  __pyx_v_ind = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":344
+ *         cdef PointCloud_PointXYZRGBA result
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ *         result = PointCloud_PointXYZRGBA()
+ */
+  if (likely(PyList_CheckExact(__pyx_v_pyindices)) || PyTuple_CheckExact(__pyx_v_pyindices)) {
+    __pyx_t_2 = __pyx_v_pyindices; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
+    __pyx_t_4 = NULL;
+  } else {
+    __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_pyindices); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 344, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 344, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_4)) {
+      if (likely(PyList_CheckExact(__pyx_t_2))) {
+        if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(43, 344, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 344, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      } else {
+        if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(43, 344, __pyx_L1_error)
+        #else
+        __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 344, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        #endif
+      }
+    } else {
+      __pyx_t_5 = __pyx_t_4(__pyx_t_2);
+      if (unlikely(!__pyx_t_5)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(43, 344, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_5);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":345
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ *         for i in pyindices:
+ *             ind.indices.push_back(i)             # <<<<<<<<<<<<<<
+ *         result = PointCloud_PointXYZRGBA()
+ *         mpcl_extract_PointXYZRGBA(self.thisptr_shared, result.thisptr(), ind, negative)
+ */
+    __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(43, 345, __pyx_L1_error)
+    try {
+      __pyx_v_ind->indices.push_back(__pyx_t_6);
+    } catch(...) {
+      __Pyx_CppExn2PyErr();
+      __PYX_ERR(43, 345, __pyx_L1_error)
+    }
+
+    /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":344
+ *         cdef PointCloud_PointXYZRGBA result
+ *         cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+ *         for i in pyindices:             # <<<<<<<<<<<<<<
+ *             ind.indices.push_back(i)
+ *         result = PointCloud_PointXYZRGBA()
+ */
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":346
+ *         for i in pyindices:
+ *             ind.indices.push_back(i)
+ *         result = PointCloud_PointXYZRGBA()             # <<<<<<<<<<<<<<
+ *         mpcl_extract_PointXYZRGBA(self.thisptr_shared, result.thisptr(), ind, negative)
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 346, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_v_result = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":347
+ *             ind.indices.push_back(i)
+ *         result = PointCloud_PointXYZRGBA()
+ *         mpcl_extract_PointXYZRGBA(self.thisptr_shared, result.thisptr(), ind, negative)             # <<<<<<<<<<<<<<
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ *         return result
+ */
+  try {
+    mpcl_extract_PointXYZRGBA(__pyx_v_self->thisptr_shared, __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_result), __pyx_v_ind, __pyx_v_negative);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(43, 347, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":349
+ *         mpcl_extract_PointXYZRGBA(self.thisptr_shared, result.thisptr(), ind, negative)
+ *         # XXX are we leaking memory here? del ind causes a double free...
+ *         return result             # <<<<<<<<<<<<<<
+ * ###
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":337
+ * #         return octree
+ * 
+ *     def extract(self, pyindices, bool negative=False):             # <<<<<<<<<<<<<<
+ *         """
+ *         Given a list of indices of points in the pointcloud, return a
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointXYZRGBA.extract", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":17
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointWithViewpoint other
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_init = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_init,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_init);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(44, 17, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_init = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(44, 17, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint___cinit__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), __pyx_v_init);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, PyObject *__pyx_v_init) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_other = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":20
+ *         cdef PointCloud_PointWithViewpoint other
+ * 
+ *         self._view_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+ */
+  __pyx_v_self->_view_count = 0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":26
+ *         # sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointWithViewpoint]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  __pyx_t_1 = (__pyx_v_init == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":27
+ * 
+ *         if init is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":26
+ *         # sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointWithViewpoint]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":28
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Integral); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_integer); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 28, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_1 = PyObject_IsInstance(__pyx_v_init, __pyx_t_4); 
+  __pyx_t_6 = (__pyx_t_1 != 0);
+  if (!__pyx_t_6) {
+  } else {
+    __pyx_t_2 = __pyx_t_6;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_6 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); 
+  __pyx_t_1 = (__pyx_t_6 != 0);
+  __pyx_t_2 = __pyx_t_1;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":29
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 29, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    if (!__pyx_t_3) {
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 29, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_init};
+        __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 29, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_init};
+        __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 29, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(44, 29, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_init);
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 29, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":28
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":30
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+  __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_init, __pyx_ptype_5numpy_ndarray); 
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":31
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 31, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_7 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_7)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_7);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    if (!__pyx_t_7) {
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 31, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_init};
+        __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 31, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_init};
+        __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 31, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+      } else
+      #endif
+      {
+        __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 31, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_init);
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 31, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":30
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":32
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, __pyx_t_4); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(44, 32, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_1 = (__pyx_t_2 != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":33
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ */
+    __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_list); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __pyx_t_3 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
+      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
+      if (likely(__pyx_t_3)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+        __Pyx_INCREF(__pyx_t_3);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_5, function);
+      }
+    }
+    if (!__pyx_t_3) {
+      __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 33, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_init};
+        __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 33, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_init};
+        __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 33, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __Pyx_GOTREF(__pyx_t_4);
+      } else
+      #endif
+      {
+        __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(44, 33, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_7);
+        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_init);
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 33, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":32
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":34
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+  __pyx_t_1 = PyObject_IsInstance(__pyx_v_init, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(44, 34, __pyx_L1_error)
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":35
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ *             other = init             # <<<<<<<<<<<<<<
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ */
+    if (!(likely(((__pyx_v_init) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_init, __pyx_ptype_3pcl_4_pcl_PointCloud_PointWithViewpoint))))) __PYX_ERR(44, 35, __pyx_L1_error)
+    __pyx_t_4 = __pyx_v_init;
+    __Pyx_INCREF(__pyx_t_4);
+    __pyx_v_other = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":36
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ */
+    (__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)[0]) = (__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_other)[0]);
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":34
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":38
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+  /*else*/ {
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":39
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ *                             % type(init))             # <<<<<<<<<<<<<<
+ * 
+ *     property width:
+ */
+    __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, ((PyObject *)Py_TYPE(__pyx_v_init))); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 39, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":38
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+    __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 38, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
+    __pyx_t_4 = 0;
+    __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 38, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __PYX_ERR(44, 38, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":17
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointWithViewpoint other
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_other);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":43
+ *     property width:
+ *         """ property containing the width of the point cloud """
+ *         def __get__(self): return self.thisptr().width             # <<<<<<<<<<<<<<
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5width_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5width_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5width___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->width); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.width.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":46
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ *         def __get__(self): return self.thisptr().height             # <<<<<<<<<<<<<<
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6height_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6height_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6height___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->height); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.height.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":49
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ *         def __get__(self): return self.thisptr().size()             # <<<<<<<<<<<<<<
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4size_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4size___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":52
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ *         def __get__(self): return self.thisptr().is_dense             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8is_dense_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8is_dense_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8is_dense___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->is_dense); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.is_dense.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":54
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_2__repr__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":55
+ * 
+ *     def __repr__(self):
+ *         return "<PointCloud of %d points>" % self.size             # <<<<<<<<<<<<<<
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_PointCloud_of_d_points, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":54
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":57
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4__releasebuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":58
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ *         self._view_count -= 1             # <<<<<<<<<<<<<<
+ * 
+ *     # Pickle support. XXX this copies the entire pointcloud; it would be nice
+ */
+  __pyx_v_self->_view_count = (__pyx_v_self->_view_count - 1);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":57
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":63
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_7__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6__reduce__[] = "PointCloud_PointWithViewpoint.__reduce__(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_7__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6__reduce__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__reduce__", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":64
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):
+ *         return type(self), (self.to_array(),)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 64, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 64, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 64, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":63
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":67
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_9from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8from_array[] = "PointCloud_PointWithViewpoint.from_array(self, ndarray arr)\n\n        Fill this object from a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_9from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_array (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arr), __pyx_ptype_5numpy_ndarray, 0, "arr", 0))) __PYX_ERR(44, 67, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8from_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((PyArrayObject *)__pyx_v_arr));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, PyArrayObject *__pyx_v_arr) {
+  npy_intp __pyx_v_npts;
+  struct pcl::PointWithViewpoint *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_arr;
+  __Pyx_Buffer __pyx_pybuffer_arr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  npy_intp __pyx_t_6;
+  npy_intp __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  __pyx_t_5numpy_float32_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  __pyx_t_5numpy_float32_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  __pyx_t_5numpy_float32_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  __pyx_t_5numpy_float32_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  __pyx_t_5numpy_float32_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  Py_ssize_t __pyx_t_24;
+  __pyx_t_5numpy_float32_t __pyx_t_25;
+  __Pyx_RefNannySetupContext("from_array", 0);
+  __pyx_pybuffer_arr.pybuffer.buf = NULL;
+  __pyx_pybuffer_arr.refcount = 0;
+  __pyx_pybuffernd_arr.data = NULL;
+  __pyx_pybuffernd_arr.rcbuffer = &__pyx_pybuffer_arr;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arr.rcbuffer->pybuffer, (PyObject*)__pyx_v_arr, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(44, 67, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_arr.diminfo[0].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arr.diminfo[0].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_arr.diminfo[1].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_arr.diminfo[1].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[1];
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":71
+ *         Fill this object from a 2D numpy array (float32)
+ *         """
+ *         assert arr.shape[1] == 6             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!(((__pyx_v_arr->dimensions[1]) == 6) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(44, 71, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":73
+ *         assert arr.shape[1] == 6
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ */
+  __pyx_v_npts = (__pyx_v_arr->dimensions[0]);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":74
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_npts); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 74, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 74, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 74, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 74, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 74, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 74, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":75
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ * 
+ */
+  __pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":76
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cpp.PointWithViewpoint *p
+ */
+  __pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":79
+ * 
+ *         cdef cpp.PointWithViewpoint *p
+ *         for i in range(npts):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5]
+ */
+  __pyx_t_6 = __pyx_v_npts;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":80
+ *         cdef cpp.PointWithViewpoint *p
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5]
+ * 
+ */
+    __pyx_v_p = getptr<struct pcl::PointWithViewpoint>(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":81
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5]             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_t_9 = 0;
+    if (__pyx_t_8 < 0) __pyx_t_8 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_9 < 0) __pyx_t_9 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_10 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = 1;
+    if (__pyx_t_11 < 0) __pyx_t_11 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_12 < 0) __pyx_t_12 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_13 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 2;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_16 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_17 = __pyx_v_i;
+    __pyx_t_18 = 3;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_19 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_20 = __pyx_v_i;
+    __pyx_t_21 = 4;
+    if (__pyx_t_20 < 0) __pyx_t_20 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_21 < 0) __pyx_t_21 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_22 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_23 = __pyx_v_i;
+    __pyx_t_24 = 5;
+    if (__pyx_t_23 < 0) __pyx_t_23 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_24 < 0) __pyx_t_24 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_24, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_v_p->x = __pyx_t_10;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_16;
+    __pyx_v_p->vp_x = __pyx_t_19;
+    __pyx_v_p->vp_y = __pyx_t_22;
+    __pyx_v_p->vp_z = __pyx_t_25;
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":67
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.from_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":84
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_11to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_10to_array[] = "PointCloud_PointWithViewpoint.to_array(self)\n\n        Return this object as a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_11to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_array (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_10to_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_10to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  npy_intp __pyx_v_n;
+  PyArrayObject *__pyx_v_result = 0;
+  struct pcl::PointWithViewpoint *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_result;
+  __Pyx_Buffer __pyx_pybuffer_result;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  npy_intp __pyx_t_11;
+  npy_intp __pyx_t_12;
+  float __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  Py_ssize_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  Py_ssize_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  Py_ssize_t __pyx_t_24;
+  Py_ssize_t __pyx_t_25;
+  __Pyx_RefNannySetupContext("to_array", 0);
+  __pyx_pybuffer_result.pybuffer.buf = NULL;
+  __pyx_pybuffer_result.refcount = 0;
+  __pyx_pybuffernd_result.data = NULL;
+  __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":89
+ *         """
+ *         cdef float x,y,z
+ *         cdef cnp.npy_intp n = self.thisptr().size()             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ *         cdef cpp.PointWithViewpoint *p
+ */
+  __pyx_v_n = __pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":93
+ *         cdef cpp.PointWithViewpoint *p
+ * 
+ *         result = np.empty((n, 6), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_6);
+  __Pyx_GIVEREF(__pyx_int_6);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_6);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 93, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(44, 93, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+    __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_7 < 0)) {
+      PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      }
+    }
+    __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_result.diminfo[1].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_result.diminfo[1].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(44, 93, __pyx_L1_error)
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_result = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":94
+ * 
+ *         result = np.empty((n, 6), dtype=np.float32)
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ */
+  __pyx_t_11 = __pyx_v_n;
+  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":95
+ *         result = np.empty((n, 6), dtype=np.float32)
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ */
+    __pyx_v_p = getptr<struct pcl::PointWithViewpoint>(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":96
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x             # <<<<<<<<<<<<<<
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ */
+    __pyx_t_13 = __pyx_v_p->x;
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 0;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":97
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y             # <<<<<<<<<<<<<<
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.vp_x
+ */
+    __pyx_t_13 = __pyx_v_p->y;
+    __pyx_t_16 = __pyx_v_i;
+    __pyx_t_17 = 1;
+    if (__pyx_t_16 < 0) __pyx_t_16 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":98
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z             # <<<<<<<<<<<<<<
+ *             result[i, 3] = p.vp_x
+ *             result[i, 3] = p.vp_y
+ */
+    __pyx_t_13 = __pyx_v_p->z;
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_19 = 2;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_19 < 0) __pyx_t_19 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_19, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":99
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.vp_x             # <<<<<<<<<<<<<<
+ *             result[i, 3] = p.vp_y
+ *             result[i, 3] = p.vp_z
+ */
+    __pyx_t_13 = __pyx_v_p->vp_x;
+    __pyx_t_20 = __pyx_v_i;
+    __pyx_t_21 = 3;
+    if (__pyx_t_20 < 0) __pyx_t_20 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_21 < 0) __pyx_t_21 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":100
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.vp_x
+ *             result[i, 3] = p.vp_y             # <<<<<<<<<<<<<<
+ *             result[i, 3] = p.vp_z
+ *         return result
+ */
+    __pyx_t_13 = __pyx_v_p->vp_y;
+    __pyx_t_22 = __pyx_v_i;
+    __pyx_t_23 = 3;
+    if (__pyx_t_22 < 0) __pyx_t_22 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_23 < 0) __pyx_t_23 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":101
+ *             result[i, 3] = p.vp_x
+ *             result[i, 3] = p.vp_y
+ *             result[i, 3] = p.vp_z             # <<<<<<<<<<<<<<
+ *         return result
+ * 
+ */
+    __pyx_t_13 = __pyx_v_p->vp_z;
+    __pyx_t_24 = __pyx_v_i;
+    __pyx_t_25 = 3;
+    if (__pyx_t_24 < 0) __pyx_t_24 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_25 < 0) __pyx_t_25 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_25, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":102
+ *             result[i, 3] = p.vp_y
+ *             result[i, 3] = p.vp_z
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":84
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":105
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 6-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_13from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_12from_list[] = "PointCloud_PointWithViewpoint.from_list(self, _list)\n\n        Fill this pointcloud from a list of 6-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_13from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_12from_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((PyObject *)__pyx_v__list));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_12from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, PyObject *__pyx_v__list) {
+  Py_ssize_t __pyx_v_npts;
+  struct pcl::PointWithViewpoint *__pyx_v_p;
+  PyObject *__pyx_v_i = NULL;
+  CYTHON_UNUSED PyObject *__pyx_v_l = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  __pyx_ctuple_float__and_float__and_float__and_float__and_float__and_float __pyx_t_9;
+  __Pyx_RefNannySetupContext("from_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":109
+ *         Fill this pointcloud from a list of 6-tuples
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointWithViewpoint* p
+ *         self.resize(npts)
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v__list); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(44, 109, __pyx_L1_error)
+  __pyx_v_npts = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":111
+ *         cdef Py_ssize_t npts = len(_list)
+ *         cdef cpp.PointWithViewpoint* p
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_npts); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 111, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 111, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 111, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 111, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(44, 111, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 111, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":112
+ *         cdef cpp.PointWithViewpoint* p
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ *         # OK
+ */
+  __pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":113
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ *         # OK
+ *         # p = idx.getptr(self.thisptr(), 1)
+ */
+  __pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":117
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v__list)) || PyTuple_CheckExact(__pyx_v__list)) {
+    __pyx_t_3 = __pyx_v__list; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v__list); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 117, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(44, 117, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(44, 117, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(44, 117, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(44, 117, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(44, 117, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      }
+    } else {
+      __pyx_t_6 = __pyx_t_7(__pyx_t_3);
+      if (unlikely(!__pyx_t_6)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(44, 117, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_6);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(44, 117, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_6;
+    __pyx_t_6 = 0;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":118
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)             # <<<<<<<<<<<<<<
+ *              p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(44, 118, __pyx_L1_error)
+    __pyx_v_p = getptr<struct pcl::PointWithViewpoint>(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self), ((int)__pyx_t_8));
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":119
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z             # <<<<<<<<<<<<<<
+ * 
+ *     def to_list(self):
+ */
+    __pyx_t_9.f0 = __pyx_v_p->x;
+    __pyx_t_9.f1 = __pyx_v_p->y;
+    __pyx_t_9.f2 = __pyx_v_p->z;
+    __pyx_t_9.f3 = __pyx_v_p->vp_x;
+    __pyx_t_9.f4 = __pyx_v_p->vp_y;
+    __pyx_t_9.f5 = __pyx_v_p->vp_z;
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":117
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":105
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 6-tuples
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.from_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_l);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":121
+ *              p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 6-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_15to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_14to_list[] = "PointCloud_PointWithViewpoint.to_list(self)\n\n        Return this object as a list of 6-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_15to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_14to_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_14to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("to_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":125
+ *         Return this object as a list of 6-tuples
+ *         """
+ *         return self.to_array().tolist()             # <<<<<<<<<<<<<<
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 125, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 125, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 125, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 125, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 125, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":121
+ *              p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 6-tuples
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.to_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":127
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_17resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_16resize[] = "PointCloud_PointWithViewpoint.resize(self, npy_intp x)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_17resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x) {
+  npy_intp __pyx_v_x;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
+  assert(__pyx_arg_x); {
+    __pyx_v_x = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_x); if (unlikely((__pyx_v_x == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(44, 127, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_16resize(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((npy_intp)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_16resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, npy_intp __pyx_v_x) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("resize", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":128
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":129
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 129, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(44, 129, __pyx_L1_error)
+
+    /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":128
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":131
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+ */
+  try {
+    __pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)->resize(__pyx_v_x);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(44, 131, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":127
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":133
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (6-tuple) at the given row/column
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_19get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_18get_point[] = "PointCloud_PointWithViewpoint.get_point(self, npy_intp row, npy_intp col)\n\n        Return a point (6-tuple) at the given row/column\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_19get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  npy_intp __pyx_v_row;
+  npy_intp __pyx_v_col;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_col,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_row)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_col)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, 1); __PYX_ERR(44, 133, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_point") < 0)) __PYX_ERR(44, 133, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_row = __Pyx_PyInt_As_Py_intptr_t(values[0]); if (unlikely((__pyx_v_row == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(44, 133, __pyx_L3_error)
+    __pyx_v_col = __Pyx_PyInt_As_Py_intptr_t(values[1]); if (unlikely((__pyx_v_col == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(44, 133, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(44, 133, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_18get_point(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), __pyx_v_row, __pyx_v_col);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_18get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col) {
+  struct pcl::PointWithViewpoint *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointWithViewpoint *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("get_point", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":137
+ *         Return a point (6-tuple) at the given row/column
+ *         """
+ *         cdef cpp.PointWithViewpoint *p = idx.getptr_at2(self.thisptr(), row, col)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at2<struct pcl::PointWithViewpoint>(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self), __pyx_v_row, __pyx_v_col);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(44, 137, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":138
+ *         """
+ *         cdef cpp.PointWithViewpoint *p = idx.getptr_at2(self.thisptr(), row, col)
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->vp_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_p->vp_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(44, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_p->vp_z); if (unlikely(!__pyx_t_7)) __PYX_ERR(44, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(44, 138, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_7);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_8;
+  __pyx_t_8 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":133
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (6-tuple) at the given row/column
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":140
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointWithViewpoint *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_21__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_21__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx) {
+  npy_intp __pyx_v_nmidx;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  assert(__pyx_arg_nmidx); {
+    __pyx_v_nmidx = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_nmidx); if (unlikely((__pyx_v_nmidx == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(44, 140, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_20__getitem__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((npy_intp)__pyx_v_nmidx));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_20__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, npy_intp __pyx_v_nmidx) {
+  struct pcl::PointWithViewpoint *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointWithViewpoint *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":141
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointWithViewpoint *p = idx.getptr_at(self.thisptr(), nmidx)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at<struct pcl::PointWithViewpoint>(__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self), __pyx_v_nmidx);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(44, 141, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":142
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointWithViewpoint *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z             # <<<<<<<<<<<<<<
+ * 
+ *     def from_file(self, char *f):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->vp_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_p->vp_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(44, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_p->vp_z); if (unlikely(!__pyx_t_7)) __PYX_ERR(44, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyTuple_New(6); if (unlikely(!__pyx_t_8)) __PYX_ERR(44, 142, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_7);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_r = __pyx_t_8;
+  __pyx_t_8 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":140
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointWithViewpoint *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":144
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_23from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_22from_file[] = "PointCloud_PointWithViewpoint.from_file(self, char *f)\n\n        Fill this pointcloud from a file (a local path).\n        Only pcd files supported currently.\n        \n        Deprecated; use pcl.load instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_23from_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_f) {
+  char *__pyx_v_f;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_file (wrapper)", 0);
+  assert(__pyx_arg_f); {
+    __pyx_v_f = __Pyx_PyObject_AsString(__pyx_arg_f); if (unlikely((!__pyx_v_f) && PyErr_Occurred())) __PYX_ERR(44, 144, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_22from_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((char *)__pyx_v_f));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_22from_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char *__pyx_v_f) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  __Pyx_RefNannySetupContext("from_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":151
+ *         Deprecated; use pcl.load instead.
+ *         """
+ *         return self._from_pcd_file(f)             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_f); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 151, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 151, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 151, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 151, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(44, 151, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 151, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":144
+ *         return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+ * 
+ *     def from_file(self, char *f):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a file (a local path).
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.from_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":153
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_25_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_24_from_pcd_file[] = "PointCloud_PointWithViewpoint._from_pcd_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_25_from_pcd_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_pcd_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(44, 153, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_24_from_pcd_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_24_from_pcd_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_error;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_pcd_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":154
+ * 
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ */
+  __pyx_v_error = 0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":155
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *         return error
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":156
+ *         cdef int error = 0
+ *         with nogil:
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *         return error
+ * 
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(44, 156, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPCDFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(44, 156, __pyx_L4_error)
+        }
+        __pyx_v_error = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":155
+ *     def _from_pcd_file(self, const char *s):
+ *         cdef int error = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *         return error
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":157
+ *         with nogil:
+ *             error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+ *         return error             # <<<<<<<<<<<<<<
+ * 
+ *     def _from_ply_file(self, const char *s):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_error); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 157, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":153
+ *         return self._from_pcd_file(f)
+ * 
+ *     def _from_pcd_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int error = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint._from_pcd_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":159
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_27_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_26_from_ply_file[] = "PointCloud_PointWithViewpoint._from_ply_file(self, const char *s)";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_27_from_ply_file(PyObject *__pyx_v_self, PyObject *__pyx_arg_s) {
+  char const *__pyx_v_s;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("_from_ply_file (wrapper)", 0);
+  assert(__pyx_arg_s); {
+    __pyx_v_s = __Pyx_PyObject_AsString(__pyx_arg_s); if (unlikely((!__pyx_v_s) && PyErr_Occurred())) __PYX_ERR(44, 159, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_26_from_ply_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), ((char const *)__pyx_v_s));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_26_from_ply_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char const *__pyx_v_s) {
+  int __pyx_v_ok;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  std::string __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("_from_ply_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":160
+ * 
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0             # <<<<<<<<<<<<<<
+ *         with nogil:
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ */
+  __pyx_v_ok = 0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":161
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *         return ok
+ */
+  {
+      #ifdef WITH_THREAD
+      PyThreadState *_save;
+      Py_UNBLOCK_THREADS
+      #endif
+      /*try:*/ {
+
+        /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":162
+ *         cdef int ok = 0
+ *         with nogil:
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))             # <<<<<<<<<<<<<<
+ *         return ok
+ * 
+ */
+        try {
+          __pyx_t_1 = std::string(__pyx_v_s);
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(44, 162, __pyx_L4_error)
+        }
+        try {
+          __pyx_t_2 = pcl::io::loadPLYFile(__pyx_t_1, (*__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(__pyx_v_self)));
+        } catch(...) {
+          #ifdef WITH_THREAD
+          PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
+          #endif
+          __Pyx_CppExn2PyErr();
+          #ifdef WITH_THREAD
+          PyGILState_Release(__pyx_gilstate_save);
+          #endif
+          __PYX_ERR(44, 162, __pyx_L4_error)
+        }
+        __pyx_v_ok = __pyx_t_2;
+      }
+
+      /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":161
+ *     def _from_ply_file(self, const char *s):
+ *         cdef int ok = 0
+ *         with nogil:             # <<<<<<<<<<<<<<
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *         return ok
+ */
+      /*finally:*/ {
+        /*normal exit:*/{
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L5;
+        }
+        __pyx_L4_error: {
+          #ifdef WITH_THREAD
+          Py_BLOCK_THREADS
+          #endif
+          goto __pyx_L1_error;
+        }
+        __pyx_L5:;
+      }
+  }
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":163
+ *         with nogil:
+ *             ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+ *         return ok             # <<<<<<<<<<<<<<
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_ok); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 163, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_r = __pyx_t_3;
+  __pyx_t_3 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":159
+ *         return error
+ * 
+ *     def _from_ply_file(self, const char *s):             # <<<<<<<<<<<<<<
+ *         cdef int ok = 0
+ *         with nogil:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint._from_ply_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":165
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """
+ *         Save pointcloud to a file in PCD format.
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_29to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_28to_file[] = "PointCloud_PointWithViewpoint.to_file(self, const char *fname, bool ascii=True)\n\n        Save pointcloud to a file in PCD format.\n        Deprecated: use pcl.save instead.\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_29to_file(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  char const *__pyx_v_fname;
+  bool __pyx_v_ascii;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_file (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fname,&__pyx_n_s_ascii,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fname)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ascii);
+          if (value) { values[1] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "to_file") < 0)) __PYX_ERR(44, 165, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_fname = __Pyx_PyObject_AsString(values[0]); if (unlikely((!__pyx_v_fname) && PyErr_Occurred())) __PYX_ERR(44, 165, __pyx_L3_error)
+    if (values[1]) {
+      __pyx_v_ascii = __Pyx_PyObject_IsTrue(values[1]); if (unlikely((__pyx_v_ascii == ((bool)-1)) && PyErr_Occurred())) __PYX_ERR(44, 165, __pyx_L3_error)
+    } else {
+      __pyx_v_ascii = ((bool)1);
+    }
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("to_file", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(44, 165, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_28to_file(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)__pyx_v_self), __pyx_v_fname, __pyx_v_ascii);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_29PointCloud_PointWithViewpoint_28to_file(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self, char const *__pyx_v_fname, bool __pyx_v_ascii) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  int __pyx_t_6;
+  PyObject *__pyx_t_7 = NULL;
+  __Pyx_RefNannySetupContext("to_file", 0);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":170
+ *         Deprecated: use pcl.save instead.
+ *         """
+ *         return self._to_pcd_file(fname, not ascii)             # <<<<<<<<<<<<<<
+ * 
+ * ###
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_pcd_file); if (unlikely(!__pyx_t_2)) __PYX_ERR(44, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_fname); if (unlikely(!__pyx_t_3)) __PYX_ERR(44, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_PyBool_FromLong((!(__pyx_v_ascii != 0))); if (unlikely(!__pyx_t_4)) __PYX_ERR(44, 170, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  __pyx_t_6 = 0;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+      __pyx_t_6 = 1;
+    }
+  }
+  #if CYTHON_FAST_PYCALL
+  if (PyFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 170, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  #if CYTHON_FAST_PYCCALL
+  if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+    PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_3, __pyx_t_4};
+    __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 170, __pyx_L1_error)
+    __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else
+  #endif
+  {
+    __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(44, 170, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_7);
+    if (__pyx_t_5) {
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
+    }
+    __Pyx_GIVEREF(__pyx_t_3);
+    PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3);
+    __Pyx_GIVEREF(__pyx_t_4);
+    PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_4);
+    __pyx_t_3 = 0;
+    __pyx_t_4 = 0;
+    __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(44, 170, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":165
+ *         return ok
+ * 
+ *     def to_file(self, const char *fname, bool ascii=True):             # <<<<<<<<<<<<<<
+ *         """
+ *         Save pointcloud to a file in PCD format.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointWithViewpoint.to_file", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":21
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointNormal other
+ * 
+ */
+
+/* Python wrapper */
+static int __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static int __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  PyObject *__pyx_v_init = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_init,0};
+    PyObject* values[1] = {0};
+    values[0] = ((PyObject *)Py_None);
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (kw_args > 0) {
+          PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_init);
+          if (value) { values[0] = value; kw_args--; }
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(45, 21, __pyx_L3_error)
+      }
+    } else {
+      switch (PyTuple_GET_SIZE(__pyx_args)) {
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+    }
+    __pyx_v_init = values[0];
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(45, 21, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return -1;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal___cinit__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self), __pyx_v_init);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal___cinit__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, PyObject *__pyx_v_init) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_other = 0;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  pcl::PointCloud<struct pcl::PointNormal>  *__pyx_t_1;
+  int __pyx_t_2;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("__cinit__", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":24
+ *         cdef PointCloud_PointNormal other
+ * 
+ *         self._view_count = 0             # <<<<<<<<<<<<<<
+ * 
+ *         # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+ */
+  __pyx_v_self->_view_count = 0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":28
+ *         # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+ *         # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointNormal]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointNormal]())
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointNormal]())             # <<<<<<<<<<<<<<
+ * 
+ *         if init is None:
+ */
+  try {
+    __pyx_t_1 = new pcl::PointCloud<struct pcl::PointNormal> ();
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(45, 28, __pyx_L1_error)
+  }
+  sp_assign<pcl::PointCloud<struct pcl::PointNormal> >(__pyx_v_self->thisptr_shared, __pyx_t_1);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":30
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointNormal]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  __pyx_t_2 = (__pyx_v_init == Py_None);
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":31
+ * 
+ *         if init is None:
+ *             return             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":30
+ *         sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointNormal]())
+ * 
+ *         if init is None:             # <<<<<<<<<<<<<<
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":32
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numbers); if (unlikely(!__pyx_t_4)) __PYX_ERR(45, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_Integral); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(45, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_integer); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 32, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); 
+  __pyx_t_7 = (__pyx_t_2 != 0);
+  if (!__pyx_t_7) {
+  } else {
+    __pyx_t_3 = __pyx_t_7;
+    goto __pyx_L4_bool_binop_done;
+  }
+  __pyx_t_7 = PyObject_IsInstance(__pyx_v_init, __pyx_t_6); 
+  __pyx_t_2 = (__pyx_t_7 != 0);
+  __pyx_t_3 = __pyx_t_2;
+  __pyx_L4_bool_binop_done:;
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":33
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 33, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 33, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 33, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 33, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(45, 33, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 33, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":32
+ *         if init is None:
+ *             return
+ *         elif isinstance(init, (numbers.Integral, np.integer)):             # <<<<<<<<<<<<<<
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":34
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+  __pyx_t_2 = __Pyx_TypeCheck(__pyx_v_init, __pyx_ptype_5numpy_ndarray); 
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":35
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 35, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_8 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_8)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_8);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_8) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 35, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 35, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 35, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(45, 35, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 35, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":34
+ *         elif isinstance(init, (numbers.Integral, np.integer)):
+ *             self.resize(init)
+ *         elif isinstance(init, np.ndarray):             # <<<<<<<<<<<<<<
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":36
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+  __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_Sequence); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_3 = PyObject_IsInstance(__pyx_v_init, __pyx_t_5); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(45, 36, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_2 = (__pyx_t_3 != 0);
+  if (__pyx_t_2) {
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":37
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)             # <<<<<<<<<<<<<<
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ */
+    __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_from_list); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 37, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __pyx_t_4 = NULL;
+    if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
+      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
+      if (likely(__pyx_t_4)) {
+        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
+        __Pyx_INCREF(__pyx_t_4);
+        __Pyx_INCREF(function);
+        __Pyx_DECREF_SET(__pyx_t_6, function);
+      }
+    }
+    if (!__pyx_t_4) {
+      __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_init); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 37, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+    } else {
+      #if CYTHON_FAST_PYCALL
+      if (PyFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 37, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      #if CYTHON_FAST_PYCCALL
+      if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
+        PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_init};
+        __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 37, __pyx_L1_error)
+        __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_GOTREF(__pyx_t_5);
+      } else
+      #endif
+      {
+        __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(45, 37, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_8);
+        __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
+        __Pyx_INCREF(__pyx_v_init);
+        __Pyx_GIVEREF(__pyx_v_init);
+        PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_init);
+        __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 37, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_5);
+        __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      }
+    }
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":36
+ *         elif isinstance(init, np.ndarray):
+ *             self.from_array(init)
+ *         elif isinstance(init, Sequence):             # <<<<<<<<<<<<<<
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":38
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+  __pyx_t_2 = PyObject_IsInstance(__pyx_v_init, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(45, 38, __pyx_L1_error)
+  __pyx_t_3 = (__pyx_t_2 != 0);
+  if (__pyx_t_3) {
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":39
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):
+ *             other = init             # <<<<<<<<<<<<<<
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ */
+    if (!(likely(((__pyx_v_init) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_init, __pyx_ptype_3pcl_4_pcl_PointCloud_PointNormal))))) __PYX_ERR(45, 39, __pyx_L1_error)
+    __pyx_t_5 = __pyx_v_init;
+    __Pyx_INCREF(__pyx_t_5);
+    __pyx_v_other = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_t_5);
+    __pyx_t_5 = 0;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":40
+ *         elif isinstance(init, type(self)):
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]             # <<<<<<<<<<<<<<
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ */
+    (__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)[0]) = (__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_other)[0]);
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":38
+ *         elif isinstance(init, Sequence):
+ *             self.from_list(init)
+ *         elif isinstance(init, type(self)):             # <<<<<<<<<<<<<<
+ *             other = init
+ *             self.thisptr()[0] = other.thisptr()[0]
+ */
+    goto __pyx_L3;
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":42
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+  /*else*/ {
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":43
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"
+ *                             % type(init))             # <<<<<<<<<<<<<<
+ * 
+ *     property width:
+ */
+    __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, ((PyObject *)Py_TYPE(__pyx_v_init))); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 43, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":42
+ *             self.thisptr()[0] = other.thisptr()[0]
+ *         else:
+ *             raise TypeError("Can't initialize a PointCloud from a %s"             # <<<<<<<<<<<<<<
+ *                             % type(init))
+ * 
+ */
+    __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 42, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_GIVEREF(__pyx_t_5);
+    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
+    __pyx_t_5 = 0;
+    __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 42, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_5);
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __Pyx_Raise(__pyx_t_5, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __PYX_ERR(45, 42, __pyx_L1_error)
+  }
+  __pyx_L3:;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":21
+ *     To load a point cloud from disk, use pcl.load.
+ *     """
+ *     def __cinit__(self, init=None):             # <<<<<<<<<<<<<<
+ *         cdef PointCloud_PointNormal other
+ * 
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_other);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":47
+ *     property width:
+ *         """ property containing the width of the point cloud """
+ *         def __get__(self): return self.thisptr().width             # <<<<<<<<<<<<<<
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_5width_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_5width_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_5width___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_5width___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->width); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.width.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":50
+ *     property height:
+ *         """ property containing the height of the point cloud """
+ *         def __get__(self): return self.thisptr().height             # <<<<<<<<<<<<<<
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_6height_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_6height_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_6height___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_6height___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->height); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.height.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":53
+ *     property size:
+ *         """ property containing the number of points in the point cloud """
+ *         def __get__(self): return self.thisptr().size()             # <<<<<<<<<<<<<<
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_4size_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_4size_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_4size___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_4size___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->size()); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":56
+ *     property is_dense:
+ *         """ property containing whether the cloud is dense or not """
+ *         def __get__(self): return self.thisptr().is_dense             # <<<<<<<<<<<<<<
+ * 
+ *     def __repr__(self):
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_8is_dense_1__get__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_8is_dense_1__get__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_8is_dense___get__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_8is_dense___get__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("__get__", 0);
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->is_dense); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.is_dense.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":58
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_3__repr__(PyObject *__pyx_v_self); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_3__repr__(PyObject *__pyx_v_self) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_2__repr__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_2__repr__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("__repr__", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":59
+ * 
+ *     def __repr__(self):
+ *         return "<PointCloud of %d points>" % self.size             # <<<<<<<<<<<<<<
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_PointCloud_of_d_points, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_r = __pyx_t_2;
+  __pyx_t_2 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":58
+ *         def __get__(self): return self.thisptr().is_dense
+ * 
+ *     def __repr__(self):             # <<<<<<<<<<<<<<
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":61
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_5__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_5__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_4__releasebuffer__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self), ((Py_buffer *)__pyx_v_buffer));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_4__releasebuffer__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, CYTHON_UNUSED Py_buffer *__pyx_v_buffer) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":62
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):
+ *         self._view_count -= 1             # <<<<<<<<<<<<<<
+ * 
+ *     # Pickle support. XXX this copies the entire pointcloud; it would be nice
+ */
+  __pyx_v_self->_view_count = (__pyx_v_self->_view_count - 1);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":61
+ *         return "<PointCloud of %d points>" % self.size
+ * 
+ *     def __releasebuffer__(self, Py_buffer *buffer):             # <<<<<<<<<<<<<<
+ *         self._view_count -= 1
+ * 
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":67
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_7__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_6__reduce__[] = "PointCloud_PointNormal.__reduce__(self)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_7__reduce__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__reduce__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_6__reduce__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_6__reduce__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  __Pyx_RefNannySetupContext("__reduce__", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":68
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):
+ *         return type(self), (self.to_array(),)             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_3)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (__pyx_t_3) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 68, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 68, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))));
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":67
+ *     # to have an asarray member that returns a view, or even better, implement
+ *     # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+ *     def __reduce__(self):             # <<<<<<<<<<<<<<
+ *         return type(self), (self.to_array(),)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.__reduce__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":71
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_9from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_8from_array[] = "PointCloud_PointNormal.from_array(self, ndarray arr)\n\n        Fill this object from a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_9from_array(PyObject *__pyx_v_self, PyObject *__pyx_v_arr) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_array (wrapper)", 0);
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arr), __pyx_ptype_5numpy_ndarray, 0, "arr", 0))) __PYX_ERR(45, 71, __pyx_L1_error)
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_8from_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self), ((PyArrayObject *)__pyx_v_arr));
+
+  /* function exit code */
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_8from_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, PyArrayObject *__pyx_v_arr) {
+  npy_intp __pyx_v_npts;
+  struct pcl::PointNormal *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_arr;
+  __Pyx_Buffer __pyx_pybuffer_arr;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  npy_intp __pyx_t_6;
+  npy_intp __pyx_t_7;
+  Py_ssize_t __pyx_t_8;
+  Py_ssize_t __pyx_t_9;
+  __pyx_t_5numpy_float32_t __pyx_t_10;
+  Py_ssize_t __pyx_t_11;
+  Py_ssize_t __pyx_t_12;
+  __pyx_t_5numpy_float32_t __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  __pyx_t_5numpy_float32_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  __pyx_t_5numpy_float32_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  __pyx_t_5numpy_float32_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  Py_ssize_t __pyx_t_24;
+  __pyx_t_5numpy_float32_t __pyx_t_25;
+  Py_ssize_t __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  __pyx_t_5numpy_float32_t __pyx_t_28;
+  __Pyx_RefNannySetupContext("from_array", 0);
+  __pyx_pybuffer_arr.pybuffer.buf = NULL;
+  __pyx_pybuffer_arr.refcount = 0;
+  __pyx_pybuffernd_arr.data = NULL;
+  __pyx_pybuffernd_arr.rcbuffer = &__pyx_pybuffer_arr;
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arr.rcbuffer->pybuffer, (PyObject*)__pyx_v_arr, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(45, 71, __pyx_L1_error)
+  }
+  __pyx_pybuffernd_arr.diminfo[0].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arr.diminfo[0].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_arr.diminfo[1].strides = __pyx_pybuffernd_arr.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_arr.diminfo[1].shape = __pyx_pybuffernd_arr.rcbuffer->pybuffer.shape[1];
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":75
+ *         Fill this object from a 2D numpy array (float32)
+ *         """
+ *         assert arr.shape[1] == 7             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ */
+  #ifndef CYTHON_WITHOUT_ASSERTIONS
+  if (unlikely(!Py_OptimizeFlag)) {
+    if (unlikely(!(((__pyx_v_arr->dimensions[1]) == 7) != 0))) {
+      PyErr_SetNone(PyExc_AssertionError);
+      __PYX_ERR(45, 75, __pyx_L1_error)
+    }
+  }
+  #endif
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":77
+ *         assert arr.shape[1] == 7
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]             # <<<<<<<<<<<<<<
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ */
+  __pyx_v_npts = (__pyx_v_arr->dimensions[0]);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":78
+ * 
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_npts); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 78, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_2, function);
+    }
+  }
+  if (!__pyx_t_4) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 78, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __Pyx_GOTREF(__pyx_t_1);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 78, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
+      __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 78, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 78, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+      __Pyx_GIVEREF(__pyx_t_3);
+      PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_3);
+      __pyx_t_3 = 0;
+      __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 78, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_1);
+      __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":79
+ *         cdef cnp.npy_intp npts = arr.shape[0]
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ * 
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":80
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ * 
+ *         cdef cpp.PointNormal *p
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":83
+ * 
+ *         cdef cpp.PointNormal *p
+ *         for i in range(npts):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5], arr[i, 6]
+ */
+  __pyx_t_6 = __pyx_v_npts;
+  for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) {
+    __pyx_v_i = __pyx_t_7;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":84
+ *         cdef cpp.PointNormal *p
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5], arr[i, 6]
+ * 
+ */
+    __pyx_v_p = getptr<struct pcl::PointNormal>(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":85
+ *         for i in range(npts):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5], arr[i, 6]             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+    __pyx_t_8 = __pyx_v_i;
+    __pyx_t_9 = 0;
+    if (__pyx_t_8 < 0) __pyx_t_8 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_9 < 0) __pyx_t_9 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_10 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_8, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_9, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_11 = __pyx_v_i;
+    __pyx_t_12 = 1;
+    if (__pyx_t_11 < 0) __pyx_t_11 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_12 < 0) __pyx_t_12 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_13 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 2;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_16 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_17 = __pyx_v_i;
+    __pyx_t_18 = 3;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_19 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_20 = __pyx_v_i;
+    __pyx_t_21 = 4;
+    if (__pyx_t_20 < 0) __pyx_t_20 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_21 < 0) __pyx_t_21 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_22 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_23 = __pyx_v_i;
+    __pyx_t_24 = 5;
+    if (__pyx_t_23 < 0) __pyx_t_23 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_24 < 0) __pyx_t_24 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_25 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_24, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_t_26 = __pyx_v_i;
+    __pyx_t_27 = 6;
+    if (__pyx_t_26 < 0) __pyx_t_26 += __pyx_pybuffernd_arr.diminfo[0].shape;
+    if (__pyx_t_27 < 0) __pyx_t_27 += __pyx_pybuffernd_arr.diminfo[1].shape;
+    __pyx_t_28 = (*__Pyx_BufPtrStrided2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_arr.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_arr.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_arr.diminfo[1].strides));
+    __pyx_v_p->x = __pyx_t_10;
+    __pyx_v_p->y = __pyx_t_13;
+    __pyx_v_p->z = __pyx_t_16;
+    __pyx_v_p->normal_x = __pyx_t_19;
+    __pyx_v_p->normal_y = __pyx_t_22;
+    __pyx_v_p->normal_z = __pyx_t_25;
+    __pyx_v_p->curvature = __pyx_t_28;
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":71
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this object from a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.from_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arr.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":88
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_11to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_10to_array[] = "PointCloud_PointNormal.to_array(self)\n\n        Return this object as a 2D numpy array (float32)\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_11to_array(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_array (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_10to_array(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_10to_array(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  npy_intp __pyx_v_n;
+  PyArrayObject *__pyx_v_result = 0;
+  struct pcl::PointNormal *__pyx_v_p;
+  npy_intp __pyx_v_i;
+  __Pyx_LocalBuf_ND __pyx_pybuffernd_result;
+  __Pyx_Buffer __pyx_pybuffer_result;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyArrayObject *__pyx_t_6 = NULL;
+  int __pyx_t_7;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  npy_intp __pyx_t_11;
+  npy_intp __pyx_t_12;
+  float __pyx_t_13;
+  Py_ssize_t __pyx_t_14;
+  Py_ssize_t __pyx_t_15;
+  Py_ssize_t __pyx_t_16;
+  Py_ssize_t __pyx_t_17;
+  Py_ssize_t __pyx_t_18;
+  Py_ssize_t __pyx_t_19;
+  Py_ssize_t __pyx_t_20;
+  Py_ssize_t __pyx_t_21;
+  Py_ssize_t __pyx_t_22;
+  Py_ssize_t __pyx_t_23;
+  Py_ssize_t __pyx_t_24;
+  Py_ssize_t __pyx_t_25;
+  Py_ssize_t __pyx_t_26;
+  Py_ssize_t __pyx_t_27;
+  __Pyx_RefNannySetupContext("to_array", 0);
+  __pyx_pybuffer_result.pybuffer.buf = NULL;
+  __pyx_pybuffer_result.refcount = 0;
+  __pyx_pybuffernd_result.data = NULL;
+  __pyx_pybuffernd_result.rcbuffer = &__pyx_pybuffer_result;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":93
+ *         """
+ *         cdef float x,y,z
+ *         cdef cnp.npy_intp n = self.thisptr().size()             # <<<<<<<<<<<<<<
+ *         cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+ *         cdef cpp.PointNormal *p
+ */
+  __pyx_v_n = __pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->size();
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":97
+ *         cdef cpp.PointNormal *p
+ * 
+ *         result = np.empty((n, 7), dtype=np.float32)             # <<<<<<<<<<<<<<
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ */
+  __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_PyInt_From_Py_intptr_t(__pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
+  __Pyx_INCREF(__pyx_int_7);
+  __Pyx_GIVEREF(__pyx_int_7);
+  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_7);
+  __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
+  __pyx_t_3 = 0;
+  __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_dtype, __pyx_t_5) < 0) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 97, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(45, 97, __pyx_L1_error)
+  __pyx_t_6 = ((PyArrayObject *)__pyx_t_5);
+  {
+    __Pyx_BufFmt_StackElem __pyx_stack[1];
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+    __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack);
+    if (unlikely(__pyx_t_7 < 0)) {
+      PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
+      if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_result.rcbuffer->pybuffer, (PyObject*)__pyx_v_result, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_C_CONTIGUOUS| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
+        Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10);
+        __Pyx_RaiseBufferFallbackError();
+      } else {
+        PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10);
+      }
+    }
+    __pyx_pybuffernd_result.diminfo[0].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_result.diminfo[0].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_result.diminfo[1].strides = __pyx_pybuffernd_result.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_result.diminfo[1].shape = __pyx_pybuffernd_result.rcbuffer->pybuffer.shape[1];
+    if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(45, 97, __pyx_L1_error)
+  }
+  __pyx_t_6 = 0;
+  __pyx_v_result = ((PyArrayObject *)__pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":98
+ * 
+ *         result = np.empty((n, 7), dtype=np.float32)
+ *         for i in range(n):             # <<<<<<<<<<<<<<
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ */
+  __pyx_t_11 = __pyx_v_n;
+  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
+    __pyx_v_i = __pyx_t_12;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":99
+ *         result = np.empty((n, 7), dtype=np.float32)
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)             # <<<<<<<<<<<<<<
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ */
+    __pyx_v_p = getptr<struct pcl::PointNormal>(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self), __pyx_v_i);
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":100
+ *         for i in range(n):
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x             # <<<<<<<<<<<<<<
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ */
+    __pyx_t_13 = __pyx_v_p->x;
+    __pyx_t_14 = __pyx_v_i;
+    __pyx_t_15 = 0;
+    if (__pyx_t_14 < 0) __pyx_t_14 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_15 < 0) __pyx_t_15 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":101
+ *             p = idx.getptr(self.thisptr(), i)
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y             # <<<<<<<<<<<<<<
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.normal_x
+ */
+    __pyx_t_13 = __pyx_v_p->y;
+    __pyx_t_16 = __pyx_v_i;
+    __pyx_t_17 = 1;
+    if (__pyx_t_16 < 0) __pyx_t_16 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_17 < 0) __pyx_t_17 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":102
+ *             result[i, 0] = p.x
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z             # <<<<<<<<<<<<<<
+ *             result[i, 3] = p.normal_x
+ *             result[i, 4] = p.normal_y
+ */
+    __pyx_t_13 = __pyx_v_p->z;
+    __pyx_t_18 = __pyx_v_i;
+    __pyx_t_19 = 2;
+    if (__pyx_t_18 < 0) __pyx_t_18 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_19 < 0) __pyx_t_19 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_18, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_19, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":103
+ *             result[i, 1] = p.y
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.normal_x             # <<<<<<<<<<<<<<
+ *             result[i, 4] = p.normal_y
+ *             result[i, 5] = p.normal_z
+ */
+    __pyx_t_13 = __pyx_v_p->normal_x;
+    __pyx_t_20 = __pyx_v_i;
+    __pyx_t_21 = 3;
+    if (__pyx_t_20 < 0) __pyx_t_20 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_21 < 0) __pyx_t_21 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":104
+ *             result[i, 2] = p.z
+ *             result[i, 3] = p.normal_x
+ *             result[i, 4] = p.normal_y             # <<<<<<<<<<<<<<
+ *             result[i, 5] = p.normal_z
+ *             result[i, 6] = p.curvature
+ */
+    __pyx_t_13 = __pyx_v_p->normal_y;
+    __pyx_t_22 = __pyx_v_i;
+    __pyx_t_23 = 4;
+    if (__pyx_t_22 < 0) __pyx_t_22 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_23 < 0) __pyx_t_23 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_23, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":105
+ *             result[i, 3] = p.normal_x
+ *             result[i, 4] = p.normal_y
+ *             result[i, 5] = p.normal_z             # <<<<<<<<<<<<<<
+ *             result[i, 6] = p.curvature
+ *         return result
+ */
+    __pyx_t_13 = __pyx_v_p->normal_z;
+    __pyx_t_24 = __pyx_v_i;
+    __pyx_t_25 = 5;
+    if (__pyx_t_24 < 0) __pyx_t_24 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_25 < 0) __pyx_t_25 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_25, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":106
+ *             result[i, 4] = p.normal_y
+ *             result[i, 5] = p.normal_z
+ *             result[i, 6] = p.curvature             # <<<<<<<<<<<<<<
+ *         return result
+ * 
+ */
+    __pyx_t_13 = __pyx_v_p->curvature;
+    __pyx_t_26 = __pyx_v_i;
+    __pyx_t_27 = 6;
+    if (__pyx_t_26 < 0) __pyx_t_26 += __pyx_pybuffernd_result.diminfo[0].shape;
+    if (__pyx_t_27 < 0) __pyx_t_27 += __pyx_pybuffernd_result.diminfo[1].shape;
+    *__Pyx_BufPtrCContig2d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_result.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_result.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_result.diminfo[1].strides) = __pyx_t_13;
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":107
+ *             result[i, 5] = p.normal_z
+ *             result[i, 6] = p.curvature
+ *         return result             # <<<<<<<<<<<<<<
+ * 
+ *     @cython.boundscheck(False)
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __Pyx_INCREF(((PyObject *)__pyx_v_result));
+  __pyx_r = ((PyObject *)__pyx_v_result);
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":88
+ * 
+ *     @cython.boundscheck(False)
+ *     def to_array(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a 2D numpy array (float32)
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.to_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  goto __pyx_L2;
+  __pyx_L0:;
+  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_result.rcbuffer->pybuffer);
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_result);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":110
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 4-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_13from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_12from_list[] = "PointCloud_PointNormal.from_list(self, _list)\n\n        Fill this pointcloud from a list of 4-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_13from_list(PyObject *__pyx_v_self, PyObject *__pyx_v__list) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("from_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_12from_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self), ((PyObject *)__pyx_v__list));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_12from_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, PyObject *__pyx_v__list) {
+  Py_ssize_t __pyx_v_npts;
+  struct pcl::PointNormal *__pyx_v_p;
+  PyObject *__pyx_v_i = NULL;
+  PyObject *__pyx_v_l = NULL;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  Py_ssize_t __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *(*__pyx_t_7)(PyObject *);
+  int __pyx_t_8;
+  PyObject *__pyx_t_9 = NULL;
+  PyObject *__pyx_t_10 = NULL;
+  PyObject *__pyx_t_11 = NULL;
+  PyObject *__pyx_t_12 = NULL;
+  PyObject *__pyx_t_13 = NULL;
+  PyObject *(*__pyx_t_14)(PyObject *);
+  float __pyx_t_15;
+  float __pyx_t_16;
+  float __pyx_t_17;
+  float __pyx_t_18;
+  float __pyx_t_19;
+  float __pyx_t_20;
+  float __pyx_t_21;
+  __Pyx_RefNannySetupContext("from_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":114
+ *         Fill this pointcloud from a list of 4-tuples
+ *         """
+ *         cdef Py_ssize_t npts = len(_list)             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointNormal* p
+ *         self.resize(npts)
+ */
+  __pyx_t_1 = PyObject_Length(__pyx_v__list); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(45, 114, __pyx_L1_error)
+  __pyx_v_npts = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":116
+ *         cdef Py_ssize_t npts = len(_list)
+ *         cdef cpp.PointNormal* p
+ *         self.resize(npts)             # <<<<<<<<<<<<<<
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1
+ */
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_resize); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_npts); if (unlikely(!__pyx_t_4)) __PYX_ERR(45, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_5)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (!__pyx_t_5) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 116, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __Pyx_GOTREF(__pyx_t_2);
+  } else {
+    #if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 116, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    #if CYTHON_FAST_PYCCALL
+    if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
+      PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
+      __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 116, __pyx_L1_error)
+      __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    } else
+    #endif
+    {
+      __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 116, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
+      __Pyx_GIVEREF(__pyx_t_4);
+      PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
+      __pyx_t_4 = 0;
+      __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 116, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_2);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    }
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":117
+ *         cdef cpp.PointNormal* p
+ *         self.resize(npts)
+ *         self.thisptr().width = npts             # <<<<<<<<<<<<<<
+ *         self.thisptr().height = 1
+ *         # OK
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->width = __pyx_v_npts;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":118
+ *         self.resize(npts)
+ *         self.thisptr().width = npts
+ *         self.thisptr().height = 1             # <<<<<<<<<<<<<<
+ *         # OK
+ *         # p = idx.getptr(self.thisptr(), 1)
+ */
+  __pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->height = 1;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":122
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = l
+ */
+  __Pyx_INCREF(__pyx_int_0);
+  __pyx_t_2 = __pyx_int_0;
+  if (likely(PyList_CheckExact(__pyx_v__list)) || PyTuple_CheckExact(__pyx_v__list)) {
+    __pyx_t_3 = __pyx_v__list; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0;
+    __pyx_t_7 = NULL;
+  } else {
+    __pyx_t_1 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v__list); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 122, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(45, 122, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_7)) {
+      if (likely(PyList_CheckExact(__pyx_t_3))) {
+        if (__pyx_t_1 >= PyList_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(45, 122, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 122, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      } else {
+        if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_6); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(45, 122, __pyx_L1_error)
+        #else
+        __pyx_t_6 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 122, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_6);
+        #endif
+      }
+    } else {
+      __pyx_t_6 = __pyx_t_7(__pyx_t_3);
+      if (unlikely(!__pyx_t_6)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(45, 122, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_6);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_l, __pyx_t_6);
+    __pyx_t_6 = 0;
+    __Pyx_INCREF(__pyx_t_2);
+    __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+    __pyx_t_6 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 122, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_6);
+    __Pyx_DECREF(__pyx_t_2);
+    __pyx_t_2 = __pyx_t_6;
+    __pyx_t_6 = 0;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":123
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)             # <<<<<<<<<<<<<<
+ *              p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = l
+ * 
+ */
+    __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(45, 123, __pyx_L1_error)
+    __pyx_v_p = getptr<struct pcl::PointNormal>(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self), ((int)__pyx_t_8));
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":124
+ *         for i, l in enumerate(_list):
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = l             # <<<<<<<<<<<<<<
+ * 
+ *     def to_list(self):
+ */
+    if ((likely(PyTuple_CheckExact(__pyx_v_l))) || (PyList_CheckExact(__pyx_v_l))) {
+      PyObject* sequence = __pyx_v_l;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 7)) {
+        if (size > 7) __Pyx_RaiseTooManyValuesError(7);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(45, 124, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      if (likely(PyTuple_CheckExact(sequence))) {
+        __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyTuple_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyTuple_GET_ITEM(sequence, 3); 
+        __pyx_t_10 = PyTuple_GET_ITEM(sequence, 4); 
+        __pyx_t_11 = PyTuple_GET_ITEM(sequence, 5); 
+        __pyx_t_12 = PyTuple_GET_ITEM(sequence, 6); 
+      } else {
+        __pyx_t_6 = PyList_GET_ITEM(sequence, 0); 
+        __pyx_t_4 = PyList_GET_ITEM(sequence, 1); 
+        __pyx_t_5 = PyList_GET_ITEM(sequence, 2); 
+        __pyx_t_9 = PyList_GET_ITEM(sequence, 3); 
+        __pyx_t_10 = PyList_GET_ITEM(sequence, 4); 
+        __pyx_t_11 = PyList_GET_ITEM(sequence, 5); 
+        __pyx_t_12 = PyList_GET_ITEM(sequence, 6); 
+      }
+      __Pyx_INCREF(__pyx_t_6);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(__pyx_t_5);
+      __Pyx_INCREF(__pyx_t_9);
+      __Pyx_INCREF(__pyx_t_10);
+      __Pyx_INCREF(__pyx_t_11);
+      __Pyx_INCREF(__pyx_t_12);
+      #else
+      {
+        Py_ssize_t i;
+        PyObject** temps[7] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12};
+        for (i=0; i < 7; i++) {
+          PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(45, 124, __pyx_L1_error)
+          __Pyx_GOTREF(item);
+          *(temps[i]) = item;
+        }
+      }
+      #endif
+    } else {
+      Py_ssize_t index = -1;
+      PyObject** temps[7] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_5,&__pyx_t_9,&__pyx_t_10,&__pyx_t_11,&__pyx_t_12};
+      __pyx_t_13 = PyObject_GetIter(__pyx_v_l); if (unlikely(!__pyx_t_13)) __PYX_ERR(45, 124, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_13);
+      __pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext;
+      for (index=0; index < 7; index++) {
+        PyObject* item = __pyx_t_14(__pyx_t_13); if (unlikely(!item)) goto __pyx_L5_unpacking_failed;
+        __Pyx_GOTREF(item);
+        *(temps[index]) = item;
+      }
+      if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 7) < 0) __PYX_ERR(45, 124, __pyx_L1_error)
+      __pyx_t_14 = NULL;
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      goto __pyx_L6_unpacking_done;
+      __pyx_L5_unpacking_failed:;
+      __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+      __pyx_t_14 = NULL;
+      if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
+      __PYX_ERR(45, 124, __pyx_L1_error)
+      __pyx_L6_unpacking_done:;
+    }
+    __pyx_t_15 = __pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_15 == (float)-1) && PyErr_Occurred())) __PYX_ERR(45, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+    __pyx_t_16 = __pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_16 == (float)-1) && PyErr_Occurred())) __PYX_ERR(45, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_17 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(45, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+    __pyx_t_18 = __pyx_PyFloat_AsFloat(__pyx_t_9); if (unlikely((__pyx_t_18 == (float)-1) && PyErr_Occurred())) __PYX_ERR(45, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
+    __pyx_t_19 = __pyx_PyFloat_AsFloat(__pyx_t_10); if (unlikely((__pyx_t_19 == (float)-1) && PyErr_Occurred())) __PYX_ERR(45, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
+    __pyx_t_20 = __pyx_PyFloat_AsFloat(__pyx_t_11); if (unlikely((__pyx_t_20 == (float)-1) && PyErr_Occurred())) __PYX_ERR(45, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+    __pyx_t_21 = __pyx_PyFloat_AsFloat(__pyx_t_12); if (unlikely((__pyx_t_21 == (float)-1) && PyErr_Occurred())) __PYX_ERR(45, 124, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+    __pyx_v_p->x = __pyx_t_15;
+    __pyx_v_p->y = __pyx_t_16;
+    __pyx_v_p->z = __pyx_t_17;
+    __pyx_v_p->normal_x = __pyx_t_18;
+    __pyx_v_p->normal_y = __pyx_t_19;
+    __pyx_v_p->normal_z = __pyx_t_20;
+    __pyx_v_p->curvature = __pyx_t_21;
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":122
+ *         # p = idx.getptr(self.thisptr(), 1)
+ *         # enumerate ? -> i -> type unknown
+ *         for i, l in enumerate(_list):             # <<<<<<<<<<<<<<
+ *              p = idx.getptr(self.thisptr(), <int> i)
+ *              p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = l
+ */
+  }
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":110
+ * 
+ *     @cython.boundscheck(False)
+ *     def from_list(self, _list):             # <<<<<<<<<<<<<<
+ *         """
+ *         Fill this pointcloud from a list of 4-tuples
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_XDECREF(__pyx_t_10);
+  __Pyx_XDECREF(__pyx_t_11);
+  __Pyx_XDECREF(__pyx_t_12);
+  __Pyx_XDECREF(__pyx_t_13);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.from_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_i);
+  __Pyx_XDECREF(__pyx_v_l);
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":126
+ *              p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_15to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_14to_list[] = "PointCloud_PointNormal.to_list(self)\n\n        Return this object as a list of 3-tuples\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_15to_list(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("to_list (wrapper)", 0);
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_14to_list(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_14to_list(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("to_list", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":130
+ *         Return this object as a list of 3-tuples
+ *         """
+ *         return self.to_array().tolist()             # <<<<<<<<<<<<<<
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_to_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_4)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_4) {
+    __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 130, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  } else {
+    __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 130, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tolist); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 130, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = NULL;
+  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
+    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
+    if (likely(__pyx_t_2)) {
+      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_2);
+      __Pyx_INCREF(function);
+      __Pyx_DECREF_SET(__pyx_t_3, function);
+    }
+  }
+  if (__pyx_t_2) {
+    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 130, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  } else {
+    __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(45, 130, __pyx_L1_error)
+  }
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":126
+ *              p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = l
+ * 
+ *     def to_list(self):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return this object as a list of 3-tuples
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.to_list", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":132
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_17resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_16resize[] = "PointCloud_PointNormal.resize(self, npy_intp x)";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_17resize(PyObject *__pyx_v_self, PyObject *__pyx_arg_x) {
+  npy_intp __pyx_v_x;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("resize (wrapper)", 0);
+  assert(__pyx_arg_x); {
+    __pyx_v_x = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_x); if (unlikely((__pyx_v_x == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(45, 132, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_16resize(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self), ((npy_intp)__pyx_v_x));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_16resize(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, npy_intp __pyx_v_x) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  __Pyx_RefNannySetupContext("resize", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":133
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  __pyx_t_1 = ((__pyx_v_self->_view_count > 0) != 0);
+  if (__pyx_t_1) {
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":134
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+    __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 134, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_2);
+    __Pyx_Raise(__pyx_t_2, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __PYX_ERR(45, 134, __pyx_L1_error)
+
+    /* "pcl/pxi/PointCloud_PointNormal.pxi":133
+ * 
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:             # <<<<<<<<<<<<<<
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ */
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":136
+ *             raise ValueError("can't resize PointCloud while there are"
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)             # <<<<<<<<<<<<<<
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+ */
+  try {
+    __pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self)->resize(__pyx_v_x);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(45, 136, __pyx_L1_error)
+  }
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":132
+ *         return self.to_array().tolist()
+ * 
+ *     def resize(self, cnp.npy_intp x):             # <<<<<<<<<<<<<<
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"
+ */
+
+  /* function exit code */
+  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.resize", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":138
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_19get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_18get_point[] = "PointCloud_PointNormal.get_point(self, npy_intp row, npy_intp col)\n\n        Return a point (3-tuple) at the given row/column\n        ";
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_19get_point(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+  npy_intp __pyx_v_row;
+  npy_intp __pyx_v_col;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("get_point (wrapper)", 0);
+  {
+    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_row,&__pyx_n_s_col,0};
+    PyObject* values[2] = {0,0};
+    if (unlikely(__pyx_kwds)) {
+      Py_ssize_t kw_args;
+      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+      switch (pos_args) {
+        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+        case  0: break;
+        default: goto __pyx_L5_argtuple_error;
+      }
+      kw_args = PyDict_Size(__pyx_kwds);
+      switch (pos_args) {
+        case  0:
+        if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_row)) != 0)) kw_args--;
+        else goto __pyx_L5_argtuple_error;
+        case  1:
+        if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_col)) != 0)) kw_args--;
+        else {
+          __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, 1); __PYX_ERR(45, 138, __pyx_L3_error)
+        }
+      }
+      if (unlikely(kw_args > 0)) {
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_point") < 0)) __PYX_ERR(45, 138, __pyx_L3_error)
+      }
+    } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+      goto __pyx_L5_argtuple_error;
+    } else {
+      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+    }
+    __pyx_v_row = __Pyx_PyInt_As_Py_intptr_t(values[0]); if (unlikely((__pyx_v_row == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(45, 138, __pyx_L3_error)
+    __pyx_v_col = __Pyx_PyInt_As_Py_intptr_t(values[1]); if (unlikely((__pyx_v_col == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(45, 138, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L5_argtuple_error:;
+  __Pyx_RaiseArgtupleInvalid("get_point", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(45, 138, __pyx_L3_error)
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_18get_point(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self), __pyx_v_row, __pyx_v_col);
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_18get_point(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, npy_intp __pyx_v_row, npy_intp __pyx_v_col) {
+  struct pcl::PointNormal *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointNormal *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  __Pyx_RefNannySetupContext("get_point", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":142
+ *         Return a point (3-tuple) at the given row/column
+ *         """
+ *         cdef cpp.PointNormal *p = idx.getptr_at2(self.thisptr(), row, col)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at2<struct pcl::PointNormal>(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self), __pyx_v_row, __pyx_v_col);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(45, 142, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":143
+ *         """
+ *         cdef cpp.PointNormal *p = idx.getptr_at2(self.thisptr(), row, col)
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature             # <<<<<<<<<<<<<<
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->normal_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_p->normal_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_p->normal_z); if (unlikely(!__pyx_t_7)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_p->curvature); if (unlikely(!__pyx_t_8)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_9 = PyTuple_New(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(45, 143, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_9, 4, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_9, 5, __pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_8);
+  PyTuple_SET_ITEM(__pyx_t_9, 6, __pyx_t_8);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_t_8 = 0;
+  __pyx_r = __pyx_t_9;
+  __pyx_t_9 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":138
+ *         self.thisptr().resize(x)
+ * 
+ *     def get_point(self, cnp.npy_intp row, cnp.npy_intp col):             # <<<<<<<<<<<<<<
+ *         """
+ *         Return a point (3-tuple) at the given row/column
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.get_point", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/pxi/PointCloud_PointNormal.pxi":145
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointNormal *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_21__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx); /*proto*/
+static PyObject *__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_21__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_arg_nmidx) {
+  npy_intp __pyx_v_nmidx;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
+  assert(__pyx_arg_nmidx); {
+    __pyx_v_nmidx = __Pyx_PyInt_As_Py_intptr_t(__pyx_arg_nmidx); if (unlikely((__pyx_v_nmidx == ((npy_intp)-1)) && PyErr_Occurred())) __PYX_ERR(45, 145, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_20__getitem__(((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)__pyx_v_self), ((npy_intp)__pyx_v_nmidx));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_22PointCloud_PointNormal_20__getitem__(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self, npy_intp __pyx_v_nmidx) {
+  struct pcl::PointNormal *__pyx_v_p;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  struct pcl::PointNormal *__pyx_t_1;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  PyObject *__pyx_t_9 = NULL;
+  __Pyx_RefNannySetupContext("__getitem__", 0);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":146
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointNormal *p = idx.getptr_at(self.thisptr(), nmidx)             # <<<<<<<<<<<<<<
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+ * 
+ */
+  try {
+    __pyx_t_1 = getptr_at<struct pcl::PointNormal>(__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(__pyx_v_self), __pyx_v_nmidx);
+  } catch(...) {
+    __Pyx_CppExn2PyErr();
+    __PYX_ERR(45, 146, __pyx_L1_error)
+  }
+  __pyx_v_p = __pyx_t_1;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":147
+ *     def __getitem__(self, cnp.npy_intp nmidx):
+ *         cdef cpp.PointNormal *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature             # <<<<<<<<<<<<<<
+ * 
+ *     # def extract(self, pyindices, bool negative=False):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_2 = PyFloat_FromDouble(__pyx_v_p->x); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_3 = PyFloat_FromDouble(__pyx_v_p->y); if (unlikely(!__pyx_t_3)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_3);
+  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_p->z); if (unlikely(!__pyx_t_4)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __pyx_t_5 = PyFloat_FromDouble(__pyx_v_p->normal_x); if (unlikely(!__pyx_t_5)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_6 = PyFloat_FromDouble(__pyx_v_p->normal_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_7 = PyFloat_FromDouble(__pyx_v_p->normal_z); if (unlikely(!__pyx_t_7)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_7);
+  __pyx_t_8 = PyFloat_FromDouble(__pyx_v_p->curvature); if (unlikely(!__pyx_t_8)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_8);
+  __pyx_t_9 = PyTuple_New(7); if (unlikely(!__pyx_t_9)) __PYX_ERR(45, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_9);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_3);
+  PyTuple_SET_ITEM(__pyx_t_9, 1, __pyx_t_3);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyTuple_SET_ITEM(__pyx_t_9, 2, __pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_9, 3, __pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_9, 4, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_7);
+  PyTuple_SET_ITEM(__pyx_t_9, 5, __pyx_t_7);
+  __Pyx_GIVEREF(__pyx_t_8);
+  PyTuple_SET_ITEM(__pyx_t_9, 6, __pyx_t_8);
+  __pyx_t_2 = 0;
+  __pyx_t_3 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_5 = 0;
+  __pyx_t_6 = 0;
+  __pyx_t_7 = 0;
+  __pyx_t_8 = 0;
+  __pyx_r = __pyx_t_9;
+  __pyx_t_9 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":145
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+ * 
+ *     def __getitem__(self, cnp.npy_intp nmidx):             # <<<<<<<<<<<<<<
+ *         cdef cpp.PointNormal *p = idx.getptr_at(self.thisptr(), nmidx)
+ *         return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_XDECREF(__pyx_t_9);
+  __Pyx_AddTraceback("pcl._pcl.PointCloud_PointNormal.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":146
+ * 
+ * ### common ###
+ * def deg2rad(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_1deg2rad(PyObject *__pyx_self, PyObject *__pyx_arg_alpha); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_deg2rad[] = "deg2rad(float alpha)";
+static PyMethodDef __pyx_mdef_3pcl_4_pcl_1deg2rad = {"deg2rad", (PyCFunction)__pyx_pw_3pcl_4_pcl_1deg2rad, METH_O, __pyx_doc_3pcl_4_pcl_deg2rad};
+static PyObject *__pyx_pw_3pcl_4_pcl_1deg2rad(PyObject *__pyx_self, PyObject *__pyx_arg_alpha) {
+  float __pyx_v_alpha;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("deg2rad (wrapper)", 0);
+  assert(__pyx_arg_alpha); {
+    __pyx_v_alpha = __pyx_PyFloat_AsFloat(__pyx_arg_alpha); if (unlikely((__pyx_v_alpha == (float)-1) && PyErr_Occurred())) __PYX_ERR(4, 146, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.deg2rad", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_deg2rad(__pyx_self, ((float)__pyx_v_alpha));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_deg2rad(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("deg2rad", 0);
+
+  /* "pcl/_pcl_180.pyx":147
+ * ### common ###
+ * def deg2rad(float alpha):
+ *     return pcl_cmn.deg2rad(alpha)             # <<<<<<<<<<<<<<
+ * 
+ * def rad2deg(float alpha):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(pcl::deg2rad(__pyx_v_alpha)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 147, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/_pcl_180.pyx":146
+ * 
+ * ### common ###
+ * def deg2rad(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.deg2rad", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl_180.pyx":149
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ * def rad2deg(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.rad2deg(alpha)
+ * 
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3pcl_4_pcl_3rad2deg(PyObject *__pyx_self, PyObject *__pyx_arg_alpha); /*proto*/
+static char __pyx_doc_3pcl_4_pcl_2rad2deg[] = "rad2deg(float alpha)";
+static PyMethodDef __pyx_mdef_3pcl_4_pcl_3rad2deg = {"rad2deg", (PyCFunction)__pyx_pw_3pcl_4_pcl_3rad2deg, METH_O, __pyx_doc_3pcl_4_pcl_2rad2deg};
+static PyObject *__pyx_pw_3pcl_4_pcl_3rad2deg(PyObject *__pyx_self, PyObject *__pyx_arg_alpha) {
+  float __pyx_v_alpha;
+  PyObject *__pyx_r = 0;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("rad2deg (wrapper)", 0);
+  assert(__pyx_arg_alpha); {
+    __pyx_v_alpha = __pyx_PyFloat_AsFloat(__pyx_arg_alpha); if (unlikely((__pyx_v_alpha == (float)-1) && PyErr_Occurred())) __PYX_ERR(4, 149, __pyx_L3_error)
+  }
+  goto __pyx_L4_argument_unpacking_done;
+  __pyx_L3_error:;
+  __Pyx_AddTraceback("pcl._pcl.rad2deg", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __Pyx_RefNannyFinishContext();
+  return NULL;
+  __pyx_L4_argument_unpacking_done:;
+  __pyx_r = __pyx_pf_3pcl_4_pcl_2rad2deg(__pyx_self, ((float)__pyx_v_alpha));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3pcl_4_pcl_2rad2deg(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_alpha) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("rad2deg", 0);
+
+  /* "pcl/_pcl_180.pyx":150
+ * 
+ * def rad2deg(float alpha):
+ *     return pcl_cmn.rad2deg(alpha)             # <<<<<<<<<<<<<<
+ * 
+ * # cdef double deg2rad(double alpha):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyFloat_FromDouble(pcl::rad2deg(__pyx_v_alpha)); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 150, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "pcl/_pcl_180.pyx":149
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ * def rad2deg(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.rad2deg(alpha)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("pcl._pcl.rad2deg", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":22
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_10PointCloud_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud *__pyx_v_self) {
+  pcl::PointCloud<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":24
+ *     cdef inline cpp.PointCloud[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":22
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":35
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZI] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZI>  *__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *__pyx_v_self) {
+  pcl::PointCloud<struct pcl::PointXYZI>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":37
+ *     cdef inline cpp.PointCloud[cpp.PointXYZI] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":35
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZI] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":48
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZRGB] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGB>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZRGB>  *__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *__pyx_v_self) {
+  pcl::PointCloud<struct pcl::PointXYZRGB>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":50
+ *     cdef inline cpp.PointCloud[cpp.PointXYZRGB] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGB>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":48
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZRGB] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGB>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":61
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZRGBA] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGBA>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointXYZRGBA>  *__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *__pyx_v_self) {
+  pcl::PointCloud<struct pcl::PointXYZRGBA>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":63
+ *     cdef inline cpp.PointCloud[cpp.PointXYZRGBA] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGBA>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * # class override
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":61
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointXYZRGBA] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGBA>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":73
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.Vertices *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying Vertices
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::Vertices *__pyx_f_3pcl_4_pcl_8Vertices_thisptr(struct __pyx_obj_3pcl_4_pcl_Vertices *__pyx_v_self) {
+  pcl::Vertices *__pyx_r;
+
+  /* "pcl/_pcl.pxd":75
+ *     cdef inline cpp.Vertices *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying Vertices
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * # class override(PointCloud_PointWithViewpoint)
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":73
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.Vertices *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying Vertices
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":85
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointWithViewpoint] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointWithViewpoint>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointWithViewpoint>  *__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *__pyx_v_self) {
+  pcl::PointCloud<struct pcl::PointWithViewpoint>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":87
+ *     cdef inline cpp.PointCloud[cpp.PointWithViewpoint] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointWithViewpoint>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":85
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointWithViewpoint] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointWithViewpoint>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":98
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.Normal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<Normal>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::PointCloud<struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_17PointCloud_Normal_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *__pyx_v_self) {
+  pcl::PointCloud<struct pcl::Normal>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":100
+ *     cdef inline cpp.PointCloud[cpp.Normal] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying PointCloud<Normal>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":98
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.Normal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<Normal>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":111
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointNormal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointNormal>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::PointCloud<struct pcl::PointNormal>  *__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *__pyx_v_self) {
+  pcl::PointCloud<struct pcl::PointNormal>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":113
+ *     cdef inline cpp.PointCloud[cpp.PointNormal] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointNormal>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":111
+ *     cdef Py_ssize_t _view_count
+ * 
+ *     cdef inline cpp.PointCloud[cpp.PointNormal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying PointCloud<PointNormal>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":121
+ *     cdef pclkdt.KdTreePtr_t thisptr_shared   # KdTree
+ * 
+ *     cdef inline pclkdt.KdTree[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying KdTree<PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::search::KdTree<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_6KdTree_thisptr(struct __pyx_obj_3pcl_4_pcl_KdTree *__pyx_v_self) {
+  pcl::search::KdTree<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":123
+ *     cdef inline pclkdt.KdTree[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying KdTree<PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * # cdef class KdTreeFLANN:
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":121
+ *     cdef pclkdt.KdTreePtr_t thisptr_shared   # KdTree
+ * 
+ *     cdef inline pclkdt.KdTree[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying KdTree<PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":138
+ *     cdef pcl_rngimg.RangeImagePtr_t thisptr_shared   # RangeImages
+ * 
+ *     cdef inline pcl_rngimg.RangeImage *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying RangeImage.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::RangeImage *__pyx_f_3pcl_4_pcl_11RangeImages_thisptr(struct __pyx_obj_3pcl_4_pcl_RangeImages *__pyx_v_self) {
+  pcl::RangeImage *__pyx_r;
+
+  /* "pcl/_pcl.pxd":140
+ *     cdef inline pcl_rngimg.RangeImage *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying RangeImage.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":138
+ *     cdef pcl_rngimg.RangeImagePtr_t thisptr_shared   # RangeImages
+ * 
+ *     cdef inline pcl_rngimg.RangeImage *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying RangeImage.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":148
+ *     cdef pcl_ftr.IntegralImageNormalEstimationPtr_t thisptr_shared     # IntegralImageNormalEstimation
+ * 
+ *     cdef inline pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *__pyx_v_self) {
+  pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":150
+ *     cdef inline pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":148
+ *     cdef pcl_ftr.IntegralImageNormalEstimationPtr_t thisptr_shared     # IntegralImageNormalEstimation
+ * 
+ *     cdef inline pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":158
+ *     cdef pcl_sac.SampleConsensusModelPtr_t thisptr_shared     # SampleConsensusModel
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModel[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModel<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::SampleConsensusModel<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_20SampleConsensusModel_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *__pyx_v_self) {
+  pcl::SampleConsensusModel<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":160
+ *     cdef inline pcl_sac.SampleConsensusModel[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModel<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class SampleConsensusModelPlane:
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":158
+ *     cdef pcl_sac.SampleConsensusModelPtr_t thisptr_shared     # SampleConsensusModel
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModel[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModel<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":165
+ *     cdef pcl_sac.SampleConsensusModelPlanePtr_t thisptr_shared     # SampleConsensusModelPlane
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelPlane[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelPlane<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_25SampleConsensusModelPlane_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *__pyx_v_self) {
+  pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":167
+ *     cdef inline pcl_sac.SampleConsensusModelPlane[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelPlane<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class SampleConsensusModelSphere:
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":165
+ *     cdef pcl_sac.SampleConsensusModelPlanePtr_t thisptr_shared     # SampleConsensusModelPlane
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelPlane[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelPlane<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":172
+ *     cdef pcl_sac.SampleConsensusModelSpherePtr_t thisptr_shared     # SampleConsensusModelSphere
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelSphere[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelSphere<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_26SampleConsensusModelSphere_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *__pyx_v_self) {
+  pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":174
+ *     cdef inline pcl_sac.SampleConsensusModelSphere[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelSphere<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class SampleConsensusModelCylinder:
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":172
+ *     cdef pcl_sac.SampleConsensusModelSpherePtr_t thisptr_shared     # SampleConsensusModelSphere
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelSphere[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelSphere<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":179
+ *     cdef pcl_sac.SampleConsensusModelCylinderPtr_t thisptr_shared     # SampleConsensusModelSphere
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelCylinder<pcl::PointXYZ, pcl::Normal>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_f_3pcl_4_pcl_28SampleConsensusModelCylinder_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *__pyx_v_self) {
+  pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":181
+ *     cdef inline pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelCylinder<pcl::PointXYZ, pcl::Normal>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class SampleConsensusModelLine:
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":179
+ *     cdef pcl_sac.SampleConsensusModelCylinderPtr_t thisptr_shared     # SampleConsensusModelSphere
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelCylinder<pcl::PointXYZ, pcl::Normal>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":186
+ *     cdef pcl_sac.SampleConsensusModelLinePtr_t thisptr_shared     # SampleConsensusModelLine
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelLine[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelLine<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_24SampleConsensusModelLine_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *__pyx_v_self) {
+  pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":188
+ *     cdef inline pcl_sac.SampleConsensusModelLine[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelLine<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class SampleConsensusModelRegistration:
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":186
+ *     cdef pcl_sac.SampleConsensusModelLinePtr_t thisptr_shared     # SampleConsensusModelLine
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelLine[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelLine<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":193
+ *     cdef pcl_sac.SampleConsensusModelRegistrationPtr_t thisptr_shared     # SampleConsensusModelRegistration
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelRegistration<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_32SampleConsensusModelRegistration_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *__pyx_v_self) {
+  pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":195
+ *     cdef inline pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelRegistration<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class SampleConsensusModelStick:
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":193
+ *     cdef pcl_sac.SampleConsensusModelRegistrationPtr_t thisptr_shared     # SampleConsensusModelRegistration
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelRegistration<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "pcl/_pcl.pxd":200
+ *     cdef pcl_sac.SampleConsensusModelStickPtr_t thisptr_shared     # SampleConsensusModelStick
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelStick[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelStick<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+static CYTHON_INLINE pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  *__pyx_f_3pcl_4_pcl_25SampleConsensusModelStick_thisptr(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *__pyx_v_self) {
+  pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  *__pyx_r;
+
+  /* "pcl/_pcl.pxd":202
+ *     cdef inline pcl_sac.SampleConsensusModelStick[cpp.PointXYZ] *thisptr(self) nogil:
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelStick<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()             # <<<<<<<<<<<<<<
+ */
+  __pyx_r = __pyx_v_self->thisptr_shared.get();
+  goto __pyx_L0;
+
+  /* "pcl/_pcl.pxd":200
+ *     cdef pcl_sac.SampleConsensusModelStickPtr_t thisptr_shared     # SampleConsensusModelStick
+ * 
+ *     cdef inline pcl_sac.SampleConsensusModelStick[cpp.PointXYZ] *thisptr(self) nogil:             # <<<<<<<<<<<<<<
+ *         # Shortcut to get raw pointer to underlying pcl::SampleConsensusModelStick<pcl::PointXYZ>.
+ *         return self.thisptr_shared.get()
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+  __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+  int __pyx_v_copy_shape;
+  int __pyx_v_i;
+  int __pyx_v_ndim;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  int __pyx_v_t;
+  char *__pyx_v_f;
+  PyArray_Descr *__pyx_v_descr = 0;
+  int __pyx_v_offset;
+  int __pyx_v_hasfields;
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  int __pyx_t_5;
+  PyObject *__pyx_t_6 = NULL;
+  char *__pyx_t_7;
+  __Pyx_RefNannySetupContext("__getbuffer__", 0);
+  if (__pyx_v_info != NULL) {
+    __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(__pyx_v_info->obj);
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":203
+ *             # of flags
+ * 
+ *             if info == NULL: return             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int copy_shape, i, ndim
+ */
+  __pyx_t_1 = ((__pyx_v_info == NULL) != 0);
+  if (__pyx_t_1) {
+    __pyx_r = 0;
+    goto __pyx_L0;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":206
+ * 
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":207
+ *             cdef int copy_shape, i, ndim
+ *             cdef int endian_detector = 1
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ * 
+ *             ndim = PyArray_NDIM(self)
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":209
+ *             cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ * 
+ *             ndim = PyArray_NDIM(self)             # <<<<<<<<<<<<<<
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":212
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 copy_shape = 1             # <<<<<<<<<<<<<<
+ *             else:
+ *                 copy_shape = 0
+ */
+    __pyx_v_copy_shape = 1;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":211
+ *             ndim = PyArray_NDIM(self)
+ * 
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 copy_shape = 1
+ *             else:
+ */
+    goto __pyx_L4;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":214
+ *                 copy_shape = 1
+ *             else:
+ *                 copy_shape = 0             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ */
+  /*else*/ {
+    __pyx_v_copy_shape = 0;
+  }
+  __pyx_L4:;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L6_bool_binop_done;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":217
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L6_bool_binop_done:;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 218, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(46, 218, __pyx_L1_error)
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":216
+ *                 copy_shape = 0
+ * 
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ */
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L9_bool_binop_done;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":221
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):             # <<<<<<<<<<<<<<
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ */
+  __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L9_bool_binop_done:;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+    __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 222, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __PYX_ERR(46, 222, __pyx_L1_error)
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":220
+ *                 raise ValueError(u"ndarray is not C contiguous")
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)             # <<<<<<<<<<<<<<
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":224
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")
+ * 
+ *             info.buf = PyArray_DATA(self)             # <<<<<<<<<<<<<<
+ *             info.ndim = ndim
+ *             if copy_shape:
+ */
+  __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":225
+ * 
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim             # <<<<<<<<<<<<<<
+ *             if copy_shape:
+ *                 # Allocate new buffer for strides and shape info.
+ */
+  __pyx_v_info->ndim = __pyx_v_ndim;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+  __pyx_t_1 = (__pyx_v_copy_shape != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":229
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)             # <<<<<<<<<<<<<<
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ */
+    __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2)));
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":230
+ *                 # This is allocated as one block, strides first.
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim             # <<<<<<<<<<<<<<
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ */
+    __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":231
+ *                 info.strides = <Py_ssize_t*>stdlib.malloc(sizeof(Py_ssize_t) * <size_t>ndim * 2)
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):             # <<<<<<<<<<<<<<
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ */
+    __pyx_t_4 = __pyx_v_ndim;
+    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
+      __pyx_v_i = __pyx_t_5;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":232
+ *                 info.shape = info.strides + ndim
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]             # <<<<<<<<<<<<<<
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ */
+      (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":233
+ *                 for i in range(ndim):
+ *                     info.strides[i] = PyArray_STRIDES(self)[i]
+ *                     info.shape[i] = PyArray_DIMS(self)[i]             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ */
+      (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
+    }
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":226
+ *             info.buf = PyArray_DATA(self)
+ *             info.ndim = ndim
+ *             if copy_shape:             # <<<<<<<<<<<<<<
+ *                 # Allocate new buffer for strides and shape info.
+ *                 # This is allocated as one block, strides first.
+ */
+    goto __pyx_L11;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":235
+ *                     info.shape[i] = PyArray_DIMS(self)[i]
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)             # <<<<<<<<<<<<<<
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ */
+  /*else*/ {
+    __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":236
+ *             else:
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)             # <<<<<<<<<<<<<<
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ */
+    __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
+  }
+  __pyx_L11:;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":237
+ *                 info.strides = <Py_ssize_t*>PyArray_STRIDES(self)
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL             # <<<<<<<<<<<<<<
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ */
+  __pyx_v_info->suboffsets = NULL;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":238
+ *                 info.shape = <Py_ssize_t*>PyArray_DIMS(self)
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)             # <<<<<<<<<<<<<<
+ *             info.readonly = not PyArray_ISWRITEABLE(self)
+ * 
+ */
+  __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":239
+ *             info.suboffsets = NULL
+ *             info.itemsize = PyArray_ITEMSIZE(self)
+ *             info.readonly = not PyArray_ISWRITEABLE(self)             # <<<<<<<<<<<<<<
+ * 
+ *             cdef int t
+ */
+  __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":242
+ * 
+ *             cdef int t
+ *             cdef char* f = NULL             # <<<<<<<<<<<<<<
+ *             cdef dtype descr = self.descr
+ *             cdef int offset
+ */
+  __pyx_v_f = NULL;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":243
+ *             cdef int t
+ *             cdef char* f = NULL
+ *             cdef dtype descr = self.descr             # <<<<<<<<<<<<<<
+ *             cdef int offset
+ * 
+ */
+  __pyx_t_3 = ((PyObject *)__pyx_v_self->descr);
+  __Pyx_INCREF(__pyx_t_3);
+  __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
+  __pyx_t_3 = 0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":246
+ *             cdef int offset
+ * 
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields and not copy_shape:
+ */
+  __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+  __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_2) {
+  } else {
+    __pyx_t_1 = __pyx_t_2;
+    goto __pyx_L15_bool_binop_done;
+  }
+  __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0);
+  __pyx_t_1 = __pyx_t_2;
+  __pyx_L15_bool_binop_done:;
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":250
+ *             if not hasfields and not copy_shape:
+ *                 # do not call releasebuffer
+ *                 info.obj = None             # <<<<<<<<<<<<<<
+ *             else:
+ *                 # need to call releasebuffer
+ */
+    __Pyx_INCREF(Py_None);
+    __Pyx_GIVEREF(Py_None);
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = Py_None;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":248
+ *             cdef bint hasfields = PyDataType_HASFIELDS(descr)
+ * 
+ *             if not hasfields and not copy_shape:             # <<<<<<<<<<<<<<
+ *                 # do not call releasebuffer
+ *                 info.obj = None
+ */
+    goto __pyx_L14;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":253
+ *             else:
+ *                 # need to call releasebuffer
+ *                 info.obj = self             # <<<<<<<<<<<<<<
+ * 
+ *             if not hasfields:
+ */
+  /*else*/ {
+    __Pyx_INCREF(((PyObject *)__pyx_v_self));
+    __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj);
+    __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+  }
+  __pyx_L14:;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":256
+ * 
+ *             if not hasfields:
+ *                 t = descr.type_num             # <<<<<<<<<<<<<<
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ */
+    __pyx_t_4 = __pyx_v_descr->type_num;
+    __pyx_v_t = __pyx_t_4;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
+    if (!__pyx_t_2) {
+      goto __pyx_L20_next_or;
+    } else {
+    }
+    __pyx_t_2 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_L20_next_or:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ */
+    __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
+    if (__pyx_t_2) {
+    } else {
+      __pyx_t_1 = __pyx_t_2;
+      goto __pyx_L19_bool_binop_done;
+    }
+    __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_1 = __pyx_t_2;
+    __pyx_L19_bool_binop_done:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_1) {
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 259, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(46, 259, __pyx_L1_error)
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":257
+ *             if not hasfields:
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":260
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ */
+    switch (__pyx_v_t) {
+      case NPY_BYTE:
+      __pyx_v_f = ((char *)"b");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":261
+ *                     raise ValueError(u"Non-native byte order not supported")
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ */
+      case NPY_UBYTE:
+      __pyx_v_f = ((char *)"B");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":262
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ */
+      case NPY_SHORT:
+      __pyx_v_f = ((char *)"h");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":263
+ *                 elif t == NPY_UBYTE:       f = "B"
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ */
+      case NPY_USHORT:
+      __pyx_v_f = ((char *)"H");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":264
+ *                 elif t == NPY_SHORT:       f = "h"
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ */
+      case NPY_INT:
+      __pyx_v_f = ((char *)"i");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":265
+ *                 elif t == NPY_USHORT:      f = "H"
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ */
+      case NPY_UINT:
+      __pyx_v_f = ((char *)"I");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":266
+ *                 elif t == NPY_INT:         f = "i"
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ */
+      case NPY_LONG:
+      __pyx_v_f = ((char *)"l");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":267
+ *                 elif t == NPY_UINT:        f = "I"
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ */
+      case NPY_ULONG:
+      __pyx_v_f = ((char *)"L");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":268
+ *                 elif t == NPY_LONG:        f = "l"
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ */
+      case NPY_LONGLONG:
+      __pyx_v_f = ((char *)"q");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":269
+ *                 elif t == NPY_ULONG:       f = "L"
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ */
+      case NPY_ULONGLONG:
+      __pyx_v_f = ((char *)"Q");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ *                 elif t == NPY_LONGLONG:    f = "q"
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ */
+      case NPY_FLOAT:
+      __pyx_v_f = ((char *)"f");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":271
+ *                 elif t == NPY_ULONGLONG:   f = "Q"
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ */
+      case NPY_DOUBLE:
+      __pyx_v_f = ((char *)"d");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":272
+ *                 elif t == NPY_FLOAT:       f = "f"
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ */
+      case NPY_LONGDOUBLE:
+      __pyx_v_f = ((char *)"g");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":273
+ *                 elif t == NPY_DOUBLE:      f = "d"
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ */
+      case NPY_CFLOAT:
+      __pyx_v_f = ((char *)"Zf");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ *                 elif t == NPY_LONGDOUBLE:  f = "g"
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"
+ */
+      case NPY_CDOUBLE:
+      __pyx_v_f = ((char *)"Zd");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":275
+ *                 elif t == NPY_CFLOAT:      f = "Zf"
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"             # <<<<<<<<<<<<<<
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ */
+      case NPY_CLONGDOUBLE:
+      __pyx_v_f = ((char *)"Zg");
+      break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":276
+ *                 elif t == NPY_CDOUBLE:     f = "Zd"
+ *                 elif t == NPY_CLONGDOUBLE: f = "Zg"
+ *                 elif t == NPY_OBJECT:      f = "O"             # <<<<<<<<<<<<<<
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      case NPY_OBJECT:
+      __pyx_v_f = ((char *)"O");
+      break;
+      default:
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":278
+ *                 elif t == NPY_OBJECT:      f = "O"
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *                 info.format = f
+ *                 return
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(46, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_GIVEREF(__pyx_t_6);
+      PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6);
+      __pyx_t_6 = 0;
+      __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(46, 278, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __Pyx_Raise(__pyx_t_6, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+      __PYX_ERR(46, 278, __pyx_L1_error)
+      break;
+    }
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":279
+ *                 else:
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f             # <<<<<<<<<<<<<<
+ *                 return
+ *             else:
+ */
+    __pyx_v_info->format = __pyx_v_f;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ *                     raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *                 info.format = f
+ *                 return             # <<<<<<<<<<<<<<
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ */
+    __pyx_r = 0;
+    goto __pyx_L0;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":255
+ *                 info.obj = self
+ * 
+ *             if not hasfields:             # <<<<<<<<<<<<<<
+ *                 t = descr.type_num
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ */
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":282
+ *                 return
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)             # <<<<<<<<<<<<<<
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ */
+  /*else*/ {
+    __pyx_v_info->format = ((char *)malloc(0xFF));
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":283
+ *             else:
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment             # <<<<<<<<<<<<<<
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ */
+    (__pyx_v_info->format[0]) = '^';
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":284
+ *                 info.format = <char*>stdlib.malloc(_buffer_format_string_len)
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0             # <<<<<<<<<<<<<<
+ *                 f = _util_dtypestring(descr, info.format + 1,
+ *                                       info.format + _buffer_format_string_len,
+ */
+    __pyx_v_offset = 0;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":285
+ *                 info.format[0] = c'^' # Native data types, manual alignment
+ *                 offset = 0
+ *                 f = _util_dtypestring(descr, info.format + 1,             # <<<<<<<<<<<<<<
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ */
+    __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) __PYX_ERR(46, 285, __pyx_L1_error)
+    __pyx_v_f = __pyx_t_7;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":288
+ *                                       info.format + _buffer_format_string_len,
+ *                                       &offset)
+ *                 f[0] = c'\0' # Terminate format string             # <<<<<<<<<<<<<<
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ */
+    (__pyx_v_f[0]) = '\x00';
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":197
+ *         # experimental exception made for __getbuffer__ and __releasebuffer__
+ *         # -- the details of this may change.
+ *         def __getbuffer__(ndarray self, Py_buffer* info, int flags):             # <<<<<<<<<<<<<<
+ *             # This implementation of getbuffer is geared towards Cython
+ *             # requirements, and does not yet fullfill the PEP.
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) {
+    __Pyx_GOTREF(__pyx_v_info->obj);
+    __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL;
+  }
+  goto __pyx_L2;
+  __pyx_L0:;
+  if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) {
+    __Pyx_GOTREF(Py_None);
+    __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL;
+  }
+  __pyx_L2:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+  __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":292
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)             # <<<<<<<<<<<<<<
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)
+ */
+    free(__pyx_v_info->format);
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):
+ *             if PyArray_HASFIELDS(self):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":294
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ *                 stdlib.free(info.strides)             # <<<<<<<<<<<<<<
+ *                 # info.shape was stored after info.strides in the same block
+ * 
+ */
+    free(__pyx_v_info->strides);
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ *             if sizeof(npy_intp) != sizeof(Py_ssize_t):             # <<<<<<<<<<<<<<
+ *                 stdlib.free(info.strides)
+ *                 # info.shape was stored after info.strides in the same block
+ */
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ *                 f[0] = c'\0' # Terminate format string
+ * 
+ *         def __releasebuffer__(ndarray self, Py_buffer* info):             # <<<<<<<<<<<<<<
+ *             if PyArray_HASFIELDS(self):
+ *                 stdlib.free(info.format)
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":771
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):
+ *     return PyArray_MultiIterNew(1, <void*>a)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(46, 771, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":770
+ * ctypedef npy_cdouble     complex_t
+ * 
+ * cdef inline object PyArray_MultiIterNew1(a):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":774
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(46, 774, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":773
+ *     return PyArray_MultiIterNew(1, <void*>a)
+ * 
+ * cdef inline object PyArray_MultiIterNew2(a, b):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":777
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(46, 777, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ *     return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+ * 
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":780
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(46, 780, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ *     return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+ * 
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":783
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(46, 783, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":782
+ *     return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+ * 
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):             # <<<<<<<<<<<<<<
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
+  PyArray_Descr *__pyx_v_child = 0;
+  int __pyx_v_endian_detector;
+  int __pyx_v_little_endian;
+  PyObject *__pyx_v_fields = 0;
+  PyObject *__pyx_v_childname = NULL;
+  PyObject *__pyx_v_new_offset = NULL;
+  PyObject *__pyx_v_t = NULL;
+  char *__pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *__pyx_t_3 = NULL;
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  int __pyx_t_6;
+  int __pyx_t_7;
+  long __pyx_t_8;
+  char *__pyx_t_9;
+  __Pyx_RefNannySetupContext("_util_dtypestring", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":790
+ * 
+ *     cdef dtype child
+ *     cdef int endian_detector = 1             # <<<<<<<<<<<<<<
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)
+ *     cdef tuple fields
+ */
+  __pyx_v_endian_detector = 1;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":791
+ *     cdef dtype child
+ *     cdef int endian_detector = 1
+ *     cdef bint little_endian = ((<char*>&endian_detector)[0] != 0)             # <<<<<<<<<<<<<<
+ *     cdef tuple fields
+ * 
+ */
+  __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  if (unlikely(__pyx_v_descr->names == Py_None)) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+    __PYX_ERR(46, 794, __pyx_L1_error)
+  }
+  __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+  for (;;) {
+    if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(46, 794, __pyx_L1_error)
+    #else
+    __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 794, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    #endif
+    __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
+    __pyx_t_3 = 0;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":795
+ * 
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]             # <<<<<<<<<<<<<<
+ *         child, new_offset = fields
+ * 
+ */
+    if (unlikely(__pyx_v_descr->fields == Py_None)) {
+      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+      __PYX_ERR(46, 795, __pyx_L1_error)
+    }
+    __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 795, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(46, 795, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
+    __pyx_t_3 = 0;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":796
+ *     for childname in descr.names:
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields             # <<<<<<<<<<<<<<
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ */
+    if (likely(__pyx_v_fields != Py_None)) {
+      PyObject* sequence = __pyx_v_fields;
+      #if !CYTHON_COMPILING_IN_PYPY
+      Py_ssize_t size = Py_SIZE(sequence);
+      #else
+      Py_ssize_t size = PySequence_Size(sequence);
+      #endif
+      if (unlikely(size != 2)) {
+        if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+        else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+        __PYX_ERR(46, 796, __pyx_L1_error)
+      }
+      #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+      __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); 
+      __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); 
+      __Pyx_INCREF(__pyx_t_3);
+      __Pyx_INCREF(__pyx_t_4);
+      #else
+      __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 796, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      #endif
+    } else {
+      __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(46, 796, __pyx_L1_error)
+    }
+    if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(46, 796, __pyx_L1_error)
+    __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
+    __pyx_t_3 = 0;
+    __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 798, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_3);
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(46, 798, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+    __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 799, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(46, 799, __pyx_L1_error)
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":798
+ *         child, new_offset = fields
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:             # <<<<<<<<<<<<<<
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ */
+    }
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
+    if (!__pyx_t_7) {
+      goto __pyx_L8_next_or;
+    } else {
+    }
+    __pyx_t_7 = (__pyx_v_little_endian != 0);
+    if (!__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_L8_next_or:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":802
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):             # <<<<<<<<<<<<<<
+ *             raise ValueError(u"Non-native byte order not supported")
+ *             # One could encode it in the format string and have Cython
+ */
+    __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
+    if (__pyx_t_7) {
+    } else {
+      __pyx_t_6 = __pyx_t_7;
+      goto __pyx_L7_bool_binop_done;
+    }
+    __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
+    __pyx_t_6 = __pyx_t_7;
+    __pyx_L7_bool_binop_done:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    if (__pyx_t_6) {
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+      __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 803, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __PYX_ERR(46, 803, __pyx_L1_error)
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or             # <<<<<<<<<<<<<<
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")
+ */
+    }
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":813
+ * 
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:             # <<<<<<<<<<<<<<
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ */
+    while (1) {
+      __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 813, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 813, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (!__pyx_t_6) break;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":814
+ *         # Output padding bytes
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte             # <<<<<<<<<<<<<<
+ *             f += 1
+ *             offset[0] += 1
+ */
+      (__pyx_v_f[0]) = 0x78;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":815
+ *         while offset[0] < new_offset:
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1             # <<<<<<<<<<<<<<
+ *             offset[0] += 1
+ * 
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":816
+ *             f[0] = 120 # "x"; pad byte
+ *             f += 1
+ *             offset[0] += 1             # <<<<<<<<<<<<<<
+ * 
+ *         offset[0] += child.itemsize
+ */
+      __pyx_t_8 = 0;
+      (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
+    }
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":818
+ *             offset[0] += 1
+ * 
+ *         offset[0] += child.itemsize             # <<<<<<<<<<<<<<
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ */
+    __pyx_t_8 = 0;
+    (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+    __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
+    if (__pyx_t_6) {
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821
+ * 
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num             # <<<<<<<<<<<<<<
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 821, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
+      __pyx_t_4 = 0;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
+      if (__pyx_t_6) {
+
+        /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+        __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 823, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __PYX_ERR(46, 823, __pyx_L1_error)
+
+        /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *         if not PyDataType_HASFIELDS(child):
+ *             t = child.type_num
+ *             if end - f < 5:             # <<<<<<<<<<<<<<
+ *                 raise RuntimeError(u"Format string allocated too short.")
+ * 
+ */
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":826
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 826, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 826, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 98;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 827, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 827, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":828
+ *             if   t == NPY_BYTE:        f[0] =  98 #"b"
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 828, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 828, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x68;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":829
+ *             elif t == NPY_UBYTE:       f[0] =  66 #"B"
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 829, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 829, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 72;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830
+ *             elif t == NPY_SHORT:       f[0] = 104 #"h"
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 830, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 830, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x69;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":831
+ *             elif t == NPY_USHORT:      f[0] =  72 #"H"
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 831, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 831, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 73;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":832
+ *             elif t == NPY_INT:         f[0] = 105 #"i"
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 832, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 832, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x6C;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833
+ *             elif t == NPY_UINT:        f[0] =  73 #"I"
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 833, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 833, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 76;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":834
+ *             elif t == NPY_LONG:        f[0] = 108 #"l"
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 834, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 834, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x71;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":835
+ *             elif t == NPY_ULONG:       f[0] = 76  #"L"
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 835, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 835, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 81;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ *             elif t == NPY_LONGLONG:    f[0] = 113 #"q"
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 836, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 836, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x66;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837
+ *             elif t == NPY_ULONGLONG:   f[0] = 81  #"Q"
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 837, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 837, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x64;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":838
+ *             elif t == NPY_FLOAT:       f[0] = 102 #"f"
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 838, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 838, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 0x67;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":839
+ *             elif t == NPY_DOUBLE:      f[0] = 100 #"d"
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 839, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 839, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x66;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":840
+ *             elif t == NPY_LONGDOUBLE:  f[0] = 103 #"g"
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd             # <<<<<<<<<<<<<<
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 840, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 840, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x64;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":841
+ *             elif t == NPY_CFLOAT:      f[0] = 90; f[1] = 102; f += 1 # Zf
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg             # <<<<<<<<<<<<<<
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ */
+      __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 841, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_3);
+      __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 841, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 90;
+        (__pyx_v_f[1]) = 0x67;
+        __pyx_v_f = (__pyx_v_f + 1);
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842
+ *             elif t == NPY_CDOUBLE:     f[0] = 90; f[1] = 100; f += 1 # Zd
+ *             elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"             # <<<<<<<<<<<<<<
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+      __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 842, __pyx_L1_error)
+      __Pyx_GOTREF(__pyx_t_4);
+      __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+      __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(46, 842, __pyx_L1_error)
+      __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+      if (__pyx_t_6) {
+        (__pyx_v_f[0]) = 79;
+        goto __pyx_L15;
+      }
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":844
+ *             elif t == NPY_OBJECT:      f[0] = 79 #"O"
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)             # <<<<<<<<<<<<<<
+ *             f += 1
+ *         else:
+ */
+      /*else*/ {
+        __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(46, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        __Pyx_GIVEREF(__pyx_t_3);
+        PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
+        __pyx_t_3 = 0;
+        __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(46, 844, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_3);
+        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+        __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+        __PYX_ERR(46, 844, __pyx_L1_error)
+      }
+      __pyx_L15:;
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":845
+ *             else:
+ *                 raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ *             f += 1             # <<<<<<<<<<<<<<
+ *         else:
+ *             # Cython ignores struct boundary information ("T{...}"),
+ */
+      __pyx_v_f = (__pyx_v_f + 1);
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":820
+ *         offset[0] += child.itemsize
+ * 
+ *         if not PyDataType_HASFIELDS(child):             # <<<<<<<<<<<<<<
+ *             t = child.type_num
+ *             if end - f < 5:
+ */
+      goto __pyx_L13;
+    }
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":849
+ *             # Cython ignores struct boundary information ("T{...}"),
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)             # <<<<<<<<<<<<<<
+ *     return f
+ * 
+ */
+    /*else*/ {
+      __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) __PYX_ERR(46, 849, __pyx_L1_error)
+      __pyx_v_f = __pyx_t_9;
+    }
+    __pyx_L13:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":794
+ *     cdef tuple fields
+ * 
+ *     for childname in descr.names:             # <<<<<<<<<<<<<<
+ *         fields = descr.fields[childname]
+ *         child, new_offset = fields
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":850
+ *             # so don't output it
+ *             f = _util_dtypestring(child, f, end, offset)
+ *     return f             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_f;
+  goto __pyx_L0;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ *     return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+ * 
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:             # <<<<<<<<<<<<<<
+ *     # Recursive utility function used in __getbuffer__ to get format
+ *     # string. The new location in the format string is returned.
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_3);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = NULL;
+  __pyx_L0:;
+  __Pyx_XDECREF((PyObject *)__pyx_v_child);
+  __Pyx_XDECREF(__pyx_v_fields);
+  __Pyx_XDECREF(__pyx_v_childname);
+  __Pyx_XDECREF(__pyx_v_new_offset);
+  __Pyx_XDECREF(__pyx_v_t);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+  PyObject *__pyx_v_baseptr;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  int __pyx_t_2;
+  __Pyx_RefNannySetupContext("set_array_base", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+  __pyx_t_1 = (__pyx_v_base == Py_None);
+  __pyx_t_2 = (__pyx_t_1 != 0);
+  if (__pyx_t_2) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":969
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ *          baseptr = NULL             # <<<<<<<<<<<<<<
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ */
+    __pyx_v_baseptr = NULL;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":968
+ * cdef inline void set_array_base(ndarray arr, object base):
+ *      cdef PyObject* baseptr
+ *      if base is None:             # <<<<<<<<<<<<<<
+ *          baseptr = NULL
+ *      else:
+ */
+    goto __pyx_L3;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":971
+ *          baseptr = NULL
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!             # <<<<<<<<<<<<<<
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ */
+  /*else*/ {
+    Py_INCREF(__pyx_v_base);
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":972
+ *      else:
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base             # <<<<<<<<<<<<<<
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr
+ */
+    __pyx_v_baseptr = ((PyObject *)__pyx_v_base);
+  }
+  __pyx_L3:;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":973
+ *          Py_INCREF(base) # important to do this before decref below!
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)             # <<<<<<<<<<<<<<
+ *      arr.base = baseptr
+ * 
+ */
+  Py_XDECREF(__pyx_v_arr->base);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":974
+ *          baseptr = <PyObject*>base
+ *      Py_XDECREF(arr.base)
+ *      arr.base = baseptr             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ */
+  __pyx_v_arr->base = __pyx_v_baseptr;
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":966
+ * 
+ * 
+ * cdef inline void set_array_base(ndarray arr, object base):             # <<<<<<<<<<<<<<
+ *      cdef PyObject* baseptr
+ *      if base is None:
+ */
+
+  /* function exit code */
+  __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  int __pyx_t_1;
+  __Pyx_RefNannySetupContext("get_array_base", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0);
+  if (__pyx_t_1) {
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":978
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:
+ *         return None             # <<<<<<<<<<<<<<
+ *     else:
+ *         return <object>arr.base
+ */
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(Py_None);
+    __pyx_r = Py_None;
+    goto __pyx_L0;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":977
+ * 
+ * cdef inline object get_array_base(ndarray arr):
+ *     if arr.base is NULL:             # <<<<<<<<<<<<<<
+ *         return None
+ *     else:
+ */
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":980
+ *         return None
+ *     else:
+ *         return <object>arr.base             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  /*else*/ {
+    __Pyx_XDECREF(__pyx_r);
+    __Pyx_INCREF(((PyObject *)__pyx_v_arr->base));
+    __pyx_r = ((PyObject *)__pyx_v_arr->base);
+    goto __pyx_L0;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":976
+ *      arr.base = baseptr
+ * 
+ * cdef inline object get_array_base(ndarray arr):             # <<<<<<<<<<<<<<
+ *     if arr.base is NULL:
+ *         return None
+ */
+
+  /* function exit code */
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_array", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":987
+ * cdef inline int import_array() except -1:
+ *     try:
+ *         _import_array()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ */
+      __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(46, 987, __pyx_L3_error)
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":988
+ *     try:
+ *         _import_array()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(46, 988, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(46, 989, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(46, 989, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":986
+ * # Cython code.
+ * cdef inline int import_array() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_array()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":985
+ * # Versions of the import_* functions which are more suitable for
+ * # Cython code.
+ * cdef inline int import_array() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_array()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_umath", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":993
+ * cdef inline int import_umath() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(46, 993, __pyx_L3_error)
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":994
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(46, 994, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(46, 995, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(46, 995, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":992
+ * 
+ * cdef inline int import_umath() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":991
+ *         raise ImportError("numpy.core.multiarray failed to import")
+ * 
+ * cdef inline int import_umath() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) {
+  int __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  PyObject *__pyx_t_3 = NULL;
+  int __pyx_t_4;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  PyObject *__pyx_t_7 = NULL;
+  PyObject *__pyx_t_8 = NULL;
+  __Pyx_RefNannySetupContext("import_ufunc", 0);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+  {
+    __Pyx_PyThreadState_declare
+    __Pyx_PyThreadState_assign
+    __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
+    __Pyx_XGOTREF(__pyx_t_1);
+    __Pyx_XGOTREF(__pyx_t_2);
+    __Pyx_XGOTREF(__pyx_t_3);
+    /*try:*/ {
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":999
+ * cdef inline int import_ufunc() except -1:
+ *     try:
+ *         _import_umath()             # <<<<<<<<<<<<<<
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+      __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(46, 999, __pyx_L3_error)
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    }
+    __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+    __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
+    goto __pyx_L10_try_end;
+    __pyx_L3_error:;
+    __Pyx_PyThreadState_assign
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1000
+ *     try:
+ *         _import_umath()
+ *     except Exception:             # <<<<<<<<<<<<<<
+ *         raise ImportError("numpy.core.umath failed to import")
+ */
+    __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
+    if (__pyx_t_4) {
+      __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+      if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(46, 1000, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_5);
+      __Pyx_GOTREF(__pyx_t_6);
+      __Pyx_GOTREF(__pyx_t_7);
+
+      /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+      __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(46, 1001, __pyx_L5_except_error)
+      __Pyx_GOTREF(__pyx_t_8);
+      __Pyx_Raise(__pyx_t_8, 0, 0, 0);
+      __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+      __PYX_ERR(46, 1001, __pyx_L5_except_error)
+    }
+    goto __pyx_L5_except_error;
+    __pyx_L5_except_error:;
+
+    /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":998
+ * 
+ * cdef inline int import_ufunc() except -1:
+ *     try:             # <<<<<<<<<<<<<<
+ *         _import_umath()
+ *     except Exception:
+ */
+    __Pyx_PyThreadState_assign
+    __Pyx_XGIVEREF(__pyx_t_1);
+    __Pyx_XGIVEREF(__pyx_t_2);
+    __Pyx_XGIVEREF(__pyx_t_3);
+    __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
+    goto __pyx_L1_error;
+    __pyx_L10_try_end:;
+  }
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":997
+ *         raise ImportError("numpy.core.umath failed to import")
+ * 
+ * cdef inline int import_ufunc() except -1:             # <<<<<<<<<<<<<<
+ *     try:
+ *         _import_umath()
+ */
+
+  /* function exit code */
+  __pyx_r = 0;
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  __Pyx_XDECREF(__pyx_t_7);
+  __Pyx_XDECREF(__pyx_t_8);
+  __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = -1;
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "vector.to_py":67
+ * 
+ * @cname("__pyx_convert_vector_to_py_int")
+ * cdef object __pyx_convert_vector_to_py_int(vector[X]& v):             # <<<<<<<<<<<<<<
+ *     return [X_to_py(v[i]) for i in range(v.size())]
+ * 
+ */
+
+static PyObject *__pyx_convert_vector_to_py_int(const std::vector<int>  &__pyx_v_v) {
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_int", 0);
+
+  /* "vector.to_py":68
+ * @cname("__pyx_convert_vector_to_py_int")
+ * cdef object __pyx_convert_vector_to_py_int(vector[X]& v):
+ *     return [X_to_py(v[i]) for i in range(v.size())]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(47, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_v.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(47, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(47, 68, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "vector.to_py":67
+ * 
+ * @cname("__pyx_convert_vector_to_py_int")
+ * cdef object __pyx_convert_vector_to_py_int(vector[X]& v):             # <<<<<<<<<<<<<<
+ *     return [X_to_py(v[i]) for i in range(v.size())]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_int", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+static PyObject *__pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___(const std::vector<std::vector<int> >  &__pyx_v_v) {
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___", 0);
+
+  /* "vector.to_py":68
+ * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___")
+ * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___(vector[X]& v):
+ *     return [X_to_py(v[i]) for i in range(v.size())]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(47, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_v.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = __pyx_convert_vector_to_py_int((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(47, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(47, 68, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "vector.to_py":67
+ * 
+ * @cname("__pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___")
+ * cdef object __pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___(vector[X]& v):             # <<<<<<<<<<<<<<
+ *     return [X_to_py(v[i]) for i in range(v.size())]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_std_3a__3a_vector_3c_int_3e___", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "vector.from_py":49
+ * 
+ * @cname("__pyx_convert_vector_from_py_int")
+ * cdef vector[X] __pyx_convert_vector_from_py_int(object o) except *:             # <<<<<<<<<<<<<<
+ *     cdef vector[X] v
+ *     for item in o:
+ */
+
+static std::vector<int>  __pyx_convert_vector_from_py_int(PyObject *__pyx_v_o) {
+  std::vector<int>  __pyx_v_v;
+  PyObject *__pyx_v_item = NULL;
+  std::vector<int>  __pyx_r;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  Py_ssize_t __pyx_t_2;
+  PyObject *(*__pyx_t_3)(PyObject *);
+  PyObject *__pyx_t_4 = NULL;
+  int __pyx_t_5;
+  __Pyx_RefNannySetupContext("__pyx_convert_vector_from_py_int", 0);
+
+  /* "vector.from_py":51
+ * cdef vector[X] __pyx_convert_vector_from_py_int(object o) except *:
+ *     cdef vector[X] v
+ *     for item in o:             # <<<<<<<<<<<<<<
+ *         v.push_back(X_from_py(item))
+ *     return v
+ */
+  if (likely(PyList_CheckExact(__pyx_v_o)) || PyTuple_CheckExact(__pyx_v_o)) {
+    __pyx_t_1 = __pyx_v_o; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+    __pyx_t_3 = NULL;
+  } else {
+    __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_o); if (unlikely(!__pyx_t_1)) __PYX_ERR(47, 51, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_1);
+    __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(47, 51, __pyx_L1_error)
+  }
+  for (;;) {
+    if (likely(!__pyx_t_3)) {
+      if (likely(PyList_CheckExact(__pyx_t_1))) {
+        if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(47, 51, __pyx_L1_error)
+        #else
+        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(47, 51, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        #endif
+      } else {
+        if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+        #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+        __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(47, 51, __pyx_L1_error)
+        #else
+        __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(47, 51, __pyx_L1_error)
+        __Pyx_GOTREF(__pyx_t_4);
+        #endif
+      }
+    } else {
+      __pyx_t_4 = __pyx_t_3(__pyx_t_1);
+      if (unlikely(!__pyx_t_4)) {
+        PyObject* exc_type = PyErr_Occurred();
+        if (exc_type) {
+          if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+          else __PYX_ERR(47, 51, __pyx_L1_error)
+        }
+        break;
+      }
+      __Pyx_GOTREF(__pyx_t_4);
+    }
+    __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_4);
+    __pyx_t_4 = 0;
+
+    /* "vector.from_py":52
+ *     cdef vector[X] v
+ *     for item in o:
+ *         v.push_back(X_from_py(item))             # <<<<<<<<<<<<<<
+ *     return v
+ * 
+ */
+    __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_v_item); if (unlikely(__pyx_t_5 == -1 && PyErr_Occurred())) __PYX_ERR(47, 52, __pyx_L1_error)
+    __pyx_v_v.push_back(__pyx_t_5);
+
+    /* "vector.from_py":51
+ * cdef vector[X] __pyx_convert_vector_from_py_int(object o) except *:
+ *     cdef vector[X] v
+ *     for item in o:             # <<<<<<<<<<<<<<
+ *         v.push_back(X_from_py(item))
+ *     return v
+ */
+  }
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+  /* "vector.from_py":53
+ *     for item in o:
+ *         v.push_back(X_from_py(item))
+ *     return v             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __pyx_r = __pyx_v_v;
+  goto __pyx_L0;
+
+  /* "vector.from_py":49
+ * 
+ * @cname("__pyx_convert_vector_from_py_int")
+ * cdef vector[X] __pyx_convert_vector_from_py_int(object o) except *:             # <<<<<<<<<<<<<<
+ *     cdef vector[X] v
+ *     for item in o:
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("vector.from_py.__pyx_convert_vector_from_py_int", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_L0:;
+  __Pyx_XDECREF(__pyx_v_item);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+
+/* "vector.to_py":67
+ * 
+ * @cname("__pyx_convert_vector_to_py_float")
+ * cdef object __pyx_convert_vector_to_py_float(vector[X]& v):             # <<<<<<<<<<<<<<
+ *     return [X_to_py(v[i]) for i in range(v.size())]
+ * 
+ */
+
+static PyObject *__pyx_convert_vector_to_py_float(const std::vector<float>  &__pyx_v_v) {
+  size_t __pyx_v_i;
+  PyObject *__pyx_r = NULL;
+  __Pyx_RefNannyDeclarations
+  PyObject *__pyx_t_1 = NULL;
+  size_t __pyx_t_2;
+  size_t __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  __Pyx_RefNannySetupContext("__pyx_convert_vector_to_py_float", 0);
+
+  /* "vector.to_py":68
+ * @cname("__pyx_convert_vector_to_py_float")
+ * cdef object __pyx_convert_vector_to_py_float(vector[X]& v):
+ *     return [X_to_py(v[i]) for i in range(v.size())]             # <<<<<<<<<<<<<<
+ * 
+ * 
+ */
+  __Pyx_XDECREF(__pyx_r);
+  __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(47, 68, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_2 = __pyx_v_v.size();
+  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
+    __pyx_v_i = __pyx_t_3;
+    __pyx_t_4 = PyFloat_FromDouble((__pyx_v_v[__pyx_v_i])); if (unlikely(!__pyx_t_4)) __PYX_ERR(47, 68, __pyx_L1_error)
+    __Pyx_GOTREF(__pyx_t_4);
+    if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(47, 68, __pyx_L1_error)
+    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  }
+  __pyx_r = __pyx_t_1;
+  __pyx_t_1 = 0;
+  goto __pyx_L0;
+
+  /* "vector.to_py":67
+ * 
+ * @cname("__pyx_convert_vector_to_py_float")
+ * cdef object __pyx_convert_vector_to_py_float(vector[X]& v):             # <<<<<<<<<<<<<<
+ *     return [X_to_py(v[i]) for i in range(v.size())]
+ * 
+ */
+
+  /* function exit code */
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_AddTraceback("vector.to_py.__pyx_convert_vector_to_py_float", __pyx_clineno, __pyx_lineno, __pyx_filename);
+  __pyx_r = 0;
+  __pyx_L0:;
+  __Pyx_XGIVEREF(__pyx_r);
+  __Pyx_RefNannyFinishContext();
+  return __pyx_r;
+}
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud __pyx_vtable_3pcl_4_pcl_PointCloud;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_PointCloud;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_PointCloudPtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_10PointCloud_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PointCloud(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud *p = (struct __pyx_obj_3pcl_4_pcl_PointCloud *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_3pcl_4_pcl_PointCloud(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_10PointCloud_width(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_10PointCloud_5width_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_10PointCloud_height(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_10PointCloud_6height_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_10PointCloud_size(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_10PointCloud_4size_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_10PointCloud_is_dense(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_10PointCloud_8is_dense_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_10PointCloud_sensor_origin(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_10PointCloud_13sensor_origin_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_10PointCloud_sensor_orientation(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_10PointCloud_18sensor_orientation_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PointCloud[] = {
+  {"__reduce__", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_9__reduce__, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_8__reduce__},
+  {"from_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_11from_array, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_10from_array},
+  {"to_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_13to_array, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_12to_array},
+  {"from_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_15from_list, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_14from_list},
+  {"to_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_17to_list, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_16to_list},
+  {"resize", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_19resize, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_18resize},
+  {"get_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_21get_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_10PointCloud_20get_point},
+  {"from_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_25from_file, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_24from_file},
+  {"_from_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_27_from_pcd_file, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_26_from_pcd_file},
+  {"_from_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_29_from_ply_file, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_28_from_ply_file},
+  {"to_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_31to_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_10PointCloud_30to_file},
+  {"_to_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_33_to_pcd_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_10PointCloud_32_to_pcd_file},
+  {"_to_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_35_to_ply_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_10PointCloud_34_to_ply_file},
+  {"make_segmenter", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_37make_segmenter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_36make_segmenter},
+  {"make_segmenter_normals", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_39make_segmenter_normals, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_10PointCloud_38make_segmenter_normals},
+  {"make_statistical_outlier_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_41make_statistical_outlier_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_40make_statistical_outlier_filter},
+  {"make_voxel_grid_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_43make_voxel_grid_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_42make_voxel_grid_filter},
+  {"make_ApproximateVoxelGrid", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_45make_ApproximateVoxelGrid, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_44make_ApproximateVoxelGrid},
+  {"make_passthrough_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_47make_passthrough_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_46make_passthrough_filter},
+  {"make_moving_least_squares", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_49make_moving_least_squares, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_48make_moving_least_squares},
+  {"make_kdtree", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_51make_kdtree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_50make_kdtree},
+  {"make_kdtree_flann", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_53make_kdtree_flann, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_52make_kdtree_flann},
+  {"make_octree", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_55make_octree, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_54make_octree},
+  {"make_octreeSearch", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_57make_octreeSearch, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_56make_octreeSearch},
+  {"make_octreeChangeDetector", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_59make_octreeChangeDetector, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_58make_octreeChangeDetector},
+  {"make_crophull", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_61make_crophull, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_60make_crophull},
+  {"make_cropbox", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_63make_cropbox, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_62make_cropbox},
+  {"make_IntegralImageNormalEstimation", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_65make_IntegralImageNormalEstimation, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_64make_IntegralImageNormalEstimation},
+  {"extract", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_67extract, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_10PointCloud_66extract},
+  {"make_ProjectInliers", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_69make_ProjectInliers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_68make_ProjectInliers},
+  {"make_RadiusOutlierRemoval", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_71make_RadiusOutlierRemoval, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_70make_RadiusOutlierRemoval},
+  {"make_ConditionAnd", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_73make_ConditionAnd, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_72make_ConditionAnd},
+  {"make_ConditionalRemoval", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_75make_ConditionalRemoval, METH_O, __pyx_doc_3pcl_4_pcl_10PointCloud_74make_ConditionalRemoval},
+  {"make_ConcaveHull", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_77make_ConcaveHull, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_76make_ConcaveHull},
+  {"make_HarrisKeypoint3D", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_79make_HarrisKeypoint3D, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_78make_HarrisKeypoint3D},
+  {"make_NormalEstimation", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_81make_NormalEstimation, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_80make_NormalEstimation},
+  {"make_VFHEstimation", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_83make_VFHEstimation, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_82make_VFHEstimation},
+  {"make_RangeImage", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_85make_RangeImage, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_84make_RangeImage},
+  {"make_EuclideanClusterExtraction", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_87make_EuclideanClusterExtraction, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_86make_EuclideanClusterExtraction},
+  {"make_GeneralizedIterativeClosestPoint", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_89make_GeneralizedIterativeClosestPoint, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_88make_GeneralizedIterativeClosestPoint},
+  {"make_IterativeClosestPointNonLinear", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_91make_IterativeClosestPointNonLinear, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_90make_IterativeClosestPointNonLinear},
+  {"make_IterativeClosestPoint", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_93make_IterativeClosestPoint, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_92make_IterativeClosestPoint},
+  {"make_MomentOfInertiaEstimation", (PyCFunction)__pyx_pw_3pcl_4_pcl_10PointCloud_95make_MomentOfInertiaEstimation, METH_NOARGS, __pyx_doc_3pcl_4_pcl_10PointCloud_94make_MomentOfInertiaEstimation},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_PointCloud[] = {
+  {(char *)"width", __pyx_getprop_3pcl_4_pcl_10PointCloud_width, 0, (char *)" property containing the width of the point cloud ", 0},
+  {(char *)"height", __pyx_getprop_3pcl_4_pcl_10PointCloud_height, 0, (char *)" property containing the height of the point cloud ", 0},
+  {(char *)"size", __pyx_getprop_3pcl_4_pcl_10PointCloud_size, 0, (char *)" property containing the number of points in the point cloud ", 0},
+  {(char *)"is_dense", __pyx_getprop_3pcl_4_pcl_10PointCloud_is_dense, 0, (char *)" property containing whether the cloud is dense or not ", 0},
+  {(char *)"sensor_origin", __pyx_getprop_3pcl_4_pcl_10PointCloud_sensor_origin, 0, (char *)0, 0},
+  {(char *)"sensor_orientation", __pyx_getprop_3pcl_4_pcl_10PointCloud_sensor_orientation, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_PointCloud = {
+  0, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_3pcl_4_pcl_PointCloud, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_PointCloud = {
+  0, /*mp_length*/
+  __pyx_pw_3pcl_4_pcl_10PointCloud_23__getitem__, /*mp_subscript*/
+  0, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_PointCloud = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_10PointCloud_5__getbuffer__, /*bf_getbuffer*/
+  __pyx_pw_3pcl_4_pcl_10PointCloud_7__releasebuffer__, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PointCloud = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PointCloud", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PointCloud), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PointCloud, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_10PointCloud_3__repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_PointCloud, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_PointCloud, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_PointCloud, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "Represents a cloud of points in 3-d space.\n\n    A point cloud can be initialized from either a NumPy ndarray of shape\n    (n_points, 3), from a list of triples, or from an integer n to create an\n    \"empty\" cloud of n points.\n\n    To load a point cloud from disk, use pcl.load.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PointCloud, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_PointCloud, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PointCloud, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZI __pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZI;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZI;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZI_Ptr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointXYZI(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *p = (struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_3pcl_4_pcl_PointCloud_PointXYZI(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_width(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_5width_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_height(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_6height_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_size(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_4size_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_is_dense(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_8is_dense_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_sensor_origin(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_13sensor_origin_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_sensor_orientation(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_18sensor_orientation_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PointCloud_PointXYZI[] = {
+  {"__reduce__", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_9__reduce__, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_8__reduce__},
+  {"from_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_11from_array, METH_O, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_10from_array},
+  {"to_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_13to_array, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_12to_array},
+  {"from_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_15from_list, METH_O, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_14from_list},
+  {"to_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_17to_list, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_16to_list},
+  {"resize", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_19resize, METH_O, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_18resize},
+  {"get_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_21get_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_20get_point},
+  {"from_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_25from_file, METH_O, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_24from_file},
+  {"_from_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_27_from_pcd_file, METH_O, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_26_from_pcd_file},
+  {"_from_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_29_from_ply_file, METH_O, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_28_from_ply_file},
+  {"to_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_31to_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_30to_file},
+  {"_to_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_33_to_pcd_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_32_to_pcd_file},
+  {"_to_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_35_to_ply_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_34_to_ply_file},
+  {"make_segmenter", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_37make_segmenter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_36make_segmenter},
+  {"make_segmenter_normals", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_39make_segmenter_normals, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_38make_segmenter_normals},
+  {"make_statistical_outlier_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_41make_statistical_outlier_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_40make_statistical_outlier_filter},
+  {"make_voxel_grid_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_43make_voxel_grid_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_42make_voxel_grid_filter},
+  {"make_passthrough_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_45make_passthrough_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_44make_passthrough_filter},
+  {"make_kdtree_flann", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_47make_kdtree_flann, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_46make_kdtree_flann},
+  {"extract", (PyCFunction)__pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_49extract, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_20PointCloud_PointXYZI_48extract},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_PointCloud_PointXYZI[] = {
+  {(char *)"width", __pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_width, 0, (char *)" property containing the width of the point cloud ", 0},
+  {(char *)"height", __pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_height, 0, (char *)" property containing the height of the point cloud ", 0},
+  {(char *)"size", __pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_size, 0, (char *)" property containing the number of points in the point cloud ", 0},
+  {(char *)"is_dense", __pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_is_dense, 0, (char *)" property containing whether the cloud is dense or not ", 0},
+  {(char *)"sensor_origin", __pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_sensor_origin, 0, (char *)0, 0},
+  {(char *)"sensor_orientation", __pyx_getprop_3pcl_4_pcl_20PointCloud_PointXYZI_sensor_orientation, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_PointCloud_PointXYZI = {
+  0, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_3pcl_4_pcl_PointCloud_PointXYZI, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_PointCloud_PointXYZI = {
+  0, /*mp_length*/
+  __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_23__getitem__, /*mp_subscript*/
+  0, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_PointCloud_PointXYZI = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_5__getbuffer__, /*bf_getbuffer*/
+  __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_7__releasebuffer__, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PointCloud_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PointCloud_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_3__repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_PointCloud_PointXYZI, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_PointCloud_PointXYZI, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_PointCloud_PointXYZI, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "Represents a cloud of points in 3-d space.\n\n    A point cloud can be initialized from either a NumPy ndarray of shape\n    (n_points, 4), from a list of triples, or from an integer n to create an\n    \"empty\" cloud of n points.\n\n    To load a point cloud from disk, use pcl.load.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PointCloud_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_PointCloud_PointXYZI, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGB __pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZRGB;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGB;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGB_Ptr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointXYZRGB(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *p = (struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_3pcl_4_pcl_PointCloud_PointXYZRGB(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_width(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_5width_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_height(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_6height_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_size(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_4size_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_is_dense(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_8is_dense_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_sensor_origin(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_13sensor_origin_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_sensor_orientation(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_18sensor_orientation_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PointCloud_PointXYZRGB[] = {
+  {"__reduce__", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_9__reduce__, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_8__reduce__},
+  {"from_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_11from_array, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_10from_array},
+  {"to_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_13to_array, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_12to_array},
+  {"from_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_15from_list, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_14from_list},
+  {"to_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_17to_list, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_16to_list},
+  {"resize", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_19resize, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_18resize},
+  {"get_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_21get_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_20get_point},
+  {"from_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_25from_file, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_24from_file},
+  {"_from_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_27_from_pcd_file, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_26_from_pcd_file},
+  {"_from_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_29_from_ply_file, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_28_from_ply_file},
+  {"to_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_31to_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_30to_file},
+  {"_to_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_33_to_pcd_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_32_to_pcd_file},
+  {"_to_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_35_to_ply_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_34_to_ply_file},
+  {"make_segmenter", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_37make_segmenter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_36make_segmenter},
+  {"make_segmenter_normals", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_39make_segmenter_normals, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_38make_segmenter_normals},
+  {"make_statistical_outlier_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_41make_statistical_outlier_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_40make_statistical_outlier_filter},
+  {"make_voxel_grid_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_43make_voxel_grid_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_42make_voxel_grid_filter},
+  {"make_passthrough_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_45make_passthrough_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_44make_passthrough_filter},
+  {"make_moving_least_squares", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_47make_moving_least_squares, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_46make_moving_least_squares},
+  {"make_kdtree_flann", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_49make_kdtree_flann, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_48make_kdtree_flann},
+  {"extract", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_51extract, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointXYZRGB_50extract},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_PointCloud_PointXYZRGB[] = {
+  {(char *)"width", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_width, 0, (char *)" property containing the width of the point cloud ", 0},
+  {(char *)"height", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_height, 0, (char *)" property containing the height of the point cloud ", 0},
+  {(char *)"size", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_size, 0, (char *)" property containing the number of points in the point cloud ", 0},
+  {(char *)"is_dense", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_is_dense, 0, (char *)" property containing whether the cloud is dense or not ", 0},
+  {(char *)"sensor_origin", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_sensor_origin, 0, (char *)0, 0},
+  {(char *)"sensor_orientation", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointXYZRGB_sensor_orientation, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_PointCloud_PointXYZRGB = {
+  0, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_3pcl_4_pcl_PointCloud_PointXYZRGB, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_PointCloud_PointXYZRGB = {
+  0, /*mp_length*/
+  __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_23__getitem__, /*mp_subscript*/
+  0, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_PointCloud_PointXYZRGB = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_5__getbuffer__, /*bf_getbuffer*/
+  __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_7__releasebuffer__, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PointCloud_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_3__repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_PointCloud_PointXYZRGB, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_PointCloud_PointXYZRGB, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_PointCloud_PointXYZRGB, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "Represents a cloud of points in 3-d space.\n\n    A point cloud can be initialized from either a NumPy ndarray of shape\n    (n_points, 3), from a list of triples, or from an integer n to create an\n    \"empty\" cloud of n points.\n\n    To load a point cloud from disk, use pcl.load.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PointCloud_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_PointCloud_PointXYZRGB, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointXYZRGBA __pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZRGBA;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGBA;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_PointCloud_PointXYZRGBA_Ptr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointXYZRGBA(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *p = (struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_3pcl_4_pcl_PointCloud_PointXYZRGBA(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_width(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5width_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_height(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_6height_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_size(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_4size_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_is_dense(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8is_dense_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_sensor_origin(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13sensor_origin_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_sensor_orientation(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18sensor_orientation_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PointCloud_PointXYZRGBA[] = {
+  {"__reduce__", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_9__reduce__, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_8__reduce__},
+  {"from_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_11from_array, METH_O, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_10from_array},
+  {"to_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_13to_array, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_12to_array},
+  {"from_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_15from_list, METH_O, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_14from_list},
+  {"to_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_17to_list, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_16to_list},
+  {"resize", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_19resize, METH_O, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_18resize},
+  {"get_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_21get_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_20get_point},
+  {"from_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_25from_file, METH_O, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_24from_file},
+  {"_from_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_27_from_pcd_file, METH_O, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_26_from_pcd_file},
+  {"_from_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_29_from_ply_file, METH_O, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_28_from_ply_file},
+  {"to_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_31to_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_30to_file},
+  {"_to_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_33_to_pcd_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_32_to_pcd_file},
+  {"_to_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_35_to_ply_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_34_to_ply_file},
+  {"make_segmenter", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_37make_segmenter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_36make_segmenter},
+  {"make_segmenter_normals", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_39make_segmenter_normals, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_38make_segmenter_normals},
+  {"make_statistical_outlier_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_41make_statistical_outlier_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_40make_statistical_outlier_filter},
+  {"make_voxel_grid_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_43make_voxel_grid_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_42make_voxel_grid_filter},
+  {"make_passthrough_filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_45make_passthrough_filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_44make_passthrough_filter},
+  {"make_moving_least_squares", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_47make_moving_least_squares, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_46make_moving_least_squares},
+  {"make_kdtree_flann", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_49make_kdtree_flann, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_48make_kdtree_flann},
+  {"extract", (PyCFunction)__pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_51extract, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23PointCloud_PointXYZRGBA_50extract},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_PointCloud_PointXYZRGBA[] = {
+  {(char *)"width", __pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_width, 0, (char *)" property containing the width of the point cloud ", 0},
+  {(char *)"height", __pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_height, 0, (char *)" property containing the height of the point cloud ", 0},
+  {(char *)"size", __pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_size, 0, (char *)" property containing the number of points in the point cloud ", 0},
+  {(char *)"is_dense", __pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_is_dense, 0, (char *)" property containing whether the cloud is dense or not ", 0},
+  {(char *)"sensor_origin", __pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_sensor_origin, 0, (char *)0, 0},
+  {(char *)"sensor_orientation", __pyx_getprop_3pcl_4_pcl_23PointCloud_PointXYZRGBA_sensor_orientation, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_PointCloud_PointXYZRGBA = {
+  0, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_3pcl_4_pcl_PointCloud_PointXYZRGBA, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_PointCloud_PointXYZRGBA = {
+  0, /*mp_length*/
+  __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_23__getitem__, /*mp_subscript*/
+  0, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_PointCloud_PointXYZRGBA = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5__getbuffer__, /*bf_getbuffer*/
+  __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_7__releasebuffer__, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PointCloud_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_3__repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_PointCloud_PointXYZRGBA, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_PointCloud_PointXYZRGBA, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_PointCloud_PointXYZRGBA, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "Represents a cloud of points in 3-d space.\n\n    A point cloud can be initialized from either a NumPy ndarray of shape\n    (n_points, 3), from a list of triples, or from an integer n to create an\n    \"empty\" cloud of n points.\n\n    To load a point cloud from disk, use pcl.load.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PointCloud_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_PointCloud_PointXYZRGBA, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PointCloud_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_Vertices __pyx_vtable_3pcl_4_pcl_Vertices;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Vertices(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_Vertices *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_Vertices *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_Vertices;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_VerticesPtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_8Vertices_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Vertices(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_Vertices *p = (struct __pyx_obj_3pcl_4_pcl_Vertices *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Vertices[] = {
+  {"from_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_8Vertices_5from_array, METH_O, __pyx_doc_3pcl_4_pcl_8Vertices_4from_array},
+  {"to_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_8Vertices_7to_array, METH_NOARGS, __pyx_doc_3pcl_4_pcl_8Vertices_6to_array},
+  {"from_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_8Vertices_9from_list, METH_O, __pyx_doc_3pcl_4_pcl_8Vertices_8from_list},
+  {"to_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_8Vertices_11to_list, METH_NOARGS, __pyx_doc_3pcl_4_pcl_8Vertices_10to_list},
+  {"resize", (PyCFunction)__pyx_pw_3pcl_4_pcl_8Vertices_13resize, METH_O, __pyx_doc_3pcl_4_pcl_8Vertices_12resize},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Vertices = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Vertices", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Vertices), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Vertices, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_8Vertices_3__repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Vertices, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Vertices, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointWithViewpoint __pyx_vtable_3pcl_4_pcl_PointCloud_PointWithViewpoint;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointWithViewpoint(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointWithViewpoint;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_PointCloud_PointWithViewpoint_Ptr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointWithViewpoint(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *p = (struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_3pcl_4_pcl_PointCloud_PointWithViewpoint(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_width(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5width_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_height(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6height_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_size(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_4size_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_is_dense(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8is_dense_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PointCloud_PointWithViewpoint[] = {
+  {"__reduce__", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_7__reduce__, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_6__reduce__},
+  {"from_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_9from_array, METH_O, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_8from_array},
+  {"to_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_11to_array, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_10to_array},
+  {"from_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_13from_list, METH_O, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_12from_list},
+  {"to_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_15to_list, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_14to_list},
+  {"resize", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_17resize, METH_O, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_16resize},
+  {"get_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_19get_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_18get_point},
+  {"from_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_23from_file, METH_O, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_22from_file},
+  {"_from_pcd_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_25_from_pcd_file, METH_O, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_24_from_pcd_file},
+  {"_from_ply_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_27_from_ply_file, METH_O, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_26_from_ply_file},
+  {"to_file", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_29to_file, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_29PointCloud_PointWithViewpoint_28to_file},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_PointCloud_PointWithViewpoint[] = {
+  {(char *)"width", __pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_width, 0, (char *)" property containing the width of the point cloud ", 0},
+  {(char *)"height", __pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_height, 0, (char *)" property containing the height of the point cloud ", 0},
+  {(char *)"size", __pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_size, 0, (char *)" property containing the number of points in the point cloud ", 0},
+  {(char *)"is_dense", __pyx_getprop_3pcl_4_pcl_29PointCloud_PointWithViewpoint_is_dense, 0, (char *)" property containing whether the cloud is dense or not ", 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_PointCloud_PointWithViewpoint = {
+  0, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_3pcl_4_pcl_PointCloud_PointWithViewpoint, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_PointCloud_PointWithViewpoint = {
+  0, /*mp_length*/
+  __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_21__getitem__, /*mp_subscript*/
+  0, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_PointCloud_PointWithViewpoint = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  0, /*bf_getbuffer*/
+  __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_5__releasebuffer__, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PointCloud_PointWithViewpoint = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PointCloud_PointWithViewpoint", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointWithViewpoint, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_29PointCloud_PointWithViewpoint_3__repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_PointCloud_PointWithViewpoint, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_PointCloud_PointWithViewpoint, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_PointCloud_PointWithViewpoint, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Represents a cloud of points in 6-d space.\n    A point cloud can be initialized from either a NumPy ndarray of shape\n    (n_points, 6), from a list of triples, or from an integer n to create an\n    \"empty\" cloud of n points.\n    To load a point cloud from disk, use pcl.load.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PointCloud_PointWithViewpoint, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_PointCloud_PointWithViewpoint, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PointCloud_PointWithViewpoint, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_Normal __pyx_vtable_3pcl_4_pcl_PointCloud_Normal;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_Normal(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_PointCloud_Normal;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_PointCloud_Normal_Ptr_t();
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_Normal(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *p = (struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PointCloud_Normal = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PointCloud_Normal", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_Normal, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PointCloud_Normal, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_PointCloud_PointNormal __pyx_vtable_3pcl_4_pcl_PointCloud_PointNormal;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PointCloud_PointNormal(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointNormal;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_8pcl_defs_PointCloud_PointNormal_Ptr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointNormal(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *p = (struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+static PyObject *__pyx_sq_item_3pcl_4_pcl_PointCloud_PointNormal(PyObject *o, Py_ssize_t i) {
+  PyObject *r;
+  PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0;
+  r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x);
+  Py_DECREF(x);
+  return r;
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_width(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_5width_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_height(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_6height_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_size(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_4size_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_is_dense(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_8is_dense_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PointCloud_PointNormal[] = {
+  {"__reduce__", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_7__reduce__, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_6__reduce__},
+  {"from_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_9from_array, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_8from_array},
+  {"to_array", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_11to_array, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_10to_array},
+  {"from_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_13from_list, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_12from_list},
+  {"to_list", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_15to_list, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_14to_list},
+  {"resize", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_17resize, METH_O, __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_16resize},
+  {"get_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_19get_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22PointCloud_PointNormal_18get_point},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_PointCloud_PointNormal[] = {
+  {(char *)"width", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_width, 0, (char *)" property containing the width of the point cloud ", 0},
+  {(char *)"height", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_height, 0, (char *)" property containing the height of the point cloud ", 0},
+  {(char *)"size", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_size, 0, (char *)" property containing the number of points in the point cloud ", 0},
+  {(char *)"is_dense", __pyx_getprop_3pcl_4_pcl_22PointCloud_PointNormal_is_dense, 0, (char *)" property containing whether the cloud is dense or not ", 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PySequenceMethods __pyx_tp_as_sequence_PointCloud_PointNormal = {
+  0, /*sq_length*/
+  0, /*sq_concat*/
+  0, /*sq_repeat*/
+  __pyx_sq_item_3pcl_4_pcl_PointCloud_PointNormal, /*sq_item*/
+  0, /*sq_slice*/
+  0, /*sq_ass_item*/
+  0, /*sq_ass_slice*/
+  0, /*sq_contains*/
+  0, /*sq_inplace_concat*/
+  0, /*sq_inplace_repeat*/
+};
+
+static PyMappingMethods __pyx_tp_as_mapping_PointCloud_PointNormal = {
+  0, /*mp_length*/
+  __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_21__getitem__, /*mp_subscript*/
+  0, /*mp_ass_subscript*/
+};
+
+static PyBufferProcs __pyx_tp_as_buffer_PointCloud_PointNormal = {
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getreadbuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getwritebuffer*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getsegcount*/
+  #endif
+  #if PY_MAJOR_VERSION < 3
+  0, /*bf_getcharbuffer*/
+  #endif
+  0, /*bf_getbuffer*/
+  __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_5__releasebuffer__, /*bf_releasebuffer*/
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PointCloud_PointNormal = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PointCloud_PointNormal", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PointCloud_PointNormal, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  __pyx_pw_3pcl_4_pcl_22PointCloud_PointNormal_3__repr__, /*tp_repr*/
+  0, /*tp_as_number*/
+  &__pyx_tp_as_sequence_PointCloud_PointNormal, /*tp_as_sequence*/
+  &__pyx_tp_as_mapping_PointCloud_PointNormal, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  &__pyx_tp_as_buffer_PointCloud_PointNormal, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Represents a cloud of points in 4-d space.\n    A point cloud can be initialized from either a NumPy ndarray of shape\n    (n_points, 4), from a list of triples, or from an integer n to create an\n    \"empty\" cloud of n points.\n    To load a point cloud from disk, use pcl.load.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PointCloud_PointNormal, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_PointCloud_PointNormal, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PointCloud_PointNormal, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTree __pyx_vtable_3pcl_4_pcl_KdTree;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTree(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_KdTree *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_KdTree *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_KdTree;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_10pcl_kdtree_KdTreePtr_t();
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_KdTree(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_KdTree *p = (struct __pyx_obj_3pcl_4_pcl_KdTree *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_KdTree = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.KdTree", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_KdTree), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_KdTree, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_KdTree, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_RangeImages __pyx_vtable_3pcl_4_pcl_RangeImages;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_RangeImages(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_RangeImages *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_RangeImages *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_RangeImages;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_15pcl_range_image_RangeImagePtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_11RangeImages_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_RangeImages(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_RangeImages *p = (struct __pyx_obj_3pcl_4_pcl_RangeImages *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_RangeImages[] = {
+  {"CreateFromPointCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_11RangeImages_3CreateFromPointCloud, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_11RangeImages_2CreateFromPointCloud},
+  {"SetAngularResolution", (PyCFunction)__pyx_pw_3pcl_4_pcl_11RangeImages_5SetAngularResolution, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_11RangeImages_4SetAngularResolution},
+  {"IntegrateFarRanges", (PyCFunction)__pyx_pw_3pcl_4_pcl_11RangeImages_7IntegrateFarRanges, METH_O, __pyx_doc_3pcl_4_pcl_11RangeImages_6IntegrateFarRanges},
+  {"SetUnseenToMaxRange", (PyCFunction)__pyx_pw_3pcl_4_pcl_11RangeImages_9SetUnseenToMaxRange, METH_NOARGS, __pyx_doc_3pcl_4_pcl_11RangeImages_8SetUnseenToMaxRange},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_RangeImages = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.RangeImages", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_RangeImages), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_RangeImages, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    rangeImage\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_RangeImages, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_RangeImages, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_IntegralImageNormalEstimation __pyx_vtable_3pcl_4_pcl_IntegralImageNormalEstimation;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_IntegralImageNormalEstimation(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_IntegralImageNormalEstimation;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_12pcl_features_IntegralImageNormalEstimationPtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_IntegralImageNormalEstimation(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *p = (struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_IntegralImageNormalEstimation[] = {
+  {"set_NormalEstimation_Method_AVERAGE_3D_GRADIENT", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_3set_NormalEstimation_Method_AVERAGE_3D_GRADIENT, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_2set_NormalEstimation_Method_AVERAGE_3D_GRADIENT},
+  {"set_NormalEstimation_Method_COVARIANCE_MATRIX", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_5set_NormalEstimation_Method_COVARIANCE_MATRIX, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_4set_NormalEstimation_Method_COVARIANCE_MATRIX},
+  {"set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_7set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_6set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE},
+  {"set_NormalEstimation_Method_SIMPLE_3D_GRADIENT", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_9set_NormalEstimation_Method_SIMPLE_3D_GRADIENT, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_8set_NormalEstimation_Method_SIMPLE_3D_GRADIENT},
+  {"set_MaxDepthChange_Factor", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_11set_MaxDepthChange_Factor, METH_O, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_10set_MaxDepthChange_Factor},
+  {"set_NormalSmoothingSize", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_13set_NormalSmoothingSize, METH_O, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_12set_NormalSmoothingSize},
+  {"compute", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_15compute, METH_O, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_14compute},
+  {"compute2", (PyCFunction)__pyx_pw_3pcl_4_pcl_29IntegralImageNormalEstimation_17compute2, METH_O, __pyx_doc_3pcl_4_pcl_29IntegralImageNormalEstimation_16compute2},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_IntegralImageNormalEstimation = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.IntegralImageNormalEstimation", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_IntegralImageNormalEstimation, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    IntegralImageNormalEstimation class for \n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_IntegralImageNormalEstimation, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_IntegralImageNormalEstimation, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModel __pyx_vtable_3pcl_4_pcl_SampleConsensusModel;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModel(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModel;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPtr_t();
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModel(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *p = (struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SampleConsensusModel = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SampleConsensusModel", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModel, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  0, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SampleConsensusModel, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelPlane __pyx_vtable_3pcl_4_pcl_SampleConsensusModelPlane;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelPlane(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelPlane;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelPlanePtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_25SampleConsensusModelPlane_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelPlane(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *p = (struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_SampleConsensusModelPlane[] = {
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SampleConsensusModelPlane = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SampleConsensusModelPlane", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelPlane, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_SampleConsensusModelPlane, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SampleConsensusModelPlane, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelSphere __pyx_vtable_3pcl_4_pcl_SampleConsensusModelSphere;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelSphere(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelSphere;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelSpherePtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_26SampleConsensusModelSphere_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelSphere(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *p = (struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_SampleConsensusModelSphere[] = {
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SampleConsensusModelSphere = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SampleConsensusModelSphere", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelSphere, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_SampleConsensusModelSphere, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SampleConsensusModelSphere, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelCylinder __pyx_vtable_3pcl_4_pcl_SampleConsensusModelCylinder;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelCylinder(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelCylinder;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelCylinderPtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_28SampleConsensusModelCylinder_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelCylinder(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *p = (struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_SampleConsensusModelCylinder[] = {
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SampleConsensusModelCylinder = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SampleConsensusModelCylinder", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelCylinder, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_SampleConsensusModelCylinder, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SampleConsensusModelCylinder, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelLine __pyx_vtable_3pcl_4_pcl_SampleConsensusModelLine;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelLine(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelLine;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelLinePtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_24SampleConsensusModelLine_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelLine(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *p = (struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_SampleConsensusModelLine[] = {
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SampleConsensusModelLine = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SampleConsensusModelLine", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelLine, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_SampleConsensusModelLine, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SampleConsensusModelLine, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelRegistration __pyx_vtable_3pcl_4_pcl_SampleConsensusModelRegistration;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelRegistration(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelRegistration;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelRegistrationPtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_32SampleConsensusModelRegistration_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelRegistration(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *p = (struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_SampleConsensusModelRegistration[] = {
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SampleConsensusModelRegistration = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SampleConsensusModelRegistration", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelRegistration, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_SampleConsensusModelRegistration, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SampleConsensusModelRegistration, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_SampleConsensusModelStick __pyx_vtable_3pcl_4_pcl_SampleConsensusModelStick;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SampleConsensusModelStick(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelStick;
+  new((void*)&(p->thisptr_shared)) __pyx_t_3pcl_20pcl_sample_consensus_SampleConsensusModelStickPtr_t();
+  if (unlikely(__pyx_pw_3pcl_4_pcl_25SampleConsensusModelStick_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelStick(PyObject *o) {
+  struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *p = (struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *)o;
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  __Pyx_call_destructor(p->thisptr_shared);
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_SampleConsensusModelStick[] = {
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SampleConsensusModelStick = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SampleConsensusModelStick", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SampleConsensusModelStick, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_SampleConsensusModelStick, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SampleConsensusModelStick, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl__CythonCompareOp_Type(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl__CythonCompareOp_Type(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_GT(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2GT_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_GE(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2GE_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_LT(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2LT_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_LE(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2LE_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_EQ(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_21_CythonCompareOp_Type_2EQ_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl__CythonCompareOp_Type[] = {
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl__CythonCompareOp_Type[] = {
+  {(char *)"GT", __pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_GT, 0, (char *)0, 0},
+  {(char *)"GE", __pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_GE, 0, (char *)0, 0},
+  {(char *)"LT", __pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_LT, 0, (char *)0, 0},
+  {(char *)"LE", __pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_LE, 0, (char *)0, 0},
+  {(char *)"EQ", __pyx_getprop_3pcl_4_pcl_21_CythonCompareOp_Type_EQ, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl__CythonCompareOp_Type = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl._CythonCompareOp_Type", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl__CythonCompareOp_Type), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl__CythonCompareOp_Type, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl__CythonCompareOp_Type, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl__CythonCompareOp_Type, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl__CythonCompareOp_Type, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl__CythonCoordinateFrame_Type(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl__CythonCoordinateFrame_Type(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_27_CythonCoordinateFrame_Type_CAMERA_FRAME(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_12CAMERA_FRAME_1__get__(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_27_CythonCoordinateFrame_Type_LASER_FRAME(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_27_CythonCoordinateFrame_Type_11LASER_FRAME_1__get__(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl__CythonCoordinateFrame_Type[] = {
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl__CythonCoordinateFrame_Type[] = {
+  {(char *)"CAMERA_FRAME", __pyx_getprop_3pcl_4_pcl_27_CythonCoordinateFrame_Type_CAMERA_FRAME, 0, (char *)0, 0},
+  {(char *)"LASER_FRAME", __pyx_getprop_3pcl_4_pcl_27_CythonCoordinateFrame_Type_LASER_FRAME, 0, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl__CythonCoordinateFrame_Type = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl._CythonCoordinateFrame_Type", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl__CythonCoordinateFrame_Type), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl__CythonCoordinateFrame_Type, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  0, /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl__CythonCoordinateFrame_Type, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl__CythonCoordinateFrame_Type, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl__CythonCoordinateFrame_Type, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_12Segmentation_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Segmentation(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_12Segmentation_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Segmentation[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_12Segmentation_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_12Segmentation_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_12Segmentation_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_12Segmentation_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_12Segmentation_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_12Segmentation_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_12Segmentation_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_12Segmentation_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_12Segmentation_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_12Segmentation_12set_distance_threshold},
+  {"set_MaxIterations", (PyCFunction)__pyx_pw_3pcl_4_pcl_12Segmentation_15set_MaxIterations, METH_O, __pyx_doc_3pcl_4_pcl_12Segmentation_14set_MaxIterations},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Segmentation = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Segmentation", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Segmentation), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Segmentation, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Segmentation, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Segmentation, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZI(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZI[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_22Segmentation_PointXYZI_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_22Segmentation_PointXYZI_12set_distance_threshold},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Segmentation_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Segmentation_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGB[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_24Segmentation_PointXYZRGB_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_24Segmentation_PointXYZRGB_12set_distance_threshold},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Segmentation_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGBA[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_25Segmentation_PointXYZRGBA_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_25Segmentation_PointXYZRGBA_12set_distance_threshold},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Segmentation_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_SegmentationNormal(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_18SegmentationNormal_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_SegmentationNormal(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_18SegmentationNormal_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_SegmentationNormal[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_12set_distance_threshold},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_15set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_14set_optimize_coefficients},
+  {"set_normal_distance_weight", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_17set_normal_distance_weight, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_16set_normal_distance_weight},
+  {"set_max_iterations", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_19set_max_iterations, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_18set_max_iterations},
+  {"set_radius_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_21set_radius_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_20set_radius_limits},
+  {"set_eps_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_23set_eps_angle, METH_O, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_22set_eps_angle},
+  {"set_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_25set_min_max_opening_angle, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_24set_min_max_opening_angle},
+  {"get_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_18SegmentationNormal_27get_min_max_opening_angle, METH_NOARGS, __pyx_doc_3pcl_4_pcl_18SegmentationNormal_26get_min_max_opening_angle},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_SegmentationNormal = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.SegmentationNormal", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_SegmentationNormal), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_SegmentationNormal, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models that require the\n    use of surface normals for estimation.\n\n    Due to Cython limitations this should derive from pcl.Segmentation, but\n    is currently unable to do so.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_SegmentationNormal, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_SegmentationNormal, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZI_Normal(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZI_Normal(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZI_Normal[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_12set_distance_threshold},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_15set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_14set_optimize_coefficients},
+  {"set_normal_distance_weight", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_17set_normal_distance_weight, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_16set_normal_distance_weight},
+  {"set_max_iterations", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_19set_max_iterations, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_18set_max_iterations},
+  {"set_radius_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_21set_radius_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_20set_radius_limits},
+  {"set_eps_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_23set_eps_angle, METH_O, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_22set_eps_angle},
+  {"set_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_25set_min_max_opening_angle, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_24set_min_max_opening_angle},
+  {"get_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_27get_min_max_opening_angle, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29Segmentation_PointXYZI_Normal_26get_min_max_opening_angle},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Segmentation_PointXYZI_Normal = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Segmentation_PointXYZI_Normal", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZI_Normal), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZI_Normal, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models that require the\n    use of surface normals for estimation.\n\n    Due to Cython limitations this should derive from pcl.Segmentation, but\n    is currently unable to do so.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZI_Normal, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZI_Normal, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_12set_distance_threshold},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_15set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_14set_optimize_coefficients},
+  {"set_normal_distance_weight", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_17set_normal_distance_weight, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_16set_normal_distance_weight},
+  {"set_max_iterations", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_19set_max_iterations, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_18set_max_iterations},
+  {"set_radius_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_21set_radius_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_20set_radius_limits},
+  {"set_eps_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_23set_eps_angle, METH_O, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_22set_eps_angle},
+  {"set_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_25set_min_max_opening_angle, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_24set_min_max_opening_angle},
+  {"get_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_27get_min_max_opening_angle, METH_NOARGS, __pyx_doc_3pcl_4_pcl_31Segmentation_PointXYZRGB_Normal_26get_min_max_opening_angle},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Segmentation_PointXYZRGB_Normal", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models that require the\n    use of surface normals for estimation.\n\n    Due to Cython limitations this should derive from pcl.Segmentation, but\n    is currently unable to do so.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal[] = {
+  {"segment", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_5segment, METH_NOARGS, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_4segment},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_7set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_6set_optimize_coefficients},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_9set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_8set_model_type},
+  {"set_method_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_11set_method_type, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_10set_method_type},
+  {"set_distance_threshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_13set_distance_threshold, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_12set_distance_threshold},
+  {"set_optimize_coefficients", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_15set_optimize_coefficients, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_14set_optimize_coefficients},
+  {"set_normal_distance_weight", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_17set_normal_distance_weight, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_16set_normal_distance_weight},
+  {"set_max_iterations", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_19set_max_iterations, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_18set_max_iterations},
+  {"set_radius_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_21set_radius_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_20set_radius_limits},
+  {"set_eps_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_23set_eps_angle, METH_O, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_22set_eps_angle},
+  {"set_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_25set_min_max_opening_angle, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_24set_min_max_opening_angle},
+  {"get_min_max_opening_angle", (PyCFunction)__pyx_pw_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_27get_min_max_opening_angle, METH_NOARGS, __pyx_doc_3pcl_4_pcl_32Segmentation_PointXYZRGBA_Normal_26get_min_max_opening_angle},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.Segmentation_PointXYZRGBA_Normal", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for Sample Consensus methods and models that require the\n    use of surface normals for estimation.\n\n    Due to Cython limitations this should derive from pcl.Segmentation, but\n    is currently unable to do so.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_EuclideanClusterExtraction(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_EuclideanClusterExtraction(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_EuclideanClusterExtraction[] = {
+  {"set_ClusterTolerance", (PyCFunction)__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_5set_ClusterTolerance, METH_O, __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_4set_ClusterTolerance},
+  {"set_MinClusterSize", (PyCFunction)__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_7set_MinClusterSize, METH_O, __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_6set_MinClusterSize},
+  {"set_MaxClusterSize", (PyCFunction)__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_9set_MaxClusterSize, METH_O, __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_8set_MaxClusterSize},
+  {"set_SearchMethod", (PyCFunction)__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_11set_SearchMethod, METH_O, __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_10set_SearchMethod},
+  {"Extract", (PyCFunction)__pyx_pw_3pcl_4_pcl_26EuclideanClusterExtraction_13Extract, METH_NOARGS, __pyx_doc_3pcl_4_pcl_26EuclideanClusterExtraction_12Extract},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_EuclideanClusterExtraction = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.EuclideanClusterExtraction", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_EuclideanClusterExtraction), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_EuclideanClusterExtraction, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Segmentation class for EuclideanClusterExtraction\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_EuclideanClusterExtraction, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_EuclideanClusterExtraction, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_mean_k(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_mean_k(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6mean_k_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_negative(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_negative(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8negative_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_stddev_mul_thresh(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_stddev_mul_thresh(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_17stddev_mul_thresh_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_4set_InputCloud},
+  {"set_mean_k", (PyCFunction)__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_7set_mean_k, METH_O, __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_6set_mean_k},
+  {"set_std_dev_mul_thresh", (PyCFunction)__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_9set_std_dev_mul_thresh, METH_O, __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_8set_std_dev_mul_thresh},
+  {"set_negative", (PyCFunction)__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_11set_negative, METH_O, __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_10set_negative},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_13filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_12filter},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter[] = {
+  {(char *)"mean_k", __pyx_getprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_mean_k, __pyx_setprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_mean_k, (char *)0, 0},
+  {(char *)"negative", __pyx_getprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_negative, __pyx_setprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_negative, (char *)0, 0},
+  {(char *)"stddev_mul_thresh", __pyx_getprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_stddev_mul_thresh, __pyx_setprop_3pcl_4_pcl_31StatisticalOutlierRemovalFilter_stddev_mul_thresh, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.StatisticalOutlierRemovalFilter", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Filter class uses point neighborhood statistics to filter outlier data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_mean_k(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_mean_k(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6mean_k_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_negative(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_negative(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8negative_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_stddev_mul_thresh(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_stddev_mul_thresh(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_17stddev_mul_thresh_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_4set_InputCloud},
+  {"set_mean_k", (PyCFunction)__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_7set_mean_k, METH_O, __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_6set_mean_k},
+  {"set_std_dev_mul_thresh", (PyCFunction)__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_9set_std_dev_mul_thresh, METH_O, __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_8set_std_dev_mul_thresh},
+  {"set_negative", (PyCFunction)__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_11set_negative, METH_O, __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_10set_negative},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_13filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_12filter},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI[] = {
+  {(char *)"mean_k", __pyx_getprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_mean_k, __pyx_setprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_mean_k, (char *)0, 0},
+  {(char *)"negative", __pyx_getprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_negative, __pyx_setprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_negative, (char *)0, 0},
+  {(char *)"stddev_mul_thresh", __pyx_getprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_stddev_mul_thresh, __pyx_setprop_3pcl_4_pcl_41StatisticalOutlierRemovalFilter_PointXYZI_stddev_mul_thresh, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Filter class uses point neighborhood statistics to filter outlier data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_mean_k(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_mean_k(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6mean_k_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_negative(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_negative(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8negative_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_stddev_mul_thresh(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_stddev_mul_thresh(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_17stddev_mul_thresh_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_4set_InputCloud},
+  {"set_mean_k", (PyCFunction)__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_7set_mean_k, METH_O, __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_6set_mean_k},
+  {"set_std_dev_mul_thresh", (PyCFunction)__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_9set_std_dev_mul_thresh, METH_O, __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_8set_std_dev_mul_thresh},
+  {"set_negative", (PyCFunction)__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_11set_negative, METH_O, __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_10set_negative},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_13filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_12filter},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB[] = {
+  {(char *)"mean_k", __pyx_getprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_mean_k, __pyx_setprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_mean_k, (char *)0, 0},
+  {(char *)"negative", __pyx_getprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_negative, __pyx_setprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_negative, (char *)0, 0},
+  {(char *)"stddev_mul_thresh", __pyx_getprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_stddev_mul_thresh, __pyx_setprop_3pcl_4_pcl_43StatisticalOutlierRemovalFilter_PointXYZRGB_stddev_mul_thresh, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Filter class uses point neighborhood statistics to filter outlier data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_mean_k(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_mean_k(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6mean_k_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_negative(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_negative(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8negative_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyObject *__pyx_getprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_stddev_mul_thresh(PyObject *o, CYTHON_UNUSED void *x) {
+  return __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_1__get__(o);
+}
+
+static int __pyx_setprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_stddev_mul_thresh(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) {
+  if (v) {
+    return __pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_17stddev_mul_thresh_3__set__(o, v);
+  }
+  else {
+    PyErr_SetString(PyExc_NotImplementedError, "__del__");
+    return -1;
+  }
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_4set_InputCloud},
+  {"set_mean_k", (PyCFunction)__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_7set_mean_k, METH_O, __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_6set_mean_k},
+  {"set_std_dev_mul_thresh", (PyCFunction)__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_9set_std_dev_mul_thresh, METH_O, __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_8set_std_dev_mul_thresh},
+  {"set_negative", (PyCFunction)__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_11set_negative, METH_O, __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_10set_negative},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_13filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_12filter},
+  {0, 0, 0, 0}
+};
+
+static struct PyGetSetDef __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA[] = {
+  {(char *)"mean_k", __pyx_getprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_mean_k, __pyx_setprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_mean_k, (char *)0, 0},
+  {(char *)"negative", __pyx_getprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_negative, __pyx_setprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_negative, (char *)0, 0},
+  {(char *)"stddev_mul_thresh", __pyx_getprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_stddev_mul_thresh, __pyx_setprop_3pcl_4_pcl_44StatisticalOutlierRemovalFilter_PointXYZRGBA_stddev_mul_thresh, (char *)0, 0},
+  {0, 0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.StatisticalOutlierRemovalFilter_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Filter class uses point neighborhood statistics to filter outlier data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  __pyx_getsets_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_15VoxelGridFilter_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_15VoxelGridFilter_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_VoxelGridFilter[] = {
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_15VoxelGridFilter_5set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_15VoxelGridFilter_4set_leaf_size},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_15VoxelGridFilter_7filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_15VoxelGridFilter_6filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_VoxelGridFilter = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.VoxelGridFilter", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_VoxelGridFilter, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_VoxelGridFilter, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZI(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_VoxelGridFilter_PointXYZI[] = {
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_5set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_4set_leaf_size},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_7filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_25VoxelGridFilter_PointXYZI_6filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.VoxelGridFilter_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_VoxelGridFilter_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB[] = {
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_5set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_4set_leaf_size},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_7filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_27VoxelGridFilter_PointXYZRGB_6filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.VoxelGridFilter_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA[] = {
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_5set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_4set_leaf_size},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_7filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28VoxelGridFilter_PointXYZRGBA_6filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.VoxelGridFilter_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_17PassThroughFilter_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_17PassThroughFilter_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PassThroughFilter[] = {
+  {"set_filter_field_name", (PyCFunction)__pyx_pw_3pcl_4_pcl_17PassThroughFilter_5set_filter_field_name, METH_O, __pyx_doc_3pcl_4_pcl_17PassThroughFilter_4set_filter_field_name},
+  {"set_filter_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_17PassThroughFilter_7set_filter_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_17PassThroughFilter_6set_filter_limits},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_17PassThroughFilter_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_17PassThroughFilter_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PassThroughFilter = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PassThroughFilter", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Passes points in a cloud based on constraints for one particular field of the point type\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PassThroughFilter, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PassThroughFilter, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZI(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PassThroughFilter_PointXYZI[] = {
+  {"set_filter_field_name", (PyCFunction)__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_5set_filter_field_name, METH_O, __pyx_doc_3pcl_4_pcl_27PassThroughFilter_PointXYZI_4set_filter_field_name},
+  {"set_filter_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_7set_filter_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_27PassThroughFilter_PointXYZI_6set_filter_limits},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_27PassThroughFilter_PointXYZI_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_27PassThroughFilter_PointXYZI_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PassThroughFilter_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Passes points in a cloud based on constraints for one particular field of the point type\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PassThroughFilter_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PassThroughFilter_PointXYZRGB[] = {
+  {"set_filter_field_name", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_5set_filter_field_name, METH_O, __pyx_doc_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_4set_filter_field_name},
+  {"set_filter_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_7set_filter_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_6set_filter_limits},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29PassThroughFilter_PointXYZRGB_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PassThroughFilter_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Passes points in a cloud based on constraints for one particular field of the point type\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PassThroughFilter_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA[] = {
+  {"set_filter_field_name", (PyCFunction)__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_5set_filter_field_name, METH_O, __pyx_doc_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_4set_filter_field_name},
+  {"set_filter_limits", (PyCFunction)__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_7set_filter_limits, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_6set_filter_limits},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30PassThroughFilter_PointXYZRGBA_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.PassThroughFilter_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Passes points in a cloud based on constraints for one particular field of the point type\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_20ApproximateVoxelGrid_4set_InputCloud},
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_7set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_20ApproximateVoxelGrid_6set_leaf_size},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_20ApproximateVoxelGrid_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20ApproximateVoxelGrid_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ApproximateVoxelGrid", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI[] = {
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_5set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_4set_leaf_size},
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_7set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_6set_InputCloud},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30ApproximateVoxelGrid_PointXYZI_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ApproximateVoxelGrid_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_4set_InputCloud},
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_7set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_6set_leaf_size},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_32ApproximateVoxelGrid_PointXYZRGB_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ApproximateVoxelGrid_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_4set_InputCloud},
+  {"set_leaf_size", (PyCFunction)__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_7set_leaf_size, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_6set_leaf_size},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_9filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_33ApproximateVoxelGrid_PointXYZRGBA_8filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ApproximateVoxelGrid_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MovingLeastSquares(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_MovingLeastSquares(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_18MovingLeastSquares_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_MovingLeastSquares[] = {
+  {"set_search_radius", (PyCFunction)__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_5set_search_radius, METH_O, __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_4set_search_radius},
+  {"set_polynomial_order", (PyCFunction)__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_7set_polynomial_order, METH_O, __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_6set_polynomial_order},
+  {"set_polynomial_fit", (PyCFunction)__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_9set_polynomial_fit, METH_O, __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_8set_polynomial_fit},
+  {"set_Compute_Normals", (PyCFunction)__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_11set_Compute_Normals, METH_O, __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_10set_Compute_Normals},
+  {"set_Search_Method", (PyCFunction)__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_13set_Search_Method, METH_O, __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_12set_Search_Method},
+  {"process", (PyCFunction)__pyx_pw_3pcl_4_pcl_18MovingLeastSquares_15process, METH_NOARGS, __pyx_doc_3pcl_4_pcl_18MovingLeastSquares_14process},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_MovingLeastSquares = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.MovingLeastSquares", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_MovingLeastSquares, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Smoothing class which is an implementation of the MLS (Moving Least Squares)\n    algorithm for data smoothing and improved normal estimation.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_MovingLeastSquares, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_MovingLeastSquares, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB[] = {
+  {"set_search_radius", (PyCFunction)__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_5set_search_radius, METH_O, __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_4set_search_radius},
+  {"set_polynomial_order", (PyCFunction)__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_7set_polynomial_order, METH_O, __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_6set_polynomial_order},
+  {"set_polynomial_fit", (PyCFunction)__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_9set_polynomial_fit, METH_O, __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_8set_polynomial_fit},
+  {"process", (PyCFunction)__pyx_pw_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_11process, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30MovingLeastSquares_PointXYZRGB_10process},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.MovingLeastSquares_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Smoothing class which is an implementation of the MLS (Moving Least Squares)\n    algorithm for data smoothing and improved normal estimation.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA[] = {
+  {"set_search_radius", (PyCFunction)__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_5set_search_radius, METH_O, __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_4set_search_radius},
+  {"set_polynomial_order", (PyCFunction)__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_7set_polynomial_order, METH_O, __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_6set_polynomial_order},
+  {"set_polynomial_fit", (PyCFunction)__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_9set_polynomial_fit, METH_O, __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_8set_polynomial_fit},
+  {"process", (PyCFunction)__pyx_pw_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_11process, METH_NOARGS, __pyx_doc_3pcl_4_pcl_31MovingLeastSquares_PointXYZRGBA_10process},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.MovingLeastSquares_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Smoothing class which is an implementation of the MLS (Moving Least Squares)\n    algorithm for data smoothing and improved normal estimation.\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN __pyx_vtable_3pcl_4_pcl_KdTreeFLANN;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_11KdTreeFLANN_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_KdTreeFLANN[] = {
+  {"nearest_k_search_for_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_5nearest_k_search_for_cloud, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_11KdTreeFLANN_4nearest_k_search_for_cloud},
+  {"nearest_k_search_for_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_7nearest_k_search_for_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_11KdTreeFLANN_6nearest_k_search_for_point},
+  {"radius_search_for_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_11KdTreeFLANN_9radius_search_for_cloud, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_11KdTreeFLANN_8radius_search_for_cloud},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_KdTreeFLANN = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.KdTreeFLANN", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Finds k nearest neighbours from points in another pointcloud to points in\n    a reference pointcloud.\n\n    Must be constructed from the reference point cloud, which is copied, so\n    changed to pc are not reflected in KdTreeFLANN(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_KdTreeFLANN, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_KdTreeFLANN, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZI __pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZI;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZI;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_KdTreeFLANN_PointXYZI[] = {
+  {"nearest_k_search_for_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_5nearest_k_search_for_cloud, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_4nearest_k_search_for_cloud},
+  {"nearest_k_search_for_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_7nearest_k_search_for_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_21KdTreeFLANN_PointXYZI_6nearest_k_search_for_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.KdTreeFLANN_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Finds k nearest neighbours from points in another pointcloud to points in\n    a reference pointcloud.\n\n    Must be constructed from the reference point cloud, which is copied, so\n    changed to pc are not reflected in KdTreeFLANN(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_KdTreeFLANN_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB __pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB[] = {
+  {"nearest_k_search_for_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_5nearest_k_search_for_cloud, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_4nearest_k_search_for_cloud},
+  {"nearest_k_search_for_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_7nearest_k_search_for_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB_6nearest_k_search_for_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.KdTreeFLANN_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Finds k nearest neighbours from points in another pointcloud to points in\n    a reference pointcloud.\n\n    Must be constructed from the reference point cloud, which is copied, so\n    changed to pc are not reflected in KdTreeFLANN(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA __pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA[] = {
+  {"nearest_k_search_for_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_5nearest_k_search_for_cloud, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_4nearest_k_search_for_cloud},
+  {"nearest_k_search_for_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_7nearest_k_search_for_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA_6nearest_k_search_for_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.KdTreeFLANN_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Finds k nearest neighbours from points in another pointcloud to points in\n    a reference pointcloud.\n\n    Must be constructed from the reference point cloud, which is copied, so\n    changed to pc are not reflected in KdTreeFLANN(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_16OctreePointCloud_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_16OctreePointCloud_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_16OctreePointCloud_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_16OctreePointCloud_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZI(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud_PointXYZI[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_26OctreePointCloud_PointXYZI_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_26OctreePointCloud_PointXYZI_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_26OctreePointCloud_PointXYZI_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_26OctreePointCloud_PointXYZI_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud_PointXYZRGB[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28OctreePointCloud_PointXYZRGB_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_29OctreePointCloud_PointXYZRGBA_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_20OctreePointCloud2Buf_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_20OctreePointCloud2Buf_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_20OctreePointCloud2Buf_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20OctreePointCloud2Buf_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud2Buf", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30OctreePointCloud2Buf_PointXYZI_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud2Buf_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_32OctreePointCloud2Buf_PointXYZRGB_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud2Buf_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  return o;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA[] = {
+  {"set_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_1set_input_cloud, METH_O, __pyx_doc_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_set_input_cloud},
+  {"delete_tree", (PyCFunction)__pyx_pw_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_3delete_tree, METH_NOARGS, __pyx_doc_3pcl_4_pcl_33OctreePointCloud2Buf_PointXYZRGBA_2delete_tree},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloud2Buf_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_OctreePointCloudSearch __pyx_vtable_3pcl_4_pcl_OctreePointCloudSearch;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch(PyTypeObject *t, PyObject *a, PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *p;
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud(t, a, k);
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_OctreePointCloudSearch;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch[] = {
+  {"nearest_k_search_for_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_5nearest_k_search_for_cloud, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_4nearest_k_search_for_cloud},
+  {"nearest_k_search_for_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_7nearest_k_search_for_point, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_6nearest_k_search_for_point},
+  {"radius_search", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_9radius_search, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_8radius_search},
+  {"VoxelSearch", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_11VoxelSearch, METH_O, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_10VoxelSearch},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_13define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_12define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_15add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_14add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_17is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_16is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_19get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_18get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_22OctreePointCloudSearch_21delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_22OctreePointCloudSearch_20delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudSearch = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudSearch", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud search\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZI(t, a, k);
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZI(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI[] = {
+  {"radius_search", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_5radius_search, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_4radius_search},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_7define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_6define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_9add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_8add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_11is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_10is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_13get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_12get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_15delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_32OctreePointCloudSearch_PointXYZI_14delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudSearch_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud search\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGB(t, a, k);
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZRGB(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB[] = {
+  {"radius_search", (PyCFunction)__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_5radius_search, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_4radius_search},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_7define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_6define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_9add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_8add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_11is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_10is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_13get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_12get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_15delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_34OctreePointCloudSearch_PointXYZRGB_14delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudSearch_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud search\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA(t, a, k);
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA[] = {
+  {"radius_search", (PyCFunction)__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_5radius_search, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_4radius_search},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_7define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_6define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_9add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_8add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_11is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_10is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_13get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_12get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_15delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_35OctreePointCloudSearch_PointXYZRGBA_14delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudSearch_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud search\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf(t, a, k);
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector[] = {
+  {"get_PointIndicesFromNewVoxels", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_3get_PointIndicesFromNewVoxels, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_2get_PointIndicesFromNewVoxels},
+  {"switchBuffers", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_5switchBuffers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_4switchBuffers},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_7define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_6define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_9add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_8add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_11is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_10is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_13get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_12get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_30OctreePointCloudChangeDetector_15delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_30OctreePointCloudChangeDetector_14delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudChangeDetector", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud ChangeDetector\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI(t, a, k);
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI[] = {
+  {"get_PointIndicesFromNewVoxels", (PyCFunction)__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_3get_PointIndicesFromNewVoxels, METH_NOARGS, __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_2get_PointIndicesFromNewVoxels},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_5define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_4define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_7add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_6add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_9is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_8is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_11get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_10get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_13delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_40OctreePointCloudChangeDetector_PointXYZI_12delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudChangeDetector_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud ChangeDetector\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB(t, a, k);
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB[] = {
+  {"get_PointIndicesFromNewVoxels", (PyCFunction)__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_3get_PointIndicesFromNewVoxels, METH_NOARGS, __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_2get_PointIndicesFromNewVoxels},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_5define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_4define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_7add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_6add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_9is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_8is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_11get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_10get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_13delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_42OctreePointCloudChangeDetector_PointXYZRGB_12delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud ChangeDetector\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o = __pyx_tp_new_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA(t, a, k);
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA[] = {
+  {"get_PointIndicesFromNewVoxels", (PyCFunction)__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_3get_PointIndicesFromNewVoxels, METH_NOARGS, __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_2get_PointIndicesFromNewVoxels},
+  {"define_bounding_box", (PyCFunction)__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_5define_bounding_box, METH_NOARGS, __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_4define_bounding_box},
+  {"add_points_from_input_cloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_7add_points_from_input_cloud, METH_NOARGS, __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_6add_points_from_input_cloud},
+  {"is_voxel_occupied_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_9is_voxel_occupied_at_point, METH_O, __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_8is_voxel_occupied_at_point},
+  {"get_occupied_voxel_centers", (PyCFunction)__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_11get_occupied_voxel_centers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_10get_occupied_voxel_centers},
+  {"delete_voxel_at_point", (PyCFunction)__pyx_pw_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_13delete_voxel_at_point, METH_O, __pyx_doc_3pcl_4_pcl_43OctreePointCloudChangeDetector_PointXYZRGBA_12delete_voxel_at_point},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.OctreePointCloudChangeDetector_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Octree pointcloud ChangeDetector\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_CropHull(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_8CropHull_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_CropHull(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_8CropHull_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_CropHull[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_8CropHull_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_8CropHull_4set_InputCloud},
+  {"SetParameter", (PyCFunction)__pyx_pw_3pcl_4_pcl_8CropHull_7SetParameter, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_8CropHull_6SetParameter},
+  {"Filtering", (PyCFunction)__pyx_pw_3pcl_4_pcl_8CropHull_9Filtering, METH_O, __pyx_doc_3pcl_4_pcl_8CropHull_8Filtering},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_8CropHull_11filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_8CropHull_10filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_CropHull = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.CropHull", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_CropHull), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_CropHull, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Must be constructed from the reference point cloud, which is copied, \n    so changed to pc are not reflected in CropHull(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_CropHull, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_CropHull, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_CropBox(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_7CropBox_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_CropBox(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_7CropBox_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_CropBox[] = {
+  {"set_InputCloud", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_5set_InputCloud, METH_O, __pyx_doc_3pcl_4_pcl_7CropBox_4set_InputCloud},
+  {"set_Translation", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_7set_Translation, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_7CropBox_6set_Translation},
+  {"set_Rotation", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_9set_Rotation, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_7CropBox_8set_Rotation},
+  {"set_Min", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_11set_Min, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_7CropBox_10set_Min},
+  {"set_Max", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_13set_Max, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_7CropBox_12set_Max},
+  {"set_MinMax", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_15set_MinMax, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_7CropBox_14set_MinMax},
+  {"set_Negative", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_17set_Negative, METH_O, __pyx_doc_3pcl_4_pcl_7CropBox_16set_Negative},
+  {"get_Negative", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_19get_Negative, METH_NOARGS, __pyx_doc_3pcl_4_pcl_7CropBox_18get_Negative},
+  {"get_RemovedIndices", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_21get_RemovedIndices, METH_NOARGS, __pyx_doc_3pcl_4_pcl_7CropBox_20get_RemovedIndices},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_7CropBox_23filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_7CropBox_22filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_CropBox = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.CropBox", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_CropBox), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_CropBox, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Must be constructed from the reference point cloud, which is copied, so\n    changed to pc are not reflected in CropBox(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_CropBox, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_CropBox, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ProjectInliers(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_14ProjectInliers_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ProjectInliers(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_14ProjectInliers_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ProjectInliers[] = {
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_14ProjectInliers_5filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_14ProjectInliers_4filter},
+  {"set_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_14ProjectInliers_7set_model_type, METH_O, __pyx_doc_3pcl_4_pcl_14ProjectInliers_6set_model_type},
+  {"get_model_type", (PyCFunction)__pyx_pw_3pcl_4_pcl_14ProjectInliers_9get_model_type, METH_NOARGS, __pyx_doc_3pcl_4_pcl_14ProjectInliers_8get_model_type},
+  {"set_copy_all_data", (PyCFunction)__pyx_pw_3pcl_4_pcl_14ProjectInliers_11set_copy_all_data, METH_O, __pyx_doc_3pcl_4_pcl_14ProjectInliers_10set_copy_all_data},
+  {"get_copy_all_data", (PyCFunction)__pyx_pw_3pcl_4_pcl_14ProjectInliers_13get_copy_all_data, METH_NOARGS, __pyx_doc_3pcl_4_pcl_14ProjectInliers_12get_copy_all_data},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ProjectInliers = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ProjectInliers", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ProjectInliers), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ProjectInliers, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ProjectInliers class for ...\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ProjectInliers, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ProjectInliers, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_RadiusOutlierRemoval(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_RadiusOutlierRemoval(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_RadiusOutlierRemoval[] = {
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_5filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_4filter},
+  {"set_radius_search", (PyCFunction)__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_7set_radius_search, METH_O, __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_6set_radius_search},
+  {"get_radius_search", (PyCFunction)__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_9get_radius_search, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_8get_radius_search},
+  {"set_MinNeighborsInRadius", (PyCFunction)__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_11set_MinNeighborsInRadius, METH_O, __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_10set_MinNeighborsInRadius},
+  {"get_MinNeighborsInRadius", (PyCFunction)__pyx_pw_3pcl_4_pcl_20RadiusOutlierRemoval_13get_MinNeighborsInRadius, METH_NOARGS, __pyx_doc_3pcl_4_pcl_20RadiusOutlierRemoval_12get_MinNeighborsInRadius},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_RadiusOutlierRemoval = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.RadiusOutlierRemoval", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_RadiusOutlierRemoval), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_RadiusOutlierRemoval, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    RadiusOutlierRemoval class for ...\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_RadiusOutlierRemoval, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_RadiusOutlierRemoval, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConditionAnd(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_12ConditionAnd_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ConditionAnd(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_12ConditionAnd_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ConditionAnd[] = {
+  {"add_Comparison2", (PyCFunction)__pyx_pw_3pcl_4_pcl_12ConditionAnd_5add_Comparison2, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_12ConditionAnd_4add_Comparison2},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ConditionAnd = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ConditionAnd", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ConditionAnd), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ConditionAnd, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Must be constructed from the reference point cloud, which is copied, so\n    changed to pc are not reflected in ConditionAnd(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ConditionAnd, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ConditionAnd, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConditionalRemoval(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_18ConditionalRemoval_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ConditionalRemoval(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ConditionalRemoval[] = {
+  {"set_KeepOrganized", (PyCFunction)__pyx_pw_3pcl_4_pcl_18ConditionalRemoval_3set_KeepOrganized, METH_O, __pyx_doc_3pcl_4_pcl_18ConditionalRemoval_2set_KeepOrganized},
+  {"filter", (PyCFunction)__pyx_pw_3pcl_4_pcl_18ConditionalRemoval_5filter, METH_NOARGS, __pyx_doc_3pcl_4_pcl_18ConditionalRemoval_4filter},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ConditionalRemoval = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ConditionalRemoval", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ConditionalRemoval), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ConditionalRemoval, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Must be constructed from the reference point cloud, which is copied, so\n    changed to pc are not reflected in ConditionalRemoval(pc).\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ConditionalRemoval, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ConditionalRemoval, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_11ConcaveHull_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_11ConcaveHull_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ConcaveHull[] = {
+  {"reconstruct", (PyCFunction)__pyx_pw_3pcl_4_pcl_11ConcaveHull_5reconstruct, METH_NOARGS, __pyx_doc_3pcl_4_pcl_11ConcaveHull_4reconstruct},
+  {"set_Alpha", (PyCFunction)__pyx_pw_3pcl_4_pcl_11ConcaveHull_7set_Alpha, METH_O, __pyx_doc_3pcl_4_pcl_11ConcaveHull_6set_Alpha},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ConcaveHull = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ConcaveHull", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ConcaveHull), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ConcaveHull class for ...\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ConcaveHull, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ConcaveHull, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZI(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull_PointXYZI(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ConcaveHull_PointXYZI[] = {
+  {"reconstruct", (PyCFunction)__pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_5reconstruct, METH_NOARGS, __pyx_doc_3pcl_4_pcl_21ConcaveHull_PointXYZI_4reconstruct},
+  {"set_Alpha", (PyCFunction)__pyx_pw_3pcl_4_pcl_21ConcaveHull_PointXYZI_7set_Alpha, METH_O, __pyx_doc_3pcl_4_pcl_21ConcaveHull_PointXYZI_6set_Alpha},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZI = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ConcaveHull_PointXYZI", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZI), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull_PointXYZI, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ConcaveHull class for ...\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ConcaveHull_PointXYZI, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZI, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZRGB(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull_PointXYZRGB(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ConcaveHull_PointXYZRGB[] = {
+  {"reconstruct", (PyCFunction)__pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_5reconstruct, METH_NOARGS, __pyx_doc_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_4reconstruct},
+  {"set_Alpha", (PyCFunction)__pyx_pw_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_7set_Alpha, METH_O, __pyx_doc_3pcl_4_pcl_23ConcaveHull_PointXYZRGB_6set_Alpha},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGB = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ConcaveHull_PointXYZRGB", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGB), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull_PointXYZRGB, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ConcaveHull class for ...\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ConcaveHull_PointXYZRGB, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZRGB, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZRGBA(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull_PointXYZRGBA(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_ConcaveHull_PointXYZRGBA[] = {
+  {"reconstruct", (PyCFunction)__pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_5reconstruct, METH_NOARGS, __pyx_doc_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_4reconstruct},
+  {"set_Alpha", (PyCFunction)__pyx_pw_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_7set_Alpha, METH_O, __pyx_doc_3pcl_4_pcl_24ConcaveHull_PointXYZRGBA_6set_Alpha},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGBA = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.ConcaveHull_PointXYZRGBA", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_ConcaveHull_PointXYZRGBA), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_ConcaveHull_PointXYZRGBA, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ConcaveHull class for ...\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_ConcaveHull_PointXYZRGBA, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_ConcaveHull_PointXYZRGBA, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_GeneralizedIterativeClosestPoint __pyx_vtable_3pcl_4_pcl_GeneralizedIterativeClosestPoint;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_GeneralizedIterativeClosestPoint(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_GeneralizedIterativeClosestPoint;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_GeneralizedIterativeClosestPoint(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_GeneralizedIterativeClosestPoint[] = {
+  {"gicp", (PyCFunction)__pyx_pw_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_5gicp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_4gicp},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_GeneralizedIterativeClosestPoint = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.GeneralizedIterativeClosestPoint", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_GeneralizedIterativeClosestPoint, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Registration class for GeneralizedIterativeClosestPoint\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_GeneralizedIterativeClosestPoint, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_GeneralizedIterativeClosestPoint, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPoint __pyx_vtable_3pcl_4_pcl_IterativeClosestPoint;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_IterativeClosestPoint(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_IterativeClosestPoint;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_IterativeClosestPoint(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_IterativeClosestPoint[] = {
+  {"set_InputTarget", (PyCFunction)__pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_5set_InputTarget, METH_O, __pyx_doc_3pcl_4_pcl_21IterativeClosestPoint_4set_InputTarget},
+  {"icp", (PyCFunction)__pyx_pw_3pcl_4_pcl_21IterativeClosestPoint_7icp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_21IterativeClosestPoint_6icp},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_IterativeClosestPoint = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.IterativeClosestPoint", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_IterativeClosestPoint, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Registration class for IterativeClosestPoint\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_IterativeClosestPoint, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_IterativeClosestPoint, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+static struct __pyx_vtabstruct_3pcl_4_pcl_IterativeClosestPointNonLinear __pyx_vtable_3pcl_4_pcl_IterativeClosestPointNonLinear;
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_IterativeClosestPointNonLinear(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *p;
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  p = ((struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *)o);
+  p->__pyx_vtab = __pyx_vtabptr_3pcl_4_pcl_IterativeClosestPointNonLinear;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_IterativeClosestPointNonLinear(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_IterativeClosestPointNonLinear[] = {
+  {"icp_nl", (PyCFunction)__pyx_pw_3pcl_4_pcl_30IterativeClosestPointNonLinear_5icp_nl, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3pcl_4_pcl_30IterativeClosestPointNonLinear_4icp_nl},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_IterativeClosestPointNonLinear = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.IterativeClosestPointNonLinear", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_IterativeClosestPointNonLinear, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Registration class for IterativeClosestPointNonLinear\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_IterativeClosestPointNonLinear, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_IterativeClosestPointNonLinear, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_RandomSampleConsensus(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_5__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_RandomSampleConsensus(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_7__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_RandomSampleConsensus[] = {
+  {"computeModel", (PyCFunction)__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_9computeModel, METH_NOARGS, __pyx_doc_3pcl_4_pcl_21RandomSampleConsensus_8computeModel},
+  {"set_DistanceThreshold", (PyCFunction)__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_11set_DistanceThreshold, METH_O, __pyx_doc_3pcl_4_pcl_21RandomSampleConsensus_10set_DistanceThreshold},
+  {"get_Inliers", (PyCFunction)__pyx_pw_3pcl_4_pcl_21RandomSampleConsensus_13get_Inliers, METH_NOARGS, __pyx_doc_3pcl_4_pcl_21RandomSampleConsensus_12get_Inliers},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_RandomSampleConsensus = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.RandomSampleConsensus", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_RandomSampleConsensus), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_RandomSampleConsensus, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_RandomSampleConsensus, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_RandomSampleConsensus, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_NormalEstimation(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_16NormalEstimation_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_NormalEstimation(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_16NormalEstimation_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_NormalEstimation[] = {
+  {"set_SearchMethod", (PyCFunction)__pyx_pw_3pcl_4_pcl_16NormalEstimation_5set_SearchMethod, METH_O, __pyx_doc_3pcl_4_pcl_16NormalEstimation_4set_SearchMethod},
+  {"set_RadiusSearch", (PyCFunction)__pyx_pw_3pcl_4_pcl_16NormalEstimation_7set_RadiusSearch, METH_O, __pyx_doc_3pcl_4_pcl_16NormalEstimation_6set_RadiusSearch},
+  {"set_KSearch", (PyCFunction)__pyx_pw_3pcl_4_pcl_16NormalEstimation_9set_KSearch, METH_O, __pyx_doc_3pcl_4_pcl_16NormalEstimation_8set_KSearch},
+  {"compute", (PyCFunction)__pyx_pw_3pcl_4_pcl_16NormalEstimation_11compute, METH_NOARGS, __pyx_doc_3pcl_4_pcl_16NormalEstimation_10compute},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_NormalEstimation = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.NormalEstimation", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_NormalEstimation), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_NormalEstimation, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    NormalEstimation class for \n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_NormalEstimation, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_NormalEstimation, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_VFHEstimation(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_13VFHEstimation_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_VFHEstimation(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_13VFHEstimation_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_VFHEstimation[] = {
+  {"set_SearchMethod", (PyCFunction)__pyx_pw_3pcl_4_pcl_13VFHEstimation_5set_SearchMethod, METH_O, __pyx_doc_3pcl_4_pcl_13VFHEstimation_4set_SearchMethod},
+  {"set_KSearch", (PyCFunction)__pyx_pw_3pcl_4_pcl_13VFHEstimation_7set_KSearch, METH_O, __pyx_doc_3pcl_4_pcl_13VFHEstimation_6set_KSearch},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_VFHEstimation = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.VFHEstimation", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_VFHEstimation), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_VFHEstimation, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    VFHEstimation class for \n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_VFHEstimation, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_VFHEstimation, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_MomentOfInertiaEstimation(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_MomentOfInertiaEstimation(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_MomentOfInertiaEstimation[] = {
+  {"get_MomentOfInertia", (PyCFunction)__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_5get_MomentOfInertia, METH_NOARGS, __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_4get_MomentOfInertia},
+  {"get_Eccentricity", (PyCFunction)__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_7get_Eccentricity, METH_NOARGS, __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_6get_Eccentricity},
+  {"get_AABB", (PyCFunction)__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_9get_AABB, METH_NOARGS, __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_8get_AABB},
+  {"get_EigenValues", (PyCFunction)__pyx_pw_3pcl_4_pcl_25MomentOfInertiaEstimation_11get_EigenValues, METH_NOARGS, __pyx_doc_3pcl_4_pcl_25MomentOfInertiaEstimation_10get_EigenValues},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_MomentOfInertiaEstimation = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.MomentOfInertiaEstimation", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_MomentOfInertiaEstimation), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_MomentOfInertiaEstimation, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    MomentOfInertiaEstimation class for \n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_MomentOfInertiaEstimation, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_MomentOfInertiaEstimation, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_HarrisKeypoint3D(PyTypeObject *t, PyObject *a, PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_1__cinit__(o, a, k) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_HarrisKeypoint3D(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_HarrisKeypoint3D[] = {
+  {"set_NonMaxSupression", (PyCFunction)__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_5set_NonMaxSupression, METH_O, __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_4set_NonMaxSupression},
+  {"set_Radius", (PyCFunction)__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_7set_Radius, METH_O, __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_6set_Radius},
+  {"set_RadiusSearch", (PyCFunction)__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_9set_RadiusSearch, METH_O, __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_8set_RadiusSearch},
+  {"compute", (PyCFunction)__pyx_pw_3pcl_4_pcl_16HarrisKeypoint3D_11compute, METH_NOARGS, __pyx_doc_3pcl_4_pcl_16HarrisKeypoint3D_10compute},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_HarrisKeypoint3D = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.HarrisKeypoint3D", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_HarrisKeypoint3D), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_HarrisKeypoint3D, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    HarrisKeypoint3D class for \n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_HarrisKeypoint3D, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_HarrisKeypoint3D, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyObject *__pyx_tp_new_3pcl_4_pcl_NormalDistributionsTransform(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) {
+  PyObject *o;
+  if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) {
+    o = (*t->tp_alloc)(t, 0);
+  } else {
+    o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0);
+  }
+  if (unlikely(!o)) return 0;
+  if (unlikely(__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad;
+  return o;
+  bad:
+  Py_DECREF(o); o = 0;
+  return NULL;
+}
+
+static void __pyx_tp_dealloc_3pcl_4_pcl_NormalDistributionsTransform(PyObject *o) {
+  #if PY_VERSION_HEX >= 0x030400a1
+  if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) {
+    if (PyObject_CallFinalizerFromDealloc(o)) return;
+  }
+  #endif
+  {
+    PyObject *etype, *eval, *etb;
+    PyErr_Fetch(&etype, &eval, &etb);
+    ++Py_REFCNT(o);
+    __pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_3__dealloc__(o);
+    --Py_REFCNT(o);
+    PyErr_Restore(etype, eval, etb);
+  }
+  (*Py_TYPE(o)->tp_free)(o);
+}
+
+static PyMethodDef __pyx_methods_3pcl_4_pcl_NormalDistributionsTransform[] = {
+  {"set_InputTarget", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_5set_InputTarget, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_4set_InputTarget},
+  {"set_Resolution", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_7set_Resolution, METH_O, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_6set_Resolution},
+  {"get_Resolution", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_9get_Resolution, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_8get_Resolution},
+  {"get_StepSize", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_11get_StepSize, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_10get_StepSize},
+  {"set_StepSize", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_13set_StepSize, METH_O, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_12set_StepSize},
+  {"get_OulierRatio", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_15get_OulierRatio, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_14get_OulierRatio},
+  {"set_OulierRatio", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_17set_OulierRatio, METH_O, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_16set_OulierRatio},
+  {"get_TransformationProbability", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_19get_TransformationProbability, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_18get_TransformationProbability},
+  {"get_FinalNumIteration", (PyCFunction)__pyx_pw_3pcl_4_pcl_28NormalDistributionsTransform_21get_FinalNumIteration, METH_NOARGS, __pyx_doc_3pcl_4_pcl_28NormalDistributionsTransform_20get_FinalNumIteration},
+  {0, 0, 0, 0}
+};
+
+static PyTypeObject __pyx_type_3pcl_4_pcl_NormalDistributionsTransform = {
+  PyVarObject_HEAD_INIT(0, 0)
+  "pcl._pcl.NormalDistributionsTransform", /*tp_name*/
+  sizeof(struct __pyx_obj_3pcl_4_pcl_NormalDistributionsTransform), /*tp_basicsize*/
+  0, /*tp_itemsize*/
+  __pyx_tp_dealloc_3pcl_4_pcl_NormalDistributionsTransform, /*tp_dealloc*/
+  0, /*tp_print*/
+  0, /*tp_getattr*/
+  0, /*tp_setattr*/
+  #if PY_MAJOR_VERSION < 3
+  0, /*tp_compare*/
+  #endif
+  #if PY_MAJOR_VERSION >= 3
+  0, /*tp_as_async*/
+  #endif
+  0, /*tp_repr*/
+  0, /*tp_as_number*/
+  0, /*tp_as_sequence*/
+  0, /*tp_as_mapping*/
+  0, /*tp_hash*/
+  0, /*tp_call*/
+  0, /*tp_str*/
+  0, /*tp_getattro*/
+  0, /*tp_setattro*/
+  0, /*tp_as_buffer*/
+  Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/
+  "\n    Registration class for NormalDistributionsTransform\n    ", /*tp_doc*/
+  0, /*tp_traverse*/
+  0, /*tp_clear*/
+  0, /*tp_richcompare*/
+  0, /*tp_weaklistoffset*/
+  0, /*tp_iter*/
+  0, /*tp_iternext*/
+  __pyx_methods_3pcl_4_pcl_NormalDistributionsTransform, /*tp_methods*/
+  0, /*tp_members*/
+  0, /*tp_getset*/
+  0, /*tp_base*/
+  0, /*tp_dict*/
+  0, /*tp_descr_get*/
+  0, /*tp_descr_set*/
+  0, /*tp_dictoffset*/
+  0, /*tp_init*/
+  0, /*tp_alloc*/
+  __pyx_tp_new_3pcl_4_pcl_NormalDistributionsTransform, /*tp_new*/
+  0, /*tp_free*/
+  0, /*tp_is_gc*/
+  0, /*tp_bases*/
+  0, /*tp_mro*/
+  0, /*tp_cache*/
+  0, /*tp_subclasses*/
+  0, /*tp_weaklist*/
+  0, /*tp_del*/
+  0, /*tp_version_tag*/
+  #if PY_VERSION_HEX >= 0x030400a1
+  0, /*tp_finalize*/
+  #endif
+};
+
+static PyMethodDef __pyx_methods[] = {
+  {0, 0, 0, 0}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef __pyx_moduledef = {
+  #if PY_VERSION_HEX < 0x03020000
+    { PyObject_HEAD_INIT(NULL) NULL, 0, NULL },
+  #else
+    PyModuleDef_HEAD_INIT,
+  #endif
+    "_pcl",
+    0, /* m_doc */
+    -1, /* m_size */
+    __pyx_methods /* m_methods */,
+    NULL, /* m_reload */
+    NULL, /* m_traverse */
+    NULL, /* m_clear */
+    NULL /* m_free */
+};
+#endif
+
+static __Pyx_StringTabEntry __pyx_string_tab[] = {
+  {&__pyx_kp_s_3, __pyx_k_3, sizeof(__pyx_k_3), 0, 0, 1, 0},
+  {&__pyx_kp_s_3a, __pyx_k_3a, sizeof(__pyx_k_3a), 0, 0, 1, 0},
+  {&__pyx_kp_s_3b, __pyx_k_3b, sizeof(__pyx_k_3b), 0, 0, 1, 0},
+  {&__pyx_kp_s_4, __pyx_k_4, sizeof(__pyx_k_4), 0, 0, 1, 0},
+  {&__pyx_kp_s_Can_t_initialize_a_PointCloud_fr, __pyx_k_Can_t_initialize_a_PointCloud_fr, sizeof(__pyx_k_Can_t_initialize_a_PointCloud_fr), 0, 0, 1, 0},
+  {&__pyx_n_s_Compute, __pyx_k_Compute, sizeof(__pyx_k_Compute), 0, 0, 1, 1},
+  {&__pyx_kp_s_CreateFromPointCloud_enter, __pyx_k_CreateFromPointCloud_enter, sizeof(__pyx_k_CreateFromPointCloud_enter), 0, 0, 1, 0},
+  {&__pyx_n_s_CythonCompareOp_Type, __pyx_k_CythonCompareOp_Type, sizeof(__pyx_k_CythonCompareOp_Type), 0, 0, 1, 1},
+  {&__pyx_n_s_CythonCoordinateFrame_Type, __pyx_k_CythonCoordinateFrame_Type, sizeof(__pyx_k_CythonCoordinateFrame_Type), 0, 0, 1, 1},
+  {&__pyx_kp_s_Expected_resolution_0_got_r, __pyx_k_Expected_resolution_0_got_r, sizeof(__pyx_k_Expected_resolution_0_got_r), 0, 0, 1, 0},
+  {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0},
+  {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0},
+  {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1},
+  {&__pyx_n_s_Integral, __pyx_k_Integral, sizeof(__pyx_k_Integral), 0, 0, 1, 1},
+  {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0},
+  {&__pyx_kp_s_PointCloud_of_d_points, __pyx_k_PointCloud_of_d_points, sizeof(__pyx_k_PointCloud_of_d_points), 0, 0, 1, 0},
+  {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_CIRCLE2D, __pyx_k_SACMODEL_CIRCLE2D, sizeof(__pyx_k_SACMODEL_CIRCLE2D), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_CIRCLE3D, __pyx_k_SACMODEL_CIRCLE3D, sizeof(__pyx_k_SACMODEL_CIRCLE3D), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_CONE, __pyx_k_SACMODEL_CONE, sizeof(__pyx_k_SACMODEL_CONE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_CYLINDER, __pyx_k_SACMODEL_CYLINDER, sizeof(__pyx_k_SACMODEL_CYLINDER), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_LINE, __pyx_k_SACMODEL_LINE, sizeof(__pyx_k_SACMODEL_LINE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_NORMAL_PARALLEL_PLANE, __pyx_k_SACMODEL_NORMAL_PARALLEL_PLANE, sizeof(__pyx_k_SACMODEL_NORMAL_PARALLEL_PLANE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_NORMAL_PLANE, __pyx_k_SACMODEL_NORMAL_PLANE, sizeof(__pyx_k_SACMODEL_NORMAL_PLANE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_NORMAL_SPHERE, __pyx_k_SACMODEL_NORMAL_SPHERE, sizeof(__pyx_k_SACMODEL_NORMAL_SPHERE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_PARALLEL_LINE, __pyx_k_SACMODEL_PARALLEL_LINE, sizeof(__pyx_k_SACMODEL_PARALLEL_LINE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_PARALLEL_LINES, __pyx_k_SACMODEL_PARALLEL_LINES, sizeof(__pyx_k_SACMODEL_PARALLEL_LINES), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_PARALLEL_PLANE, __pyx_k_SACMODEL_PARALLEL_PLANE, sizeof(__pyx_k_SACMODEL_PARALLEL_PLANE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_PERPENDICULAR_PLANE, __pyx_k_SACMODEL_PERPENDICULAR_PLANE, sizeof(__pyx_k_SACMODEL_PERPENDICULAR_PLANE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_PLANE, __pyx_k_SACMODEL_PLANE, sizeof(__pyx_k_SACMODEL_PLANE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_REGISTRATION, __pyx_k_SACMODEL_REGISTRATION, sizeof(__pyx_k_SACMODEL_REGISTRATION), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_SPHERE, __pyx_k_SACMODEL_SPHERE, sizeof(__pyx_k_SACMODEL_SPHERE), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_STICK, __pyx_k_SACMODEL_STICK, sizeof(__pyx_k_SACMODEL_STICK), 0, 0, 1, 1},
+  {&__pyx_n_s_SACMODEL_TORUS, __pyx_k_SACMODEL_TORUS, sizeof(__pyx_k_SACMODEL_TORUS), 0, 0, 1, 1},
+  {&__pyx_n_s_SAC_LMEDS, __pyx_k_SAC_LMEDS, sizeof(__pyx_k_SAC_LMEDS), 0, 0, 1, 1},
+  {&__pyx_n_s_SAC_MLESAC, __pyx_k_SAC_MLESAC, sizeof(__pyx_k_SAC_MLESAC), 0, 0, 1, 1},
+  {&__pyx_n_s_SAC_MSAC, __pyx_k_SAC_MSAC, sizeof(__pyx_k_SAC_MSAC), 0, 0, 1, 1},
+  {&__pyx_n_s_SAC_PROSAC, __pyx_k_SAC_PROSAC, sizeof(__pyx_k_SAC_PROSAC), 0, 0, 1, 1},
+  {&__pyx_n_s_SAC_RANSAC, __pyx_k_SAC_RANSAC, sizeof(__pyx_k_SAC_RANSAC), 0, 0, 1, 1},
+  {&__pyx_n_s_SAC_RMSAC, __pyx_k_SAC_RMSAC, sizeof(__pyx_k_SAC_RMSAC), 0, 0, 1, 1},
+  {&__pyx_n_s_SAC_RRANSAC, __pyx_k_SAC_RRANSAC, sizeof(__pyx_k_SAC_RRANSAC), 0, 0, 1, 1},
+  {&__pyx_n_s_Sequence, __pyx_k_Sequence, sizeof(__pyx_k_Sequence), 0, 0, 1, 1},
+  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
+  {&__pyx_kp_s_Users_T_O_python_pcl_pcl__pcl_1, __pyx_k_Users_T_O_python_pcl_pcl__pcl_1, sizeof(__pyx_k_Users_T_O_python_pcl_pcl__pcl_1), 0, 0, 1, 0},
+  {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1},
+  {&__pyx_kp_s_Vertices_of_d_points, __pyx_k_Vertices_of_d_points, sizeof(__pyx_k_Vertices_of_d_points), 0, 0, 1, 0},
+  {&__pyx_kp_s_VoxelSearch_at, __pyx_k_VoxelSearch_at, sizeof(__pyx_k_VoxelSearch_at), 0, 0, 1, 0},
+  {&__pyx_kp_s__8, __pyx_k__8, sizeof(__pyx_k__8), 0, 0, 1, 0},
+  {&__pyx_kp_s__9, __pyx_k__9, sizeof(__pyx_k__9), 0, 0, 1, 0},
+  {&__pyx_n_s_alpha, __pyx_k_alpha, sizeof(__pyx_k_alpha), 0, 0, 1, 1},
+  {&__pyx_n_s_angular_resolution, __pyx_k_angular_resolution, sizeof(__pyx_k_angular_resolution), 0, 0, 1, 1},
+  {&__pyx_kp_s_angular_resolution_2, __pyx_k_angular_resolution_2, sizeof(__pyx_k_angular_resolution_2), 0, 0, 1, 0},
+  {&__pyx_n_s_angular_resolution_x, __pyx_k_angular_resolution_x, sizeof(__pyx_k_angular_resolution_x), 0, 0, 1, 1},
+  {&__pyx_n_s_angular_resolution_y, __pyx_k_angular_resolution_y, sizeof(__pyx_k_angular_resolution_y), 0, 0, 1, 1},
+  {&__pyx_n_s_array, __pyx_k_array, sizeof(__pyx_k_array), 0, 0, 1, 1},
+  {&__pyx_n_s_ascii, __pyx_k_ascii, sizeof(__pyx_k_ascii), 0, 0, 1, 1},
+  {&__pyx_n_s_binary, __pyx_k_binary, sizeof(__pyx_k_binary), 0, 0, 1, 1},
+  {&__pyx_n_s_border_size, __pyx_k_border_size, sizeof(__pyx_k_border_size), 0, 0, 1, 1},
+  {&__pyx_kp_s_border_size_2, __pyx_k_border_size_2, sizeof(__pyx_k_border_size_2), 0, 0, 1, 0},
+  {&__pyx_kp_s_call_createFromPointCloud, __pyx_k_call_createFromPointCloud, sizeof(__pyx_k_call_createFromPointCloud), 0, 0, 1, 0},
+  {&__pyx_kp_s_can_t_resize_PointCloud_while_th, __pyx_k_can_t_resize_PointCloud_while_th, sizeof(__pyx_k_can_t_resize_PointCloud_while_th), 0, 0, 1, 0},
+  {&__pyx_kp_s_can_t_resize_Vertices_while_ther, __pyx_k_can_t_resize_Vertices_while_ther, sizeof(__pyx_k_can_t_resize_Vertices_while_ther), 0, 0, 1, 0},
+  {&__pyx_kp_s_cinit___end, __pyx_k_cinit___end, sizeof(__pyx_k_cinit___end), 0, 0, 1, 0},
+  {&__pyx_kp_s_cinit___start, __pyx_k_cinit___start, sizeof(__pyx_k_cinit___start), 0, 0, 1, 0},
+  {&__pyx_n_s_cloud, __pyx_k_cloud, sizeof(__pyx_k_cloud), 0, 0, 1, 1},
+  {&__pyx_kp_s_cloud_height, __pyx_k_cloud_height, sizeof(__pyx_k_cloud_height), 0, 0, 1, 0},
+  {&__pyx_kp_s_cloud_size, __pyx_k_cloud_size, sizeof(__pyx_k_cloud_size), 0, 0, 1, 0},
+  {&__pyx_kp_s_cloud_width, __pyx_k_cloud_width, sizeof(__pyx_k_cloud_width), 0, 0, 1, 0},
+  {&__pyx_n_s_col, __pyx_k_col, sizeof(__pyx_k_col), 0, 0, 1, 1},
+  {&__pyx_n_s_collections, __pyx_k_collections, sizeof(__pyx_k_collections), 0, 0, 1, 1},
+  {&__pyx_n_s_compOp, __pyx_k_compOp, sizeof(__pyx_k_compOp), 0, 0, 1, 1},
+  {&__pyx_n_s_cond, __pyx_k_cond, sizeof(__pyx_k_cond), 0, 0, 1, 1},
+  {&__pyx_n_s_coordinate_frame, __pyx_k_coordinate_frame, sizeof(__pyx_k_coordinate_frame), 0, 0, 1, 1},
+  {&__pyx_n_s_deg2rad, __pyx_k_deg2rad, sizeof(__pyx_k_deg2rad), 0, 0, 1, 1},
+  {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1},
+  {&__pyx_n_s_empty, __pyx_k_empty, sizeof(__pyx_k_empty), 0, 0, 1, 1},
+  {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1},
+  {&__pyx_n_s_end, __pyx_k_end, sizeof(__pyx_k_end), 0, 0, 1, 1},
+  {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1},
+  {&__pyx_n_s_f, __pyx_k_f, sizeof(__pyx_k_f), 0, 0, 1, 1},
+  {&__pyx_n_s_f1, __pyx_k_f1, sizeof(__pyx_k_f1), 0, 0, 1, 1},
+  {&__pyx_n_s_f2, __pyx_k_f2, sizeof(__pyx_k_f2), 0, 0, 1, 1},
+  {&__pyx_n_s_field_name, __pyx_k_field_name, sizeof(__pyx_k_field_name), 0, 0, 1, 1},
+  {&__pyx_kp_s_field_name_should_be_a_string_go, __pyx_k_field_name_should_be_a_string_go, sizeof(__pyx_k_field_name_should_be_a_string_go), 0, 0, 1, 0},
+  {&__pyx_n_s_file, __pyx_k_file, sizeof(__pyx_k_file), 0, 0, 1, 1},
+  {&__pyx_n_s_filter_max, __pyx_k_filter_max, sizeof(__pyx_k_filter_max), 0, 0, 1, 1},
+  {&__pyx_n_s_filter_min, __pyx_k_filter_min, sizeof(__pyx_k_filter_min), 0, 0, 1, 1},
+  {&__pyx_kp_s_filter_outputCloud_size, __pyx_k_filter_outputCloud_size, sizeof(__pyx_k_filter_outputCloud_size), 0, 0, 1, 0},
+  {&__pyx_kp_s_filter_pc_size, __pyx_k_filter_pc_size, sizeof(__pyx_k_filter_pc_size), 0, 0, 1, 0},
+  {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1},
+  {&__pyx_n_s_float32, __pyx_k_float32, sizeof(__pyx_k_float32), 0, 0, 1, 1},
+  {&__pyx_n_s_fname, __pyx_k_fname, sizeof(__pyx_k_fname), 0, 0, 1, 1},
+  {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1},
+  {&__pyx_n_s_from_array, __pyx_k_from_array, sizeof(__pyx_k_from_array), 0, 0, 1, 1},
+  {&__pyx_n_s_from_list, __pyx_k_from_list, sizeof(__pyx_k_from_list), 0, 0, 1, 1},
+  {&__pyx_n_s_from_pcd_file, __pyx_k_from_pcd_file, sizeof(__pyx_k_from_pcd_file), 0, 0, 1, 1},
+  {&__pyx_n_s_height, __pyx_k_height, sizeof(__pyx_k_height), 0, 0, 1, 1},
+  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
+  {&__pyx_n_s_index, __pyx_k_index, sizeof(__pyx_k_index), 0, 0, 1, 1},
+  {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1},
+  {&__pyx_n_s_int32, __pyx_k_int32, sizeof(__pyx_k_int32), 0, 0, 1, 1},
+  {&__pyx_n_s_integer, __pyx_k_integer, sizeof(__pyx_k_integer), 0, 0, 1, 1},
+  {&__pyx_n_s_k, __pyx_k_k, sizeof(__pyx_k_k), 0, 0, 1, 1},
+  {&__pyx_kp_s_keypoints_count, __pyx_k_keypoints_count, sizeof(__pyx_k_keypoints_count), 0, 0, 1, 0},
+  {&__pyx_n_s_ksearch, __pyx_k_ksearch, sizeof(__pyx_k_ksearch), 0, 0, 1, 1},
+  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
+  {&__pyx_n_s_make_NormalEstimation, __pyx_k_make_NormalEstimation, sizeof(__pyx_k_make_NormalEstimation), 0, 0, 1, 1},
+  {&__pyx_n_s_max_angle, __pyx_k_max_angle, sizeof(__pyx_k_max_angle), 0, 0, 1, 1},
+  {&__pyx_n_s_max_angle_height, __pyx_k_max_angle_height, sizeof(__pyx_k_max_angle_height), 0, 0, 1, 1},
+  {&__pyx_kp_s_max_angle_height_2, __pyx_k_max_angle_height_2, sizeof(__pyx_k_max_angle_height_2), 0, 0, 1, 0},
+  {&__pyx_n_s_max_angle_width, __pyx_k_max_angle_width, sizeof(__pyx_k_max_angle_width), 0, 0, 1, 1},
+  {&__pyx_kp_s_max_angle_width_2, __pyx_k_max_angle_width_2, sizeof(__pyx_k_max_angle_width_2), 0, 0, 1, 0},
+  {&__pyx_n_s_max_iter, __pyx_k_max_iter, sizeof(__pyx_k_max_iter), 0, 0, 1, 1},
+  {&__pyx_n_s_max_nn, __pyx_k_max_nn, sizeof(__pyx_k_max_nn), 0, 0, 1, 1},
+  {&__pyx_n_s_maxs, __pyx_k_maxs, sizeof(__pyx_k_maxs), 0, 0, 1, 1},
+  {&__pyx_n_s_maxx, __pyx_k_maxx, sizeof(__pyx_k_maxx), 0, 0, 1, 1},
+  {&__pyx_n_s_maxy, __pyx_k_maxy, sizeof(__pyx_k_maxy), 0, 0, 1, 1},
+  {&__pyx_n_s_maxz, __pyx_k_maxz, sizeof(__pyx_k_maxz), 0, 0, 1, 1},
+  {&__pyx_n_s_min_angle, __pyx_k_min_angle, sizeof(__pyx_k_min_angle), 0, 0, 1, 1},
+  {&__pyx_n_s_min_range, __pyx_k_min_range, sizeof(__pyx_k_min_range), 0, 0, 1, 1},
+  {&__pyx_kp_s_min_range_2, __pyx_k_min_range_2, sizeof(__pyx_k_min_range_2), 0, 0, 1, 0},
+  {&__pyx_n_s_mins, __pyx_k_mins, sizeof(__pyx_k_mins), 0, 0, 1, 1},
+  {&__pyx_n_s_minx, __pyx_k_minx, sizeof(__pyx_k_minx), 0, 0, 1, 1},
+  {&__pyx_n_s_miny, __pyx_k_miny, sizeof(__pyx_k_miny), 0, 0, 1, 1},
+  {&__pyx_n_s_minz, __pyx_k_minz, sizeof(__pyx_k_minz), 0, 0, 1, 1},
+  {&__pyx_n_s_model, __pyx_k_model, sizeof(__pyx_k_model), 0, 0, 1, 1},
+  {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0},
+  {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0},
+  {&__pyx_n_s_negative, __pyx_k_negative, sizeof(__pyx_k_negative), 0, 0, 1, 1},
+  {&__pyx_n_s_noise_level, __pyx_k_noise_level, sizeof(__pyx_k_noise_level), 0, 0, 1, 1},
+  {&__pyx_kp_s_noise_level_2, __pyx_k_noise_level_2, sizeof(__pyx_k_noise_level_2), 0, 0, 1, 0},
+  {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1},
+  {&__pyx_n_s_numbers, __pyx_k_numbers, sizeof(__pyx_k_numbers), 0, 0, 1, 1},
+  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
+  {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0},
+  {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0},
+  {&__pyx_n_s_order, __pyx_k_order, sizeof(__pyx_k_order), 0, 0, 1, 1},
+  {&__pyx_n_s_pc, __pyx_k_pc, sizeof(__pyx_k_pc), 0, 0, 1, 1},
+  {&__pyx_n_s_pcl__pcl, __pyx_k_pcl__pcl, sizeof(__pyx_k_pcl__pcl), 0, 0, 1, 1},
+  {&__pyx_n_s_point, __pyx_k_point, sizeof(__pyx_k_point), 0, 0, 1, 1},
+  {&__pyx_n_s_points, __pyx_k_points, sizeof(__pyx_k_points), 0, 0, 1, 1},
+  {&__pyx_n_s_print, __pyx_k_print, sizeof(__pyx_k_print), 0, 0, 1, 1},
+  {&__pyx_n_s_pyindices, __pyx_k_pyindices, sizeof(__pyx_k_pyindices), 0, 0, 1, 1},
+  {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1},
+  {&__pyx_n_s_rad2deg, __pyx_k_rad2deg, sizeof(__pyx_k_rad2deg), 0, 0, 1, 1},
+  {&__pyx_n_s_radius, __pyx_k_radius, sizeof(__pyx_k_radius), 0, 0, 1, 1},
+  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
+  {&__pyx_n_s_resize, __pyx_k_resize, sizeof(__pyx_k_resize), 0, 0, 1, 1},
+  {&__pyx_n_s_resolution, __pyx_k_resolution, sizeof(__pyx_k_resolution), 0, 0, 1, 1},
+  {&__pyx_n_s_row, __pyx_k_row, sizeof(__pyx_k_row), 0, 0, 1, 1},
+  {&__pyx_n_s_rx, __pyx_k_rx, sizeof(__pyx_k_rx), 0, 0, 1, 1},
+  {&__pyx_n_s_ry, __pyx_k_ry, sizeof(__pyx_k_ry), 0, 0, 1, 1},
+  {&__pyx_n_s_rz, __pyx_k_rz, sizeof(__pyx_k_rz), 0, 0, 1, 1},
+  {&__pyx_n_s_searchRadius, __pyx_k_searchRadius, sizeof(__pyx_k_searchRadius), 0, 0, 1, 1},
+  {&__pyx_n_s_set_input_cloud, __pyx_k_set_input_cloud, sizeof(__pyx_k_set_input_cloud), 0, 0, 1, 1},
+  {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1},
+  {&__pyx_n_s_source, __pyx_k_source, sizeof(__pyx_k_source), 0, 0, 1, 1},
+  {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1},
+  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
+  {&__pyx_n_s_thresh, __pyx_k_thresh, sizeof(__pyx_k_thresh), 0, 0, 1, 1},
+  {&__pyx_n_s_to_array, __pyx_k_to_array, sizeof(__pyx_k_to_array), 0, 0, 1, 1},
+  {&__pyx_n_s_to_pcd_file, __pyx_k_to_pcd_file, sizeof(__pyx_k_to_pcd_file), 0, 0, 1, 1},
+  {&__pyx_n_s_tolist, __pyx_k_tolist, sizeof(__pyx_k_tolist), 0, 0, 1, 1},
+  {&__pyx_n_s_tx, __pyx_k_tx, sizeof(__pyx_k_tx), 0, 0, 1, 1},
+  {&__pyx_n_s_ty, __pyx_k_ty, sizeof(__pyx_k_ty), 0, 0, 1, 1},
+  {&__pyx_n_s_tz, __pyx_k_tz, sizeof(__pyx_k_tz), 0, 0, 1, 1},
+  {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0},
+  {&__pyx_n_s_vertices, __pyx_k_vertices, sizeof(__pyx_k_vertices), 0, 0, 1, 1},
+  {&__pyx_n_s_vt, __pyx_k_vt, sizeof(__pyx_k_vt), 0, 0, 1, 1},
+  {&__pyx_n_s_width, __pyx_k_width, sizeof(__pyx_k_width), 0, 0, 1, 1},
+  {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1},
+  {&__pyx_n_s_y, __pyx_k_y, sizeof(__pyx_k_y), 0, 0, 1, 1},
+  {&__pyx_n_s_z, __pyx_k_z, sizeof(__pyx_k_z), 0, 0, 1, 1},
+  {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1},
+  {0, 0, 0, 0, 0, 0, 0}
+};
+static int __Pyx_InitCachedBuiltins(void) {
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 21, __pyx_L1_error)
+  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 20, __pyx_L1_error)
+  __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(2, 21, __pyx_L1_error)
+  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(3, 196, __pyx_L1_error)
+  __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(46, 799, __pyx_L1_error)
+  __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(46, 989, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+static int __Pyx_InitCachedConstants(void) {
+  __Pyx_RefNannyDeclarations
+  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":18
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+  __pyx_tuple_ = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 18, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple_);
+  __Pyx_GIVEREF(__pyx_tuple_);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":55
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__2);
+  __Pyx_GIVEREF(__pyx_tuple__2);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":89
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__3);
+  __Pyx_GIVEREF(__pyx_tuple__3);
+
+  /* "pcl/pxi/Filters/PassThroughFilter_180.pxi":123
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r"
+ */
+  __pyx_tuple__4 = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 123, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__4);
+  __Pyx_GIVEREF(__pyx_tuple__4);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":116
+ *         result = pc.to_array()
+ *         cdef cpp.PointXYZ point
+ *         point.x = result[0, 0]             # <<<<<<<<<<<<<<
+ *         point.y = result[0, 1]
+ *         point.z = result[0, 2]
+ */
+  __pyx_tuple__5 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_0); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(2, 116, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__5);
+  __Pyx_GIVEREF(__pyx_tuple__5);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":117
+ *         cdef cpp.PointXYZ point
+ *         point.x = result[0, 0]
+ *         point.y = result[0, 1]             # <<<<<<<<<<<<<<
+ *         point.z = result[0, 2]
+ * 
+ */
+  __pyx_tuple__6 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(2, 117, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__6);
+  __Pyx_GIVEREF(__pyx_tuple__6);
+
+  /* "pcl/pxi/Octree/OctreePointCloudSearch_180.pxi":118
+ *         point.x = result[0, 0]
+ *         point.y = result[0, 1]
+ *         point.z = result[0, 2]             # <<<<<<<<<<<<<<
+ * 
+ *         print ('VoxelSearch at (' + str(point.x) + ' ' + str(point.y) + ' ' + str(point.z) + ')')
+ */
+  __pyx_tuple__7 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_2); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(2, 118, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__7);
+  __Pyx_GIVEREF(__pyx_tuple__7);
+
+  /* "pcl/pxi/Vertices.pxi":89
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize Vertices while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().vertices.resize(x)
+ */
+  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_can_t_resize_Vertices_while_ther); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(16, 89, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__10);
+  __Pyx_GIVEREF(__pyx_tuple__10);
+
+  /* "pcl/pxi/Filters/ConditionAnd.pxi":33
+ *         cdef bytes fname_ascii
+ *         if isinstance(field_name, unicode):
+ *             fname_ascii = field_name.encode("ascii")             # <<<<<<<<<<<<<<
+ *         elif not isinstance(field_name, bytes):
+ *             raise TypeError("field_name should be a string, got %r" % field_name)
+ */
+  __pyx_tuple__11 = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(21, 33, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__11);
+  __Pyx_GIVEREF(__pyx_tuple__11);
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":55
+ *         cdef np.float32_t *transf_data
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')             # <<<<<<<<<<<<<<
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ */
+  __pyx_tuple__12 = PyTuple_Pack(2, __pyx_int_4, __pyx_int_4); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__12);
+  __Pyx_GIVEREF(__pyx_tuple__12);
+  __pyx_tuple__13 = PyTuple_Pack(1, __pyx_tuple__12); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(25, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__13);
+  __Pyx_GIVEREF(__pyx_tuple__13);
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":72
+ *         cdef np.float32_t *transf_data
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')             # <<<<<<<<<<<<<<
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ */
+  __pyx_tuple__14 = PyTuple_Pack(2, __pyx_int_4, __pyx_int_4); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__14);
+  __Pyx_GIVEREF(__pyx_tuple__14);
+  __pyx_tuple__15 = PyTuple_Pack(1, __pyx_tuple__14); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(26, 72, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__15);
+  __Pyx_GIVEREF(__pyx_tuple__15);
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":55
+ *         cdef np.float32_t *transf_data
+ * 
+ *         transf = np.empty((4, 4), dtype=np.float32, order='fortran')             # <<<<<<<<<<<<<<
+ *         transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+ * 
+ */
+  __pyx_tuple__16 = PyTuple_Pack(2, __pyx_int_4, __pyx_int_4); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__16);
+  __Pyx_GIVEREF(__pyx_tuple__16);
+  __pyx_tuple__17 = PyTuple_Pack(1, __pyx_tuple__16); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(27, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__17);
+  __Pyx_GIVEREF(__pyx_tuple__17);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":208
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+  __pyx_tuple__18 = PyTuple_Pack(1, __pyx_kp_s_can_t_resize_PointCloud_while_th); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(3, 208, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__18);
+  __Pyx_GIVEREF(__pyx_tuple__18);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":200
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+  __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_can_t_resize_PointCloud_while_th); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(41, 200, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__19);
+  __Pyx_GIVEREF(__pyx_tuple__19);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":197
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+  __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_can_t_resize_PointCloud_while_th); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(42, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__20);
+  __Pyx_GIVEREF(__pyx_tuple__20);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":197
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+  __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_can_t_resize_PointCloud_while_th); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(43, 197, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__21);
+  __Pyx_GIVEREF(__pyx_tuple__21);
+
+  /* "pcl/pxi/PointCloud_PointWithViewpoint.pxi":129
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+  __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_can_t_resize_PointCloud_while_th); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(44, 129, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__22);
+  __Pyx_GIVEREF(__pyx_tuple__22);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":134
+ *     def resize(self, cnp.npy_intp x):
+ *         if self._view_count > 0:
+ *             raise ValueError("can't resize PointCloud while there are"             # <<<<<<<<<<<<<<
+ *                              " arrays/memoryviews referencing it")
+ *         self.thisptr().resize(x)
+ */
+  __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_can_t_resize_PointCloud_while_th); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(45, 134, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__23);
+  __Pyx_GIVEREF(__pyx_tuple__23);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":218
+ *             if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not C contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+  __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(46, 218, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__24);
+  __Pyx_GIVEREF(__pyx_tuple__24);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":222
+ *             if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ *                 and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)):
+ *                 raise ValueError(u"ndarray is not Fortran contiguous")             # <<<<<<<<<<<<<<
+ * 
+ *             info.buf = PyArray_DATA(self)
+ */
+  __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(46, 222, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__25);
+  __Pyx_GIVEREF(__pyx_tuple__25);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":259
+ *                 if ((descr.byteorder == c'>' and little_endian) or
+ *                     (descr.byteorder == c'<' and not little_endian)):
+ *                     raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *                 if   t == NPY_BYTE:        f = "b"
+ *                 elif t == NPY_UBYTE:       f = "B"
+ */
+  __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(46, 259, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__26);
+  __Pyx_GIVEREF(__pyx_tuple__26);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":799
+ * 
+ *         if (end - f) - <int>(new_offset - offset[0]) < 15:
+ *             raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")             # <<<<<<<<<<<<<<
+ * 
+ *         if ((child.byteorder == c'>' and little_endian) or
+ */
+  __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(46, 799, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__27);
+  __Pyx_GIVEREF(__pyx_tuple__27);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":803
+ *         if ((child.byteorder == c'>' and little_endian) or
+ *             (child.byteorder == c'<' and not little_endian)):
+ *             raise ValueError(u"Non-native byte order not supported")             # <<<<<<<<<<<<<<
+ *             # One could encode it in the format string and have Cython
+ *             # complain instead, BUT: < and > in format strings also imply
+ */
+  __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(46, 803, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__28);
+  __Pyx_GIVEREF(__pyx_tuple__28);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":823
+ *             t = child.type_num
+ *             if end - f < 5:
+ *                 raise RuntimeError(u"Format string allocated too short.")             # <<<<<<<<<<<<<<
+ * 
+ *             # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+  __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(46, 823, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__29);
+  __Pyx_GIVEREF(__pyx_tuple__29);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":989
+ *         _import_array()
+ *     except Exception:
+ *         raise ImportError("numpy.core.multiarray failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_umath() except -1:
+ */
+  __pyx_tuple__30 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(46, 989, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__30);
+  __Pyx_GIVEREF(__pyx_tuple__30);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":995
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ * 
+ * cdef inline int import_ufunc() except -1:
+ */
+  __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(46, 995, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__31);
+  __Pyx_GIVEREF(__pyx_tuple__31);
+
+  /* "../../../usr/local/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1001
+ *         _import_umath()
+ *     except Exception:
+ *         raise ImportError("numpy.core.umath failed to import")             # <<<<<<<<<<<<<<
+ */
+  __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(46, 1001, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__32);
+  __Pyx_GIVEREF(__pyx_tuple__32);
+
+  /* "pcl/_pcl_180.pyx":146
+ * 
+ * ### common ###
+ * def deg2rad(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ */
+  __pyx_tuple__33 = PyTuple_Pack(2, __pyx_n_s_alpha, __pyx_n_s_alpha); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(4, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__33);
+  __Pyx_GIVEREF(__pyx_tuple__33);
+  __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_T_O_python_pcl_pcl__pcl_1, __pyx_n_s_deg2rad, 146, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(4, 146, __pyx_L1_error)
+
+  /* "pcl/_pcl_180.pyx":149
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ * def rad2deg(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.rad2deg(alpha)
+ * 
+ */
+  __pyx_tuple__35 = PyTuple_Pack(2, __pyx_n_s_alpha, __pyx_n_s_alpha); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(4, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_tuple__35);
+  __Pyx_GIVEREF(__pyx_tuple__35);
+  __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_T_O_python_pcl_pcl__pcl_1, __pyx_n_s_rad2deg, 149, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(4, 149, __pyx_L1_error)
+  __Pyx_RefNannyFinishContext();
+  return 0;
+  __pyx_L1_error:;
+  __Pyx_RefNannyFinishContext();
+  return -1;
+}
+
+static int __Pyx_InitGlobals(void) {
+  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(4, 1, __pyx_L1_error);
+  __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) __PYX_ERR(4, 1, __pyx_L1_error)
+  return 0;
+  __pyx_L1_error:;
+  return -1;
+}
+
+#if PY_MAJOR_VERSION < 3
+PyMODINIT_FUNC init_pcl(void); /*proto*/
+PyMODINIT_FUNC init_pcl(void)
+#else
+PyMODINIT_FUNC PyInit__pcl(void); /*proto*/
+PyMODINIT_FUNC PyInit__pcl(void)
+#endif
+{
+  PyObject *__pyx_t_1 = NULL;
+  PyObject *__pyx_t_2 = NULL;
+  int __pyx_t_3;
+  PyObject *__pyx_t_4 = NULL;
+  PyObject *__pyx_t_5 = NULL;
+  PyObject *__pyx_t_6 = NULL;
+  __Pyx_RefNannyDeclarations
+  #if CYTHON_REFNANNY
+  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
+  if (!__Pyx_RefNanny) {
+      PyErr_Clear();
+      __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
+      if (!__Pyx_RefNanny)
+          Py_FatalError("failed to import 'refnanny' module");
+  }
+  #endif
+  __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__pcl(void)", 0);
+  if (__Pyx_check_binary_version() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(4, 1, __pyx_L1_error)
+  #ifdef __Pyx_CyFunction_USED
+  if (__pyx_CyFunction_init() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_FusedFunction_USED
+  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Coroutine_USED
+  if (__pyx_Coroutine_init() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_Generator_USED
+  if (__pyx_Generator_init() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #endif
+  #ifdef __Pyx_StopAsyncIteration_USED
+  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #endif
+  /*--- Library function declarations ---*/
+  /*--- Threads initialization code ---*/
+  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
+  #ifdef WITH_THREAD /* Python build with threading support? */
+  PyEval_InitThreads();
+  #endif
+  #endif
+  /*--- Module creation code ---*/
+  #if PY_MAJOR_VERSION < 3
+  __pyx_m = Py_InitModule4("_pcl", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+  #else
+  __pyx_m = PyModule_Create(&__pyx_moduledef);
+  #endif
+  if (unlikely(!__pyx_m)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(4, 1, __pyx_L1_error)
+  Py_INCREF(__pyx_d);
+  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(4, 1, __pyx_L1_error)
+  #if CYTHON_COMPILING_IN_PYPY
+  Py_INCREF(__pyx_b);
+  #endif
+  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(4, 1, __pyx_L1_error);
+  /*--- Initialize various global constants etc. ---*/
+  if (__Pyx_InitGlobals() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #endif
+  if (__pyx_module_is_main_pcl___pcl) {
+    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  }
+  #if PY_MAJOR_VERSION >= 3
+  {
+    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(4, 1, __pyx_L1_error)
+    if (!PyDict_GetItemString(modules, "pcl._pcl")) {
+      if (unlikely(PyDict_SetItemString(modules, "pcl._pcl", __pyx_m) < 0)) __PYX_ERR(4, 1, __pyx_L1_error)
+    }
+  }
+  #endif
+  /*--- Builtin init code ---*/
+  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  /*--- Constants init code ---*/
+  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  /*--- Global init code ---*/
+  __pyx_v_3pcl_4_pcl__pc_tmp = ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)Py_None); Py_INCREF(Py_None);
+  __pyx_v_3pcl_4_pcl__pc_xyzi_tmp4 = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)Py_None); Py_INCREF(Py_None);
+  __pyx_v_3pcl_4_pcl__pc_xyzrgb_tmp3 = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)Py_None); Py_INCREF(Py_None);
+  __pyx_v_3pcl_4_pcl__pc_xyzrgba_tmp2 = ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)Py_None); Py_INCREF(Py_None);
+  /*--- Variable export code ---*/
+  /*--- Function export code ---*/
+  /*--- Type init code ---*/
+  __pyx_vtabptr_3pcl_4_pcl_PointCloud = &__pyx_vtable_3pcl_4_pcl_PointCloud;
+  __pyx_vtable_3pcl_4_pcl_PointCloud.thisptr = (pcl::PointCloud<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_PointCloud *))__pyx_f_3pcl_4_pcl_10PointCloud_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PointCloud) < 0) __PYX_ERR(3, 54, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PointCloud.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_PointCloud.tp_dict, __pyx_vtabptr_3pcl_4_pcl_PointCloud) < 0) __PYX_ERR(3, 54, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "PointCloud", (PyObject *)&__pyx_type_3pcl_4_pcl_PointCloud) < 0) __PYX_ERR(3, 54, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PointCloud = &__pyx_type_3pcl_4_pcl_PointCloud;
+  __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZI = &__pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZI;
+  __pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZI.thisptr = (pcl::PointCloud<struct pcl::PointXYZI>  *(*)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *))__pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PointCloud_PointXYZI) < 0) __PYX_ERR(41, 45, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PointCloud_PointXYZI.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_PointCloud_PointXYZI.tp_dict, __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZI) < 0) __PYX_ERR(41, 45, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "PointCloud_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_PointCloud_PointXYZI) < 0) __PYX_ERR(41, 45, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI = &__pyx_type_3pcl_4_pcl_PointCloud_PointXYZI;
+  __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGB = &__pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZRGB;
+  __pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZRGB.thisptr = (pcl::PointCloud<struct pcl::PointXYZRGB>  *(*)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *))__pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGB) < 0) __PYX_ERR(42, 45, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGB.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGB.tp_dict, __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGB) < 0) __PYX_ERR(42, 45, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "PointCloud_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGB) < 0) __PYX_ERR(42, 45, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB = &__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGB;
+  __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGBA = &__pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZRGBA;
+  __pyx_vtable_3pcl_4_pcl_PointCloud_PointXYZRGBA.thisptr = (pcl::PointCloud<struct pcl::PointXYZRGBA>  *(*)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *))__pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGBA) < 0) __PYX_ERR(43, 45, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGBA.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGBA.tp_dict, __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointXYZRGBA) < 0) __PYX_ERR(43, 45, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "PointCloud_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGBA) < 0) __PYX_ERR(43, 45, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_PointCloud_PointXYZRGBA;
+  __pyx_vtabptr_3pcl_4_pcl_Vertices = &__pyx_vtable_3pcl_4_pcl_Vertices;
+  __pyx_vtable_3pcl_4_pcl_Vertices.thisptr = (pcl::Vertices *(*)(struct __pyx_obj_3pcl_4_pcl_Vertices *))__pyx_f_3pcl_4_pcl_8Vertices_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Vertices) < 0) __PYX_ERR(16, 6, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Vertices.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_Vertices.tp_dict, __pyx_vtabptr_3pcl_4_pcl_Vertices) < 0) __PYX_ERR(16, 6, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "Vertices", (PyObject *)&__pyx_type_3pcl_4_pcl_Vertices) < 0) __PYX_ERR(16, 6, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Vertices = &__pyx_type_3pcl_4_pcl_Vertices;
+  __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointWithViewpoint = &__pyx_vtable_3pcl_4_pcl_PointCloud_PointWithViewpoint;
+  __pyx_vtable_3pcl_4_pcl_PointCloud_PointWithViewpoint.thisptr = (pcl::PointCloud<struct pcl::PointWithViewpoint>  *(*)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointWithViewpoint *))__pyx_f_3pcl_4_pcl_29PointCloud_PointWithViewpoint_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PointCloud_PointWithViewpoint) < 0) __PYX_ERR(44, 9, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PointCloud_PointWithViewpoint.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_PointCloud_PointWithViewpoint.tp_dict, __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointWithViewpoint) < 0) __PYX_ERR(44, 9, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "PointCloud_PointWithViewpoint", (PyObject *)&__pyx_type_3pcl_4_pcl_PointCloud_PointWithViewpoint) < 0) __PYX_ERR(44, 9, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PointCloud_PointWithViewpoint = &__pyx_type_3pcl_4_pcl_PointCloud_PointWithViewpoint;
+  __pyx_vtabptr_3pcl_4_pcl_PointCloud_Normal = &__pyx_vtable_3pcl_4_pcl_PointCloud_Normal;
+  __pyx_vtable_3pcl_4_pcl_PointCloud_Normal.thisptr = (pcl::PointCloud<struct pcl::Normal>  *(*)(struct __pyx_obj_3pcl_4_pcl_PointCloud_Normal *))__pyx_f_3pcl_4_pcl_17PointCloud_Normal_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PointCloud_Normal) < 0) __PYX_ERR(48, 91, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PointCloud_Normal.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_PointCloud_Normal.tp_dict, __pyx_vtabptr_3pcl_4_pcl_PointCloud_Normal) < 0) __PYX_ERR(48, 91, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "PointCloud_Normal", (PyObject *)&__pyx_type_3pcl_4_pcl_PointCloud_Normal) < 0) __PYX_ERR(48, 91, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PointCloud_Normal = &__pyx_type_3pcl_4_pcl_PointCloud_Normal;
+  __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointNormal = &__pyx_vtable_3pcl_4_pcl_PointCloud_PointNormal;
+  __pyx_vtable_3pcl_4_pcl_PointCloud_PointNormal.thisptr = (pcl::PointCloud<struct pcl::PointNormal>  *(*)(struct __pyx_obj_3pcl_4_pcl_PointCloud_PointNormal *))__pyx_f_3pcl_4_pcl_22PointCloud_PointNormal_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PointCloud_PointNormal) < 0) __PYX_ERR(45, 13, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PointCloud_PointNormal.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_PointCloud_PointNormal.tp_dict, __pyx_vtabptr_3pcl_4_pcl_PointCloud_PointNormal) < 0) __PYX_ERR(45, 13, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "PointCloud_PointNormal", (PyObject *)&__pyx_type_3pcl_4_pcl_PointCloud_PointNormal) < 0) __PYX_ERR(45, 13, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PointCloud_PointNormal = &__pyx_type_3pcl_4_pcl_PointCloud_PointNormal;
+  __pyx_vtabptr_3pcl_4_pcl_KdTree = &__pyx_vtable_3pcl_4_pcl_KdTree;
+  __pyx_vtable_3pcl_4_pcl_KdTree.thisptr = (pcl::search::KdTree<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_KdTree *))__pyx_f_3pcl_4_pcl_6KdTree_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_KdTree) < 0) __PYX_ERR(48, 118, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_KdTree.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_KdTree.tp_dict, __pyx_vtabptr_3pcl_4_pcl_KdTree) < 0) __PYX_ERR(48, 118, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "KdTree", (PyObject *)&__pyx_type_3pcl_4_pcl_KdTree) < 0) __PYX_ERR(48, 118, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_KdTree = &__pyx_type_3pcl_4_pcl_KdTree;
+  __pyx_vtabptr_3pcl_4_pcl_RangeImages = &__pyx_vtable_3pcl_4_pcl_RangeImages;
+  __pyx_vtable_3pcl_4_pcl_RangeImages.thisptr = (pcl::RangeImage *(*)(struct __pyx_obj_3pcl_4_pcl_RangeImages *))__pyx_f_3pcl_4_pcl_11RangeImages_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_RangeImages) < 0) __PYX_ERR(24, 12, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_RangeImages.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_RangeImages.tp_dict, __pyx_vtabptr_3pcl_4_pcl_RangeImages) < 0) __PYX_ERR(24, 12, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "RangeImages", (PyObject *)&__pyx_type_3pcl_4_pcl_RangeImages) < 0) __PYX_ERR(24, 12, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_RangeImages = &__pyx_type_3pcl_4_pcl_RangeImages;
+  __pyx_vtabptr_3pcl_4_pcl_IntegralImageNormalEstimation = &__pyx_vtable_3pcl_4_pcl_IntegralImageNormalEstimation;
+  __pyx_vtable_3pcl_4_pcl_IntegralImageNormalEstimation.thisptr = (pcl::IntegralImageNormalEstimation<struct pcl::PointXYZ,struct pcl::Normal>  *(*)(struct __pyx_obj_3pcl_4_pcl_IntegralImageNormalEstimation *))__pyx_f_3pcl_4_pcl_29IntegralImageNormalEstimation_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_IntegralImageNormalEstimation) < 0) __PYX_ERR(37, 17, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_IntegralImageNormalEstimation.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_IntegralImageNormalEstimation.tp_dict, __pyx_vtabptr_3pcl_4_pcl_IntegralImageNormalEstimation) < 0) __PYX_ERR(37, 17, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "IntegralImageNormalEstimation", (PyObject *)&__pyx_type_3pcl_4_pcl_IntegralImageNormalEstimation) < 0) __PYX_ERR(37, 17, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_IntegralImageNormalEstimation = &__pyx_type_3pcl_4_pcl_IntegralImageNormalEstimation;
+  __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModel = &__pyx_vtable_3pcl_4_pcl_SampleConsensusModel;
+  __pyx_vtable_3pcl_4_pcl_SampleConsensusModel.thisptr = (pcl::SampleConsensusModel<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModel *))__pyx_f_3pcl_4_pcl_20SampleConsensusModel_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SampleConsensusModel) < 0) __PYX_ERR(48, 155, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SampleConsensusModel.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_SampleConsensusModel.tp_dict, __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModel) < 0) __PYX_ERR(48, 155, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "SampleConsensusModel", (PyObject *)&__pyx_type_3pcl_4_pcl_SampleConsensusModel) < 0) __PYX_ERR(48, 155, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SampleConsensusModel = &__pyx_type_3pcl_4_pcl_SampleConsensusModel;
+  __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelPlane = &__pyx_vtable_3pcl_4_pcl_SampleConsensusModelPlane;
+  __pyx_vtable_3pcl_4_pcl_SampleConsensusModelPlane.thisptr = (pcl::SampleConsensusModelPlane<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelPlane *))__pyx_f_3pcl_4_pcl_25SampleConsensusModelPlane_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SampleConsensusModelPlane) < 0) __PYX_ERR(29, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SampleConsensusModelPlane.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_SampleConsensusModelPlane.tp_dict, __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelPlane) < 0) __PYX_ERR(29, 5, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "SampleConsensusModelPlane", (PyObject *)&__pyx_type_3pcl_4_pcl_SampleConsensusModelPlane) < 0) __PYX_ERR(29, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SampleConsensusModelPlane = &__pyx_type_3pcl_4_pcl_SampleConsensusModelPlane;
+  __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelSphere = &__pyx_vtable_3pcl_4_pcl_SampleConsensusModelSphere;
+  __pyx_vtable_3pcl_4_pcl_SampleConsensusModelSphere.thisptr = (pcl::SampleConsensusModelSphere<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelSphere *))__pyx_f_3pcl_4_pcl_26SampleConsensusModelSphere_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SampleConsensusModelSphere) < 0) __PYX_ERR(30, 7, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SampleConsensusModelSphere.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_SampleConsensusModelSphere.tp_dict, __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelSphere) < 0) __PYX_ERR(30, 7, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "SampleConsensusModelSphere", (PyObject *)&__pyx_type_3pcl_4_pcl_SampleConsensusModelSphere) < 0) __PYX_ERR(30, 7, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SampleConsensusModelSphere = &__pyx_type_3pcl_4_pcl_SampleConsensusModelSphere;
+  __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelCylinder = &__pyx_vtable_3pcl_4_pcl_SampleConsensusModelCylinder;
+  __pyx_vtable_3pcl_4_pcl_SampleConsensusModelCylinder.thisptr = (pcl::SampleConsensusModelCylinder<struct pcl::PointXYZ,struct pcl::Normal>  *(*)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelCylinder *))__pyx_f_3pcl_4_pcl_28SampleConsensusModelCylinder_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SampleConsensusModelCylinder) < 0) __PYX_ERR(31, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SampleConsensusModelCylinder.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_SampleConsensusModelCylinder.tp_dict, __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelCylinder) < 0) __PYX_ERR(31, 5, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "SampleConsensusModelCylinder", (PyObject *)&__pyx_type_3pcl_4_pcl_SampleConsensusModelCylinder) < 0) __PYX_ERR(31, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SampleConsensusModelCylinder = &__pyx_type_3pcl_4_pcl_SampleConsensusModelCylinder;
+  __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelLine = &__pyx_vtable_3pcl_4_pcl_SampleConsensusModelLine;
+  __pyx_vtable_3pcl_4_pcl_SampleConsensusModelLine.thisptr = (pcl::SampleConsensusModelLine<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelLine *))__pyx_f_3pcl_4_pcl_24SampleConsensusModelLine_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SampleConsensusModelLine) < 0) __PYX_ERR(32, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SampleConsensusModelLine.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_SampleConsensusModelLine.tp_dict, __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelLine) < 0) __PYX_ERR(32, 5, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "SampleConsensusModelLine", (PyObject *)&__pyx_type_3pcl_4_pcl_SampleConsensusModelLine) < 0) __PYX_ERR(32, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SampleConsensusModelLine = &__pyx_type_3pcl_4_pcl_SampleConsensusModelLine;
+  __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelRegistration = &__pyx_vtable_3pcl_4_pcl_SampleConsensusModelRegistration;
+  __pyx_vtable_3pcl_4_pcl_SampleConsensusModelRegistration.thisptr = (pcl::SampleConsensusModelRegistration<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelRegistration *))__pyx_f_3pcl_4_pcl_32SampleConsensusModelRegistration_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SampleConsensusModelRegistration) < 0) __PYX_ERR(33, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SampleConsensusModelRegistration.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_SampleConsensusModelRegistration.tp_dict, __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelRegistration) < 0) __PYX_ERR(33, 5, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "SampleConsensusModelRegistration", (PyObject *)&__pyx_type_3pcl_4_pcl_SampleConsensusModelRegistration) < 0) __PYX_ERR(33, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SampleConsensusModelRegistration = &__pyx_type_3pcl_4_pcl_SampleConsensusModelRegistration;
+  __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelStick = &__pyx_vtable_3pcl_4_pcl_SampleConsensusModelStick;
+  __pyx_vtable_3pcl_4_pcl_SampleConsensusModelStick.thisptr = (pcl::SampleConsensusModelStick<struct pcl::PointXYZ>  *(*)(struct __pyx_obj_3pcl_4_pcl_SampleConsensusModelStick *))__pyx_f_3pcl_4_pcl_25SampleConsensusModelStick_thisptr;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SampleConsensusModelStick) < 0) __PYX_ERR(34, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SampleConsensusModelStick.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_SampleConsensusModelStick.tp_dict, __pyx_vtabptr_3pcl_4_pcl_SampleConsensusModelStick) < 0) __PYX_ERR(34, 5, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "SampleConsensusModelStick", (PyObject *)&__pyx_type_3pcl_4_pcl_SampleConsensusModelStick) < 0) __PYX_ERR(34, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SampleConsensusModelStick = &__pyx_type_3pcl_4_pcl_SampleConsensusModelStick;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl__CythonCompareOp_Type) < 0) __PYX_ERR(4, 68, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl__CythonCompareOp_Type.tp_print = 0;
+  __pyx_ptype_3pcl_4_pcl__CythonCompareOp_Type = &__pyx_type_3pcl_4_pcl__CythonCompareOp_Type;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl__CythonCoordinateFrame_Type) < 0) __PYX_ERR(4, 89, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl__CythonCoordinateFrame_Type.tp_print = 0;
+  __pyx_ptype_3pcl_4_pcl__CythonCoordinateFrame_Type = &__pyx_type_3pcl_4_pcl__CythonCoordinateFrame_Type;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Segmentation) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Segmentation.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Segmentation", (PyObject *)&__pyx_type_3pcl_4_pcl_Segmentation) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Segmentation = &__pyx_type_3pcl_4_pcl_Segmentation;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZI) < 0) __PYX_ERR(0, 35, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Segmentation_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Segmentation_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZI) < 0) __PYX_ERR(0, 35, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZI = &__pyx_type_3pcl_4_pcl_Segmentation_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Segmentation_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB) < 0) __PYX_ERR(0, 63, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGB = &__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA) < 0) __PYX_ERR(0, 91, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Segmentation_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA) < 0) __PYX_ERR(0, 91, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_SegmentationNormal) < 0) __PYX_ERR(6, 18, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_SegmentationNormal.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "SegmentationNormal", (PyObject *)&__pyx_type_3pcl_4_pcl_SegmentationNormal) < 0) __PYX_ERR(6, 18, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_SegmentationNormal = &__pyx_type_3pcl_4_pcl_SegmentationNormal;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZI_Normal) < 0) __PYX_ERR(6, 71, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Segmentation_PointXYZI_Normal.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Segmentation_PointXYZI_Normal", (PyObject *)&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZI_Normal) < 0) __PYX_ERR(6, 71, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZI_Normal = &__pyx_type_3pcl_4_pcl_Segmentation_PointXYZI_Normal;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal) < 0) __PYX_ERR(6, 124, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Segmentation_PointXYZRGB_Normal", (PyObject *)&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal) < 0) __PYX_ERR(6, 124, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal = &__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGB_Normal;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal) < 0) __PYX_ERR(6, 177, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "Segmentation_PointXYZRGBA_Normal", (PyObject *)&__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal) < 0) __PYX_ERR(6, 177, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal = &__pyx_type_3pcl_4_pcl_Segmentation_PointXYZRGBA_Normal;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_EuclideanClusterExtraction) < 0) __PYX_ERR(7, 7, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_EuclideanClusterExtraction.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "EuclideanClusterExtraction", (PyObject *)&__pyx_type_3pcl_4_pcl_EuclideanClusterExtraction) < 0) __PYX_ERR(7, 7, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_EuclideanClusterExtraction = &__pyx_type_3pcl_4_pcl_EuclideanClusterExtraction;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter) < 0) __PYX_ERR(8, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "StatisticalOutlierRemovalFilter", (PyObject *)&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter) < 0) __PYX_ERR(8, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter = &__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI) < 0) __PYX_ERR(8, 67, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "StatisticalOutlierRemovalFilter_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI) < 0) __PYX_ERR(8, 67, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI = &__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB) < 0) __PYX_ERR(8, 129, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "StatisticalOutlierRemovalFilter_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB) < 0) __PYX_ERR(8, 129, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB = &__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA) < 0) __PYX_ERR(8, 191, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "StatisticalOutlierRemovalFilter_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA) < 0) __PYX_ERR(8, 191, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_StatisticalOutlierRemovalFilter_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_VoxelGridFilter) < 0) __PYX_ERR(9, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_VoxelGridFilter.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "VoxelGridFilter", (PyObject *)&__pyx_type_3pcl_4_pcl_VoxelGridFilter) < 0) __PYX_ERR(9, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_VoxelGridFilter = &__pyx_type_3pcl_4_pcl_VoxelGridFilter;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZI) < 0) __PYX_ERR(9, 30, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "VoxelGridFilter_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZI) < 0) __PYX_ERR(9, 30, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZI = &__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB) < 0) __PYX_ERR(9, 55, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "VoxelGridFilter_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB) < 0) __PYX_ERR(9, 55, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB = &__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA) < 0) __PYX_ERR(9, 80, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "VoxelGridFilter_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA) < 0) __PYX_ERR(9, 80, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_VoxelGridFilter_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PassThroughFilter) < 0) __PYX_ERR(1, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PassThroughFilter.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "PassThroughFilter", (PyObject *)&__pyx_type_3pcl_4_pcl_PassThroughFilter) < 0) __PYX_ERR(1, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PassThroughFilter = &__pyx_type_3pcl_4_pcl_PassThroughFilter;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZI) < 0) __PYX_ERR(1, 42, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "PassThroughFilter_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZI) < 0) __PYX_ERR(1, 42, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZI = &__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGB) < 0) __PYX_ERR(1, 76, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "PassThroughFilter_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGB) < 0) __PYX_ERR(1, 76, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZRGB = &__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA) < 0) __PYX_ERR(1, 110, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "PassThroughFilter_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA) < 0) __PYX_ERR(1, 110, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_PassThroughFilter_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid) < 0) __PYX_ERR(10, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ApproximateVoxelGrid", (PyObject *)&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid) < 0) __PYX_ERR(10, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid = &__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI) < 0) __PYX_ERR(10, 35, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ApproximateVoxelGrid_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI) < 0) __PYX_ERR(10, 35, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI = &__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB) < 0) __PYX_ERR(10, 64, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ApproximateVoxelGrid_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB) < 0) __PYX_ERR(10, 64, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB = &__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA) < 0) __PYX_ERR(10, 92, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ApproximateVoxelGrid_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA) < 0) __PYX_ERR(10, 92, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_ApproximateVoxelGrid_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_MovingLeastSquares) < 0) __PYX_ERR(11, 7, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_MovingLeastSquares.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "MovingLeastSquares", (PyObject *)&__pyx_type_3pcl_4_pcl_MovingLeastSquares) < 0) __PYX_ERR(11, 7, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_MovingLeastSquares = &__pyx_type_3pcl_4_pcl_MovingLeastSquares;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB) < 0) __PYX_ERR(11, 105, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "MovingLeastSquares_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB) < 0) __PYX_ERR(11, 105, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB = &__pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA) < 0) __PYX_ERR(11, 149, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "MovingLeastSquares_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA) < 0) __PYX_ERR(11, 149, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_MovingLeastSquares_PointXYZRGBA;
+  __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN = &__pyx_vtable_3pcl_4_pcl_KdTreeFLANN;
+  __pyx_vtable_3pcl_4_pcl_KdTreeFLANN._nearest_k = (void (*)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, int, int, PyArrayObject *, PyArrayObject *))__pyx_f_3pcl_4_pcl_11KdTreeFLANN__nearest_k;
+  __pyx_vtable_3pcl_4_pcl_KdTreeFLANN._search_radius = (void (*)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, int, int, double, PyArrayObject *, PyArrayObject *))__pyx_f_3pcl_4_pcl_11KdTreeFLANN__search_radius;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_KdTreeFLANN) < 0) __PYX_ERR(12, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_KdTreeFLANN.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_KdTreeFLANN.tp_dict, __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN) < 0) __PYX_ERR(12, 5, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "KdTreeFLANN", (PyObject *)&__pyx_type_3pcl_4_pcl_KdTreeFLANN) < 0) __PYX_ERR(12, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_KdTreeFLANN = &__pyx_type_3pcl_4_pcl_KdTreeFLANN;
+  __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZI = &__pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZI;
+  __pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZI._nearest_k = (void (*)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZI *, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *, int, int, PyArrayObject *, PyArrayObject *))__pyx_f_3pcl_4_pcl_21KdTreeFLANN_PointXYZI__nearest_k;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZI) < 0) __PYX_ERR(12, 101, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZI.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZI.tp_dict, __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZI) < 0) __PYX_ERR(12, 101, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "KdTreeFLANN_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZI) < 0) __PYX_ERR(12, 101, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZI = &__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZI;
+  __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB = &__pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB;
+  __pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB._nearest_k = (void (*)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB *, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *, int, int, PyArrayObject *, PyArrayObject *))__pyx_f_3pcl_4_pcl_23KdTreeFLANN_PointXYZRGB__nearest_k;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB) < 0) __PYX_ERR(12, 165, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB.tp_dict, __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB) < 0) __PYX_ERR(12, 165, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "KdTreeFLANN_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB) < 0) __PYX_ERR(12, 165, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB = &__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGB;
+  __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA = &__pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA;
+  __pyx_vtable_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA._nearest_k = (void (*)(struct __pyx_obj_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA *, struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *, int, int, PyArrayObject *, PyArrayObject *))__pyx_f_3pcl_4_pcl_24KdTreeFLANN_PointXYZRGBA__nearest_k;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA) < 0) __PYX_ERR(12, 229, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA.tp_dict, __pyx_vtabptr_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA) < 0) __PYX_ERR(12, 229, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "KdTreeFLANN_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA) < 0) __PYX_ERR(12, 229, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_KdTreeFLANN_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud) < 0) __PYX_ERR(13, 7, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud) < 0) __PYX_ERR(13, 7, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud = &__pyx_type_3pcl_4_pcl_OctreePointCloud;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZI) < 0) __PYX_ERR(13, 88, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZI) < 0) __PYX_ERR(13, 88, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZI = &__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGB) < 0) __PYX_ERR(13, 170, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGB) < 0) __PYX_ERR(13, 170, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZRGB = &__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA) < 0) __PYX_ERR(13, 248, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA) < 0) __PYX_ERR(13, 248, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf) < 0) __PYX_ERR(14, 7, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud2Buf", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf) < 0) __PYX_ERR(14, 7, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf = &__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI) < 0) __PYX_ERR(14, 85, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud2Buf_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI) < 0) __PYX_ERR(14, 85, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI = &__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB) < 0) __PYX_ERR(14, 164, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud2Buf_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB) < 0) __PYX_ERR(14, 164, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB = &__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA) < 0) __PYX_ERR(14, 239, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloud2Buf_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA) < 0) __PYX_ERR(14, 239, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA;
+  __pyx_vtabptr_3pcl_4_pcl_OctreePointCloudSearch = &__pyx_vtable_3pcl_4_pcl_OctreePointCloudSearch;
+  __pyx_vtable_3pcl_4_pcl_OctreePointCloudSearch._nearest_k = (void (*)(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, int, int, PyArrayObject *, PyArrayObject *))__pyx_f_3pcl_4_pcl_22OctreePointCloudSearch__nearest_k;
+  __pyx_vtable_3pcl_4_pcl_OctreePointCloudSearch._VoxelSearch = (void (*)(struct __pyx_obj_3pcl_4_pcl_OctreePointCloudSearch *, struct pcl::PointXYZ, std::vector<int>  &))__pyx_f_3pcl_4_pcl_22OctreePointCloudSearch__VoxelSearch;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch) < 0) __PYX_ERR(2, 8, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_OctreePointCloudSearch.tp_dict, __pyx_vtabptr_3pcl_4_pcl_OctreePointCloudSearch) < 0) __PYX_ERR(2, 8, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudSearch", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch) < 0) __PYX_ERR(2, 8, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch = &__pyx_type_3pcl_4_pcl_OctreePointCloudSearch;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI) < 0) __PYX_ERR(2, 224, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudSearch_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI) < 0) __PYX_ERR(2, 224, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI = &__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZI;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB) < 0) __PYX_ERR(2, 305, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudSearch_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB) < 0) __PYX_ERR(2, 305, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB = &__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGB;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA) < 0) __PYX_ERR(2, 387, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudSearch_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA) < 0) __PYX_ERR(2, 387, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_OctreePointCloudSearch_PointXYZRGBA;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector) < 0) __PYX_ERR(15, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudChangeDetector", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector) < 0) __PYX_ERR(15, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector = &__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI) < 0) __PYX_ERR(15, 76, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudChangeDetector_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI) < 0) __PYX_ERR(15, 76, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI = &__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZI;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB) < 0) __PYX_ERR(15, 145, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudChangeDetector_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB) < 0) __PYX_ERR(15, 145, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB = &__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGB;
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA.tp_base = __pyx_ptype_3pcl_4_pcl_OctreePointCloud2Buf_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA) < 0) __PYX_ERR(15, 214, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "OctreePointCloudChangeDetector_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA) < 0) __PYX_ERR(15, 214, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_OctreePointCloudChangeDetector_PointXYZRGBA;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_CropHull) < 0) __PYX_ERR(17, 10, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_CropHull.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "CropHull", (PyObject *)&__pyx_type_3pcl_4_pcl_CropHull) < 0) __PYX_ERR(17, 10, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_CropHull = &__pyx_type_3pcl_4_pcl_CropHull;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_CropBox) < 0) __PYX_ERR(18, 12, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_CropBox.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "CropBox", (PyObject *)&__pyx_type_3pcl_4_pcl_CropBox) < 0) __PYX_ERR(18, 12, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_CropBox = &__pyx_type_3pcl_4_pcl_CropBox;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ProjectInliers) < 0) __PYX_ERR(19, 6, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ProjectInliers.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ProjectInliers", (PyObject *)&__pyx_type_3pcl_4_pcl_ProjectInliers) < 0) __PYX_ERR(19, 6, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ProjectInliers = &__pyx_type_3pcl_4_pcl_ProjectInliers;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_RadiusOutlierRemoval) < 0) __PYX_ERR(20, 9, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_RadiusOutlierRemoval.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "RadiusOutlierRemoval", (PyObject *)&__pyx_type_3pcl_4_pcl_RadiusOutlierRemoval) < 0) __PYX_ERR(20, 9, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_RadiusOutlierRemoval = &__pyx_type_3pcl_4_pcl_RadiusOutlierRemoval;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ConditionAnd) < 0) __PYX_ERR(21, 14, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ConditionAnd.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ConditionAnd", (PyObject *)&__pyx_type_3pcl_4_pcl_ConditionAnd) < 0) __PYX_ERR(21, 14, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ConditionAnd = &__pyx_type_3pcl_4_pcl_ConditionAnd;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ConditionalRemoval) < 0) __PYX_ERR(22, 12, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ConditionalRemoval.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ConditionalRemoval", (PyObject *)&__pyx_type_3pcl_4_pcl_ConditionalRemoval) < 0) __PYX_ERR(22, 12, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ConditionalRemoval = &__pyx_type_3pcl_4_pcl_ConditionalRemoval;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ConcaveHull) < 0) __PYX_ERR(23, 5, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ConcaveHull.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ConcaveHull", (PyObject *)&__pyx_type_3pcl_4_pcl_ConcaveHull) < 0) __PYX_ERR(23, 5, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ConcaveHull = &__pyx_type_3pcl_4_pcl_ConcaveHull;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZI) < 0) __PYX_ERR(23, 27, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZI.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ConcaveHull_PointXYZI", (PyObject *)&__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZI) < 0) __PYX_ERR(23, 27, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ConcaveHull_PointXYZI = &__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZI;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGB) < 0) __PYX_ERR(23, 50, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGB.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ConcaveHull_PointXYZRGB", (PyObject *)&__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGB) < 0) __PYX_ERR(23, 50, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ConcaveHull_PointXYZRGB = &__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGB;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGBA) < 0) __PYX_ERR(23, 73, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGBA.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "ConcaveHull_PointXYZRGBA", (PyObject *)&__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGBA) < 0) __PYX_ERR(23, 73, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_ConcaveHull_PointXYZRGBA = &__pyx_type_3pcl_4_pcl_ConcaveHull_PointXYZRGBA;
+  __pyx_vtabptr_3pcl_4_pcl_GeneralizedIterativeClosestPoint = &__pyx_vtable_3pcl_4_pcl_GeneralizedIterativeClosestPoint;
+  __pyx_vtable_3pcl_4_pcl_GeneralizedIterativeClosestPoint.run = (PyObject *(*)(struct __pyx_obj_3pcl_4_pcl_GeneralizedIterativeClosestPoint *, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_opt_args_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run *__pyx_optional_args))__pyx_f_3pcl_4_pcl_32GeneralizedIterativeClosestPoint_run;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_GeneralizedIterativeClosestPoint) < 0) __PYX_ERR(25, 12, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_GeneralizedIterativeClosestPoint.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_GeneralizedIterativeClosestPoint.tp_dict, __pyx_vtabptr_3pcl_4_pcl_GeneralizedIterativeClosestPoint) < 0) __PYX_ERR(25, 12, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "GeneralizedIterativeClosestPoint", (PyObject *)&__pyx_type_3pcl_4_pcl_GeneralizedIterativeClosestPoint) < 0) __PYX_ERR(25, 12, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_GeneralizedIterativeClosestPoint = &__pyx_type_3pcl_4_pcl_GeneralizedIterativeClosestPoint;
+  __pyx_vtabptr_3pcl_4_pcl_IterativeClosestPoint = &__pyx_vtable_3pcl_4_pcl_IterativeClosestPoint;
+  __pyx_vtable_3pcl_4_pcl_IterativeClosestPoint.run = (PyObject *(*)(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPoint *, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_opt_args_3pcl_4_pcl_21IterativeClosestPoint_run *__pyx_optional_args))__pyx_f_3pcl_4_pcl_21IterativeClosestPoint_run;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_IterativeClosestPoint) < 0) __PYX_ERR(26, 16, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_IterativeClosestPoint.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_IterativeClosestPoint.tp_dict, __pyx_vtabptr_3pcl_4_pcl_IterativeClosestPoint) < 0) __PYX_ERR(26, 16, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "IterativeClosestPoint", (PyObject *)&__pyx_type_3pcl_4_pcl_IterativeClosestPoint) < 0) __PYX_ERR(26, 16, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_IterativeClosestPoint = &__pyx_type_3pcl_4_pcl_IterativeClosestPoint;
+  __pyx_vtabptr_3pcl_4_pcl_IterativeClosestPointNonLinear = &__pyx_vtable_3pcl_4_pcl_IterativeClosestPointNonLinear;
+  __pyx_vtable_3pcl_4_pcl_IterativeClosestPointNonLinear.run = (PyObject *(*)(struct __pyx_obj_3pcl_4_pcl_IterativeClosestPointNonLinear *, pcl::Registration<struct pcl::PointXYZ,struct pcl::PointXYZ,float>  &, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_obj_3pcl_4_pcl_PointCloud *, struct __pyx_opt_args_3pcl_4_pcl_30IterativeClosestPointNonLinear_run *__pyx_optional_args))__pyx_f_3pcl_4_pcl_30IterativeClosestPointNonLinear_run;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_IterativeClosestPointNonLinear) < 0) __PYX_ERR(27, 12, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_IterativeClosestPointNonLinear.tp_print = 0;
+  if (__Pyx_SetVtable(__pyx_type_3pcl_4_pcl_IterativeClosestPointNonLinear.tp_dict, __pyx_vtabptr_3pcl_4_pcl_IterativeClosestPointNonLinear) < 0) __PYX_ERR(27, 12, __pyx_L1_error)
+  if (PyObject_SetAttrString(__pyx_m, "IterativeClosestPointNonLinear", (PyObject *)&__pyx_type_3pcl_4_pcl_IterativeClosestPointNonLinear) < 0) __PYX_ERR(27, 12, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_IterativeClosestPointNonLinear = &__pyx_type_3pcl_4_pcl_IterativeClosestPointNonLinear;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_RandomSampleConsensus) < 0) __PYX_ERR(28, 8, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_RandomSampleConsensus.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "RandomSampleConsensus", (PyObject *)&__pyx_type_3pcl_4_pcl_RandomSampleConsensus) < 0) __PYX_ERR(28, 8, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_RandomSampleConsensus = &__pyx_type_3pcl_4_pcl_RandomSampleConsensus;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_NormalEstimation) < 0) __PYX_ERR(35, 10, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_NormalEstimation.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "NormalEstimation", (PyObject *)&__pyx_type_3pcl_4_pcl_NormalEstimation) < 0) __PYX_ERR(35, 10, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_NormalEstimation = &__pyx_type_3pcl_4_pcl_NormalEstimation;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_VFHEstimation) < 0) __PYX_ERR(36, 10, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_VFHEstimation.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "VFHEstimation", (PyObject *)&__pyx_type_3pcl_4_pcl_VFHEstimation) < 0) __PYX_ERR(36, 10, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_VFHEstimation = &__pyx_type_3pcl_4_pcl_VFHEstimation;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_MomentOfInertiaEstimation) < 0) __PYX_ERR(38, 9, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_MomentOfInertiaEstimation.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "MomentOfInertiaEstimation", (PyObject *)&__pyx_type_3pcl_4_pcl_MomentOfInertiaEstimation) < 0) __PYX_ERR(38, 9, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_MomentOfInertiaEstimation = &__pyx_type_3pcl_4_pcl_MomentOfInertiaEstimation;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_HarrisKeypoint3D) < 0) __PYX_ERR(39, 22, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_HarrisKeypoint3D.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "HarrisKeypoint3D", (PyObject *)&__pyx_type_3pcl_4_pcl_HarrisKeypoint3D) < 0) __PYX_ERR(39, 22, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_HarrisKeypoint3D = &__pyx_type_3pcl_4_pcl_HarrisKeypoint3D;
+  if (PyType_Ready(&__pyx_type_3pcl_4_pcl_NormalDistributionsTransform) < 0) __PYX_ERR(40, 6, __pyx_L1_error)
+  __pyx_type_3pcl_4_pcl_NormalDistributionsTransform.tp_print = 0;
+  if (PyObject_SetAttrString(__pyx_m, "NormalDistributionsTransform", (PyObject *)&__pyx_type_3pcl_4_pcl_NormalDistributionsTransform) < 0) __PYX_ERR(40, 6, __pyx_L1_error)
+  __pyx_ptype_3pcl_4_pcl_NormalDistributionsTransform = &__pyx_type_3pcl_4_pcl_NormalDistributionsTransform;
+  /*--- Type import code ---*/
+  __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", 
+  #if CYTHON_COMPILING_IN_PYPY
+  sizeof(PyTypeObject),
+  #else
+  sizeof(PyHeapTypeObject),
+  #endif
+  0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) __PYX_ERR(49, 9, __pyx_L1_error)
+  __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) __PYX_ERR(50, 8, __pyx_L1_error)
+  __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) __PYX_ERR(51, 15, __pyx_L1_error)
+  __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) __PYX_ERR(46, 155, __pyx_L1_error)
+  __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) __PYX_ERR(46, 168, __pyx_L1_error)
+  __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) __PYX_ERR(46, 172, __pyx_L1_error)
+  __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) __PYX_ERR(46, 181, __pyx_L1_error)
+  __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) __PYX_ERR(46, 861, __pyx_L1_error)
+  /*--- Variable import code ---*/
+  /*--- Function import code ---*/
+  /*--- Execution code ---*/
+  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+  if (__Pyx_patch_abc() < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  #endif
+
+  /* "pcl/_pcl_180.pyx":4
+ * # cython: embedsignature=True
+ * 
+ * from collections import Sequence             # <<<<<<<<<<<<<<
+ * import numbers
+ * import numpy as np
+ */
+  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_INCREF(__pyx_n_s_Sequence);
+  __Pyx_GIVEREF(__pyx_n_s_Sequence);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Sequence);
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Sequence); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Sequence, __pyx_t_1) < 0) __PYX_ERR(4, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":5
+ * 
+ * from collections import Sequence
+ * import numbers             # <<<<<<<<<<<<<<
+ * import numpy as np
+ * cimport numpy as cnp
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numbers, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_numbers, __pyx_t_2) < 0) __PYX_ERR(4, 5, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":6
+ * from collections import Sequence
+ * import numbers
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as cnp
+ * 
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 6, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(4, 6, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":33
+ * from boost_shared_ptr cimport sp_assign
+ * 
+ * cnp.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * ### Enum ###
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(4, 33, __pyx_L1_error)
+
+  /* "pcl/_pcl_180.pyx":38
+ * 
+ * ## Enum Setting
+ * SAC_RANSAC = pcl_sc.SAC_RANSAC             # <<<<<<<<<<<<<<
+ * SAC_LMEDS = pcl_sc.SAC_LMEDS
+ * SAC_MSAC = pcl_sc.SAC_MSAC
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(pcl::SAC_RANSAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 38, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAC_RANSAC, __pyx_t_2) < 0) __PYX_ERR(4, 38, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":39
+ * ## Enum Setting
+ * SAC_RANSAC = pcl_sc.SAC_RANSAC
+ * SAC_LMEDS = pcl_sc.SAC_LMEDS             # <<<<<<<<<<<<<<
+ * SAC_MSAC = pcl_sc.SAC_MSAC
+ * SAC_RRANSAC = pcl_sc.SAC_RRANSAC
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(pcl::SAC_LMEDS); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 39, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAC_LMEDS, __pyx_t_2) < 0) __PYX_ERR(4, 39, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":40
+ * SAC_RANSAC = pcl_sc.SAC_RANSAC
+ * SAC_LMEDS = pcl_sc.SAC_LMEDS
+ * SAC_MSAC = pcl_sc.SAC_MSAC             # <<<<<<<<<<<<<<
+ * SAC_RRANSAC = pcl_sc.SAC_RRANSAC
+ * SAC_RMSAC = pcl_sc.SAC_RMSAC
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(pcl::SAC_MSAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 40, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAC_MSAC, __pyx_t_2) < 0) __PYX_ERR(4, 40, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":41
+ * SAC_LMEDS = pcl_sc.SAC_LMEDS
+ * SAC_MSAC = pcl_sc.SAC_MSAC
+ * SAC_RRANSAC = pcl_sc.SAC_RRANSAC             # <<<<<<<<<<<<<<
+ * SAC_RMSAC = pcl_sc.SAC_RMSAC
+ * SAC_MLESAC = pcl_sc.SAC_MLESAC
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(pcl::SAC_RRANSAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 41, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAC_RRANSAC, __pyx_t_2) < 0) __PYX_ERR(4, 41, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":42
+ * SAC_MSAC = pcl_sc.SAC_MSAC
+ * SAC_RRANSAC = pcl_sc.SAC_RRANSAC
+ * SAC_RMSAC = pcl_sc.SAC_RMSAC             # <<<<<<<<<<<<<<
+ * SAC_MLESAC = pcl_sc.SAC_MLESAC
+ * SAC_PROSAC = pcl_sc.SAC_PROSAC
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(pcl::SAC_RMSAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 42, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAC_RMSAC, __pyx_t_2) < 0) __PYX_ERR(4, 42, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":43
+ * SAC_RRANSAC = pcl_sc.SAC_RRANSAC
+ * SAC_RMSAC = pcl_sc.SAC_RMSAC
+ * SAC_MLESAC = pcl_sc.SAC_MLESAC             # <<<<<<<<<<<<<<
+ * SAC_PROSAC = pcl_sc.SAC_PROSAC
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(pcl::SAC_MLESAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 43, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAC_MLESAC, __pyx_t_2) < 0) __PYX_ERR(4, 43, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":44
+ * SAC_RMSAC = pcl_sc.SAC_RMSAC
+ * SAC_MLESAC = pcl_sc.SAC_MLESAC
+ * SAC_PROSAC = pcl_sc.SAC_PROSAC             # <<<<<<<<<<<<<<
+ * 
+ * SACMODEL_PLANE = pcl_sc.SACMODEL_PLANE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_int(pcl::SAC_PROSAC); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SAC_PROSAC, __pyx_t_2) < 0) __PYX_ERR(4, 44, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":46
+ * SAC_PROSAC = pcl_sc.SAC_PROSAC
+ * 
+ * SACMODEL_PLANE = pcl_sc.SACMODEL_PLANE             # <<<<<<<<<<<<<<
+ * SACMODEL_LINE = pcl_sc.SACMODEL_LINE
+ * SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_PLANE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 46, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_PLANE, __pyx_t_2) < 0) __PYX_ERR(4, 46, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":47
+ * 
+ * SACMODEL_PLANE = pcl_sc.SACMODEL_PLANE
+ * SACMODEL_LINE = pcl_sc.SACMODEL_LINE             # <<<<<<<<<<<<<<
+ * SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D
+ * SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_LINE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 47, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_LINE, __pyx_t_2) < 0) __PYX_ERR(4, 47, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":48
+ * SACMODEL_PLANE = pcl_sc.SACMODEL_PLANE
+ * SACMODEL_LINE = pcl_sc.SACMODEL_LINE
+ * SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D             # <<<<<<<<<<<<<<
+ * SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D
+ * SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_CIRCLE2D); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 48, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_CIRCLE2D, __pyx_t_2) < 0) __PYX_ERR(4, 48, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":49
+ * SACMODEL_LINE = pcl_sc.SACMODEL_LINE
+ * SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D
+ * SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D             # <<<<<<<<<<<<<<
+ * SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE
+ * SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_CIRCLE3D); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 49, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_CIRCLE3D, __pyx_t_2) < 0) __PYX_ERR(4, 49, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":50
+ * SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D
+ * SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D
+ * SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE             # <<<<<<<<<<<<<<
+ * SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER
+ * SACMODEL_CONE = pcl_sc.SACMODEL_CONE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_SPHERE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 50, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_SPHERE, __pyx_t_2) < 0) __PYX_ERR(4, 50, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":51
+ * SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D
+ * SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE
+ * SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER             # <<<<<<<<<<<<<<
+ * SACMODEL_CONE = pcl_sc.SACMODEL_CONE
+ * SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_CYLINDER); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 51, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_CYLINDER, __pyx_t_2) < 0) __PYX_ERR(4, 51, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":52
+ * SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE
+ * SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER
+ * SACMODEL_CONE = pcl_sc.SACMODEL_CONE             # <<<<<<<<<<<<<<
+ * SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS
+ * SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_CONE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 52, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_CONE, __pyx_t_2) < 0) __PYX_ERR(4, 52, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":53
+ * SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER
+ * SACMODEL_CONE = pcl_sc.SACMODEL_CONE
+ * SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS             # <<<<<<<<<<<<<<
+ * SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE
+ * SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_TORUS); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 53, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_TORUS, __pyx_t_2) < 0) __PYX_ERR(4, 53, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":54
+ * SACMODEL_CONE = pcl_sc.SACMODEL_CONE
+ * SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS
+ * SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE             # <<<<<<<<<<<<<<
+ * SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE
+ * SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_PARALLEL_LINE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 54, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_PARALLEL_LINE, __pyx_t_2) < 0) __PYX_ERR(4, 54, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":55
+ * SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS
+ * SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE
+ * SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE             # <<<<<<<<<<<<<<
+ * SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES
+ * SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_PERPENDICULAR_PLANE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 55, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_PERPENDICULAR_PLANE, __pyx_t_2) < 0) __PYX_ERR(4, 55, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":56
+ * SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE
+ * SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE
+ * SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES             # <<<<<<<<<<<<<<
+ * SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE
+ * SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_PARALLEL_LINES); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 56, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_PARALLEL_LINES, __pyx_t_2) < 0) __PYX_ERR(4, 56, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":57
+ * SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE
+ * SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES
+ * SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE             # <<<<<<<<<<<<<<
+ * SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE
+ * SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_NORMAL_PLANE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 57, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_NORMAL_PLANE, __pyx_t_2) < 0) __PYX_ERR(4, 57, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":58
+ * SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES
+ * SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE
+ * SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE             # <<<<<<<<<<<<<<
+ * SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION
+ * SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_NORMAL_SPHERE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 58, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_NORMAL_SPHERE, __pyx_t_2) < 0) __PYX_ERR(4, 58, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":59
+ * SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE
+ * SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE
+ * SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION             # <<<<<<<<<<<<<<
+ * SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE
+ * SACMODEL_NORMAL_PARALLEL_PLANE = pcl_sc.SACMODEL_NORMAL_PARALLEL_PLANE
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_REGISTRATION); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 59, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_REGISTRATION, __pyx_t_2) < 0) __PYX_ERR(4, 59, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":60
+ * SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE
+ * SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION
+ * SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE             # <<<<<<<<<<<<<<
+ * SACMODEL_NORMAL_PARALLEL_PLANE = pcl_sc.SACMODEL_NORMAL_PARALLEL_PLANE
+ * SACMODEL_STICK = pcl_sc.SACMODEL_STICK
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_PARALLEL_PLANE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 60, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_PARALLEL_PLANE, __pyx_t_2) < 0) __PYX_ERR(4, 60, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":61
+ * SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION
+ * SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE
+ * SACMODEL_NORMAL_PARALLEL_PLANE = pcl_sc.SACMODEL_NORMAL_PARALLEL_PLANE             # <<<<<<<<<<<<<<
+ * SACMODEL_STICK = pcl_sc.SACMODEL_STICK
+ * 
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_NORMAL_PARALLEL_PLANE); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 61, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_NORMAL_PARALLEL_PLANE, __pyx_t_2) < 0) __PYX_ERR(4, 61, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":62
+ * SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE
+ * SACMODEL_NORMAL_PARALLEL_PLANE = pcl_sc.SACMODEL_NORMAL_PARALLEL_PLANE
+ * SACMODEL_STICK = pcl_sc.SACMODEL_STICK             # <<<<<<<<<<<<<<
+ * 
+ * ### Enum Setting(define Class InternalType) ###
+ */
+  __pyx_t_2 = __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(pcl::SACMODEL_STICK); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 62, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_SACMODEL_STICK, __pyx_t_2) < 0) __PYX_ERR(4, 62, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":84
+ *         self.EQ = pcl_fil.COMPAREOP_EQ
+ * 
+ * CythonCompareOp_Type = _CythonCompareOp_Type()             # <<<<<<<<<<<<<<
+ * 
+ * # RangeImage
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl__CythonCompareOp_Type), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 84, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CythonCompareOp_Type, __pyx_t_2) < 0) __PYX_ERR(4, 84, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":98
+ *         self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER
+ * 
+ * CythonCoordinateFrame_Type = _CythonCoordinateFrame_Type()             # <<<<<<<<<<<<<<
+ * 
+ * # # features
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl__CythonCoordinateFrame_Type), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 98, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_CythonCoordinateFrame_Type, __pyx_t_2) < 0) __PYX_ERR(4, 98, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":1
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * 
+ * cimport _pcl
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(25, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(25, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi":10
+ * from eigen cimport Matrix4f
+ * 
+ * np.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class GeneralizedIterativeClosestPoint:
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(25, 10, __pyx_L1_error)
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":5
+ * 
+ * cimport numpy as np
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * 
+ * cimport _pcl
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(26, 5, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(26, 5, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/registration/IterativeClosestPoint_180.pxi":14
+ * from eigen cimport Matrix4f
+ * 
+ * np.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class IterativeClosestPoint:
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(26, 14, __pyx_L1_error)
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":1
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * 
+ * cimport _pcl
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(27, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(27, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi":10
+ * from eigen cimport Matrix4f
+ * 
+ * np.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * cdef class IterativeClosestPointNonLinear:
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(27, 10, __pyx_L1_error)
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":4
+ * # main
+ * cimport pcl_defs as cpp
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as cnp
+ * 
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 4, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(3, 4, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":7
+ * cimport numpy as cnp
+ * 
+ * cnp.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * # parts
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(3, 7, __pyx_L1_error)
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":44
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides[2]
+ * cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],             # <<<<<<<<<<<<<<
+ *                                                [4, 5, 6]], dtype=np.float32))
+ * 
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_int_1);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_int_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyList_SET_ITEM(__pyx_t_2, 2, __pyx_int_3);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":45
+ * cdef Py_ssize_t _strides[2]
+ * cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],
+ *                                                [4, 5, 6]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * 
+ * cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()
+ */
+  __pyx_t_4 = PyList_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_int_4);
+  __Pyx_INCREF(__pyx_int_5);
+  __Pyx_GIVEREF(__pyx_int_5);
+  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_int_5);
+  __Pyx_INCREF(__pyx_int_6);
+  __Pyx_GIVEREF(__pyx_int_6);
+  PyList_SET_ITEM(__pyx_t_4, 2, __pyx_int_6);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":44
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides[2]
+ * cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],             # <<<<<<<<<<<<<<
+ *                                                [4, 5, 6]], dtype=np.float32))
+ * 
+ */
+  __pyx_t_5 = PyList_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_2 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":45
+ * cdef Py_ssize_t _strides[2]
+ * cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],
+ *                                                [4, 5, 6]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * 
+ * cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 45, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(3, 45, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":44
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides[2]
+ * cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],             # <<<<<<<<<<<<<<
+ *                                                [4, 5, 6]], dtype=np.float32))
+ * 
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud), __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 44, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_tmp));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_tmp, ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)__pyx_t_6));
+  __Pyx_GIVEREF(__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":47
+ *                                                [4, 5, 6]], dtype=np.float32))
+ * 
+ * cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()             # <<<<<<<<<<<<<<
+ * _strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p, 0))
+ */
+  __pyx_v_3pcl_4_pcl_p = __pyx_f_3pcl_4_pcl_10PointCloud_thisptr(__pyx_v_3pcl_4_pcl__pc_tmp);
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":48
+ * 
+ * cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()
+ * _strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>idx.getptr(p, 0))
+ * _strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)
+ */
+  (__pyx_v_3pcl_4_pcl__strides[0]) = (((Py_ssize_t)((void *)getptr<struct pcl::PointXYZ>(__pyx_v_3pcl_4_pcl_p, 1))) - ((Py_ssize_t)((void *)getptr<struct pcl::PointXYZ>(__pyx_v_3pcl_4_pcl_p, 0))));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":50
+ * _strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p, 0))
+ * _strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>&(idx.getptr(p, 0).x))
+ * _pc_tmp = None
+ */
+  (__pyx_v_3pcl_4_pcl__strides[1]) = (((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZ>(__pyx_v_3pcl_4_pcl_p, 0)->y))) - ((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZ>(__pyx_v_3pcl_4_pcl_p, 0)->x))));
+
+  /* "pcl/pxi/PointCloud_PointXYZ_180.pxi":52
+ * _strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)
+ *                - <Py_ssize_t><void *>&(idx.getptr(p, 0).x))
+ * _pc_tmp = None             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PointCloud:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_tmp));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_tmp, ((struct __pyx_obj_3pcl_4_pcl_PointCloud *)Py_None));
+  __Pyx_GIVEREF(Py_None);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":3
+ * # -*- coding: utf-8 -*-
+ * cimport pcl_defs as cpp
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as cnp
+ * 
+ */
+  __pyx_t_6 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_6) < 0) __PYX_ERR(41, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":6
+ * cimport numpy as cnp
+ * 
+ * cnp.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * # parts
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(41, 6, __pyx_L1_error)
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzi_4[2]
+ * cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                     [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = PyList_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyList_SET_ITEM(__pyx_t_6, 0, __pyx_int_1);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyList_SET_ITEM(__pyx_t_6, 1, __pyx_int_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyList_SET_ITEM(__pyx_t_6, 2, __pyx_int_3);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyList_SET_ITEM(__pyx_t_6, 3, __pyx_int_0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":37
+ * cdef Py_ssize_t _strides_xyzi_4[2]
+ * cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],
+ *                                                                     [4, 5, 6, 0]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+ * _strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)
+ */
+  __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_int_4);
+  __Pyx_INCREF(__pyx_int_5);
+  __Pyx_GIVEREF(__pyx_int_5);
+  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_int_5);
+  __Pyx_INCREF(__pyx_int_6);
+  __Pyx_GIVEREF(__pyx_int_6);
+  PyList_SET_ITEM(__pyx_t_4, 2, __pyx_int_6);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyList_SET_ITEM(__pyx_t_4, 3, __pyx_int_0);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzi_4[2]
+ * cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                     [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+ */
+  __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":37
+ * cdef Py_ssize_t _strides_xyzi_4[2]
+ * cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],
+ *                                                                     [4, 5, 6, 0]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+ * _strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)
+ */
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(41, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(41, 37, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzi_4[2]
+ * cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                     [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(41, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_xyzi_tmp4));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_xyzi_tmp4, ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)__pyx_t_2));
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":38
+ * cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],
+ *                                                                     [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()             # <<<<<<<<<<<<<<
+ * _strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 0))
+ */
+  __pyx_v_3pcl_4_pcl_p_xyzi_4 = __pyx_f_3pcl_4_pcl_20PointCloud_PointXYZI_thisptr(__pyx_v_3pcl_4_pcl__pc_xyzi_tmp4);
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":39
+ *                                                                     [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+ * _strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 0))
+ * _strides_xyzi_4[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).y)
+ */
+  (__pyx_v_3pcl_4_pcl__strides_xyzi_4[0]) = (((Py_ssize_t)((void *)getptr<struct pcl::PointXYZI>(__pyx_v_3pcl_4_pcl_p_xyzi_4, 1))) - ((Py_ssize_t)((void *)getptr<struct pcl::PointXYZI>(__pyx_v_3pcl_4_pcl_p_xyzi_4, 0))));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":41
+ * _strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 0))
+ * _strides_xyzi_4[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).y)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).x))
+ * _pc_xyzi_tmp4 = None
+ */
+  (__pyx_v_3pcl_4_pcl__strides_xyzi_4[1]) = (((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZI>(__pyx_v_3pcl_4_pcl_p_xyzi_4, 0)->y))) - ((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZI>(__pyx_v_3pcl_4_pcl_p_xyzi_4, 0)->x))));
+
+  /* "pcl/pxi/PointCloud_PointXYZI_180.pxi":43
+ * _strides_xyzi_4[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).y)
+ *                - <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).x))
+ * _pc_xyzi_tmp4 = None             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PointCloud_PointXYZI:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_xyzi_tmp4));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_xyzi_tmp4, ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZI *)Py_None));
+  __Pyx_GIVEREF(Py_None);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":3
+ * # -*- coding: utf-8 -*-
+ * cimport pcl_defs as cpp
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as cnp
+ * 
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(42, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":6
+ * cimport numpy as cnp
+ * 
+ * cnp.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * # parts
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(42, 6, __pyx_L1_error)
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzrgb_3[2]
+ * cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+ */
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  __pyx_t_2 = PyList_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyList_SET_ITEM(__pyx_t_2, 0, __pyx_int_1);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyList_SET_ITEM(__pyx_t_2, 1, __pyx_int_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyList_SET_ITEM(__pyx_t_2, 2, __pyx_int_3);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyList_SET_ITEM(__pyx_t_2, 3, __pyx_int_0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":37
+ * cdef Py_ssize_t _strides_xyzrgb_3[2]
+ * cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+ * _strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)
+ */
+  __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_int_4);
+  __Pyx_INCREF(__pyx_int_5);
+  __Pyx_GIVEREF(__pyx_int_5);
+  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_int_5);
+  __Pyx_INCREF(__pyx_int_6);
+  __Pyx_GIVEREF(__pyx_int_6);
+  PyList_SET_ITEM(__pyx_t_4, 2, __pyx_int_6);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyList_SET_ITEM(__pyx_t_4, 3, __pyx_int_0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzrgb_3[2]
+ * cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+ */
+  __pyx_t_5 = PyList_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+  __pyx_t_2 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_5);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
+  __pyx_t_5 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":37
+ * cdef Py_ssize_t _strides_xyzrgb_3[2]
+ * cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+ * _strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)
+ */
+  __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(42, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+  if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_dtype, __pyx_t_6) < 0) __PYX_ERR(42, 37, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzrgb_3[2]
+ * cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+ */
+  __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6);
+  __pyx_t_6 = 0;
+  __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB), __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(42, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_xyzrgb_tmp3));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_xyzrgb_tmp3, ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)__pyx_t_6));
+  __Pyx_GIVEREF(__pyx_t_6);
+  __pyx_t_6 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":38
+ * cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()             # <<<<<<<<<<<<<<
+ * _strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 0))
+ */
+  __pyx_v_3pcl_4_pcl_p_xyzrgb_3 = __pyx_f_3pcl_4_pcl_22PointCloud_PointXYZRGB_thisptr(__pyx_v_3pcl_4_pcl__pc_xyzrgb_tmp3);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":39
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+ * _strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 0))
+ * _strides_xyzrgb_3[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).y)
+ */
+  (__pyx_v_3pcl_4_pcl__strides_xyzrgb_3[0]) = (((Py_ssize_t)((void *)getptr<struct pcl::PointXYZRGB>(__pyx_v_3pcl_4_pcl_p_xyzrgb_3, 1))) - ((Py_ssize_t)((void *)getptr<struct pcl::PointXYZRGB>(__pyx_v_3pcl_4_pcl_p_xyzrgb_3, 0))));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":41
+ * _strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 0))
+ * _strides_xyzrgb_3[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).y)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).x))
+ * _pc_xyzrgb_tmp3 = None
+ */
+  (__pyx_v_3pcl_4_pcl__strides_xyzrgb_3[1]) = (((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZRGB>(__pyx_v_3pcl_4_pcl_p_xyzrgb_3, 0)->y))) - ((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZRGB>(__pyx_v_3pcl_4_pcl_p_xyzrgb_3, 0)->x))));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGB_180.pxi":43
+ * _strides_xyzrgb_3[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).y)
+ *                - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).x))
+ * _pc_xyzrgb_tmp3 = None             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PointCloud_PointXYZRGB:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_xyzrgb_tmp3));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_xyzrgb_tmp3, ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGB *)Py_None));
+  __Pyx_GIVEREF(Py_None);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":3
+ * # -*- coding: utf-8 -*-
+ * cimport pcl_defs as cpp
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as cnp
+ * 
+ */
+  __pyx_t_6 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_6) < 0) __PYX_ERR(43, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":6
+ * cimport numpy as cnp
+ * 
+ * cnp.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * # parts
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(43, 6, __pyx_L1_error)
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzrgba_2[2]
+ * cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+ */
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_5);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  __pyx_t_6 = PyList_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __Pyx_INCREF(__pyx_int_1);
+  __Pyx_GIVEREF(__pyx_int_1);
+  PyList_SET_ITEM(__pyx_t_6, 0, __pyx_int_1);
+  __Pyx_INCREF(__pyx_int_2);
+  __Pyx_GIVEREF(__pyx_int_2);
+  PyList_SET_ITEM(__pyx_t_6, 1, __pyx_int_2);
+  __Pyx_INCREF(__pyx_int_3);
+  __Pyx_GIVEREF(__pyx_int_3);
+  PyList_SET_ITEM(__pyx_t_6, 2, __pyx_int_3);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyList_SET_ITEM(__pyx_t_6, 3, __pyx_int_0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":37
+ * cdef Py_ssize_t _strides_xyzrgba_2[2]
+ * cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+ * _strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)
+ */
+  __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_INCREF(__pyx_int_4);
+  __Pyx_GIVEREF(__pyx_int_4);
+  PyList_SET_ITEM(__pyx_t_4, 0, __pyx_int_4);
+  __Pyx_INCREF(__pyx_int_5);
+  __Pyx_GIVEREF(__pyx_int_5);
+  PyList_SET_ITEM(__pyx_t_4, 1, __pyx_int_5);
+  __Pyx_INCREF(__pyx_int_6);
+  __Pyx_GIVEREF(__pyx_int_6);
+  PyList_SET_ITEM(__pyx_t_4, 2, __pyx_int_6);
+  __Pyx_INCREF(__pyx_int_0);
+  __Pyx_GIVEREF(__pyx_int_0);
+  PyList_SET_ITEM(__pyx_t_4, 3, __pyx_int_0);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzrgba_2[2]
+ * cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+ */
+  __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_6);
+  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
+  __Pyx_GIVEREF(__pyx_t_4);
+  PyList_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
+  __pyx_t_6 = 0;
+  __pyx_t_4 = 0;
+  __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_4);
+  __Pyx_GIVEREF(__pyx_t_1);
+  PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
+  __pyx_t_1 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":37
+ * cdef Py_ssize_t _strides_xyzrgba_2[2]
+ * cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))             # <<<<<<<<<<<<<<
+ * cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+ * _strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)
+ */
+  __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(43, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_6);
+  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_float32); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 37, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(43, 37, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":36
+ * # XXX Is there a more elegant way to get these?
+ * cdef Py_ssize_t _strides_xyzrgba_2[2]
+ * cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],             # <<<<<<<<<<<<<<
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+ */
+  __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_1);
+  __Pyx_GIVEREF(__pyx_t_2);
+  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
+  __pyx_t_2 = 0;
+  __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(43, 36, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_xyzrgba_tmp2));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_xyzrgba_tmp2, ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)__pyx_t_2));
+  __Pyx_GIVEREF(__pyx_t_2);
+  __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":38
+ * cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()             # <<<<<<<<<<<<<<
+ * _strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 0))
+ */
+  __pyx_v_3pcl_4_pcl_p_xyzrgba_2 = __pyx_f_3pcl_4_pcl_23PointCloud_PointXYZRGBA_thisptr(__pyx_v_3pcl_4_pcl__pc_xyzrgba_tmp2);
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":39
+ *                                                                           [4, 5, 6, 0]], dtype=np.float32))
+ * cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+ * _strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 0))
+ * _strides_xyzrgba_2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).y)
+ */
+  (__pyx_v_3pcl_4_pcl__strides_xyzrgba_2[0]) = (((Py_ssize_t)((void *)getptr<struct pcl::PointXYZRGBA>(__pyx_v_3pcl_4_pcl_p_xyzrgba_2, 1))) - ((Py_ssize_t)((void *)getptr<struct pcl::PointXYZRGBA>(__pyx_v_3pcl_4_pcl_p_xyzrgba_2, 0))));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":41
+ * _strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)
+ *                - <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 0))
+ * _strides_xyzrgba_2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).y)             # <<<<<<<<<<<<<<
+ *                - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).x))
+ * _pc_xyzrgba_tmp2 = None
+ */
+  (__pyx_v_3pcl_4_pcl__strides_xyzrgba_2[1]) = (((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZRGBA>(__pyx_v_3pcl_4_pcl_p_xyzrgba_2, 0)->y))) - ((Py_ssize_t)((void *)(&getptr<struct pcl::PointXYZRGBA>(__pyx_v_3pcl_4_pcl_p_xyzrgba_2, 0)->x))));
+
+  /* "pcl/pxi/PointCloud_PointXYZRGBA_180.pxi":43
+ * _strides_xyzrgba_2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).y)
+ *                - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).x))
+ * _pc_xyzrgba_tmp2 = None             # <<<<<<<<<<<<<<
+ * 
+ * cdef class PointCloud_PointXYZRGBA:
+ */
+  __Pyx_INCREF(Py_None);
+  __Pyx_XGOTREF(((PyObject *)__pyx_v_3pcl_4_pcl__pc_xyzrgba_tmp2));
+  __Pyx_DECREF_SET(__pyx_v_3pcl_4_pcl__pc_xyzrgba_tmp2, ((struct __pyx_obj_3pcl_4_pcl_PointCloud_PointXYZRGBA *)Py_None));
+  __Pyx_GIVEREF(Py_None);
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":3
+ * # -*- coding: utf-8 -*-
+ * cimport pcl_defs as cpp
+ * import numpy as np             # <<<<<<<<<<<<<<
+ * cimport numpy as cnp
+ * 
+ */
+  __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(45, 3, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) __PYX_ERR(45, 3, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/pxi/PointCloud_PointNormal.pxi":6
+ * cimport numpy as cnp
+ * 
+ * cnp.import_array()             # <<<<<<<<<<<<<<
+ * 
+ * from libcpp cimport bool
+ */
+  __pyx_t_3 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(45, 6, __pyx_L1_error)
+
+  /* "pcl/_pcl_180.pyx":146
+ * 
+ * ### common ###
+ * def deg2rad(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3pcl_4_pcl_1deg2rad, NULL, __pyx_n_s_pcl__pcl); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 146, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_deg2rad, __pyx_t_2) < 0) __PYX_ERR(4, 146, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":149
+ *     return pcl_cmn.deg2rad(alpha)
+ * 
+ * def rad2deg(float alpha):             # <<<<<<<<<<<<<<
+ *     return pcl_cmn.rad2deg(alpha)
+ * 
+ */
+  __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_3pcl_4_pcl_3rad2deg, NULL, __pyx_n_s_pcl__pcl); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 149, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_rad2deg, __pyx_t_2) < 0) __PYX_ERR(4, 149, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "pcl/_pcl_180.pyx":1
+ * # -*- coding: utf-8 -*-             # <<<<<<<<<<<<<<
+ * # cython: embedsignature=True
+ * 
+ */
+  __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(4, 1, __pyx_L1_error)
+  __Pyx_GOTREF(__pyx_t_2);
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(4, 1, __pyx_L1_error)
+  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+  /* "vector.to_py":67
+ * 
+ * @cname("__pyx_convert_vector_to_py_float")
+ * cdef object __pyx_convert_vector_to_py_float(vector[X]& v):             # <<<<<<<<<<<<<<
+ *     return [X_to_py(v[i]) for i in range(v.size())]
+ * 
+ */
+
+  /*--- Wrapped vars code ---*/
+
+  goto __pyx_L0;
+  __pyx_L1_error:;
+  __Pyx_XDECREF(__pyx_t_1);
+  __Pyx_XDECREF(__pyx_t_2);
+  __Pyx_XDECREF(__pyx_t_4);
+  __Pyx_XDECREF(__pyx_t_5);
+  __Pyx_XDECREF(__pyx_t_6);
+  if (__pyx_m) {
+    if (__pyx_d) {
+      __Pyx_AddTraceback("init pcl._pcl", __pyx_clineno, __pyx_lineno, __pyx_filename);
+    }
+    Py_DECREF(__pyx_m); __pyx_m = 0;
+  } else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_ImportError, "init pcl._pcl");
+  }
+  __pyx_L0:;
+  __Pyx_RefNannyFinishContext();
+  #if PY_MAJOR_VERSION < 3
+  return;
+  #else
+  return __pyx_m;
+  #endif
+}
+
+/* --- Runtime support code --- */
+/* Refnanny */
+#if CYTHON_REFNANNY
+static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
+    PyObject *m = NULL, *p = NULL;
+    void *r = NULL;
+    m = PyImport_ImportModule((char *)modname);
+    if (!m) goto end;
+    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
+    if (!p) goto end;
+    r = PyLong_AsVoidPtr(p);
+end:
+    Py_XDECREF(p);
+    Py_XDECREF(m);
+    return (__Pyx_RefNannyAPIStruct *)r;
+}
+#endif
+
+/* GetBuiltinName */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
+    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
+    if (unlikely(!result)) {
+        PyErr_Format(PyExc_NameError,
+#if PY_MAJOR_VERSION >= 3
+            "name '%U' is not defined", name);
+#else
+            "name '%.200s' is not defined", PyString_AS_STRING(name));
+#endif
+    }
+    return result;
+}
+
+/* RaiseArgTupleInvalid */
+static void __Pyx_RaiseArgtupleInvalid(
+    const char* func_name,
+    int exact,
+    Py_ssize_t num_min,
+    Py_ssize_t num_max,
+    Py_ssize_t num_found)
+{
+    Py_ssize_t num_expected;
+    const char *more_or_less;
+    if (num_found < num_min) {
+        num_expected = num_min;
+        more_or_less = "at least";
+    } else {
+        num_expected = num_max;
+        more_or_less = "at most";
+    }
+    if (exact) {
+        more_or_less = "exactly";
+    }
+    PyErr_Format(PyExc_TypeError,
+                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
+                 func_name, more_or_less, num_expected,
+                 (num_expected == 1) ? "" : "s", num_found);
+}
+
+/* KeywordStringCheck */
+static CYTHON_INLINE int __Pyx_CheckKeywordStrings(
+    PyObject *kwdict,
+    const char* function_name,
+    int kw_allowed)
+{
+    PyObject* key = 0;
+    Py_ssize_t pos = 0;
+#if CYTHON_COMPILING_IN_PYPY
+    if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0))
+        goto invalid_keyword;
+    return 1;
+#else
+    while (PyDict_Next(kwdict, &pos, &key, 0)) {
+        #if PY_MAJOR_VERSION < 3
+        if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key)))
+        #endif
+            if (unlikely(!PyUnicode_Check(key)))
+                goto invalid_keyword_type;
+    }
+    if ((!kw_allowed) && unlikely(key))
+        goto invalid_keyword;
+    return 1;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    return 0;
+#endif
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+    return 0;
+}
+
+/* GetModuleGlobalName */
+static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
+    PyObject *result;
+#if !CYTHON_AVOID_BORROWED_REFS
+    result = PyDict_GetItem(__pyx_d, name);
+    if (likely(result)) {
+        Py_INCREF(result);
+    } else {
+#else
+    result = PyObject_GetItem(__pyx_d, name);
+    if (!result) {
+        PyErr_Clear();
+#endif
+        result = __Pyx_GetBuiltinName(name);
+    }
+    return result;
+}
+
+/* GetItemInt */
+  static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+    PyObject *r;
+    if (!j) return NULL;
+    r = PyObject_GetItem(o, j);
+    Py_DECREF(j);
+    return r;
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o);
+    if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) {
+        PyObject *r = PyList_GET_ITEM(o, i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+                                                              CYTHON_NCP_UNUSED int wraparound,
+                                                              CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o);
+    if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) {
+        PyObject *r = PyTuple_GET_ITEM(o, i);
+        Py_INCREF(r);
+        return r;
+    }
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+#else
+    return PySequence_GetItem(o, i);
+#endif
+}
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
+                                                     CYTHON_NCP_UNUSED int wraparound,
+                                                     CYTHON_NCP_UNUSED int boundscheck) {
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
+    if (is_list || PyList_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
+        if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) {
+            PyObject *r = PyList_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    }
+    else if (PyTuple_CheckExact(o)) {
+        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
+        if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
+            PyObject *r = PyTuple_GET_ITEM(o, n);
+            Py_INCREF(r);
+            return r;
+        }
+    } else {
+        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
+        if (likely(m && m->sq_item)) {
+            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
+                Py_ssize_t l = m->sq_length(o);
+                if (likely(l >= 0)) {
+                    i += l;
+                } else {
+                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
+                        return NULL;
+                    PyErr_Clear();
+                }
+            }
+            return m->sq_item(o, i);
+        }
+    }
+#else
+    if (is_list || PySequence_Check(o)) {
+        return PySequence_GetItem(o, i);
+    }
+#endif
+    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
+}
+
+/* PyCFunctionFastCall */
+  #if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
+    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
+    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
+    PyObject *self = PyCFunction_GET_SELF(func);
+    assert(PyCFunction_Check(func));
+    assert(METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)));
+    assert(nargs >= 0);
+    assert(nargs == 0 || args != NULL);
+    /* _PyCFunction_FastCallDict() must not be called with an exception set,
+       because it may clear it (directly or indirectly) and so the
+       caller loses its exception */
+    assert(!PyErr_Occurred());
+    return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs, NULL);
+}
+#endif  // CYTHON_FAST_PYCCALL
+
+/* PyFunctionFastCall */
+  #if CYTHON_FAST_PYCALL
+#include "frameobject.h"
+static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
+                                               PyObject *globals) {
+    PyFrameObject *f;
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject **fastlocals;
+    Py_ssize_t i;
+    PyObject *result;
+    assert(globals != NULL);
+    /* XXX Perhaps we should create a specialized
+       PyFrame_New() that doesn't take locals, but does
+       take builtins without sanity checking them.
+       */
+    assert(tstate != NULL);
+    f = PyFrame_New(tstate, co, globals, NULL);
+    if (f == NULL) {
+        return NULL;
+    }
+    fastlocals = f->f_localsplus;
+    for (i = 0; i < na; i++) {
+        Py_INCREF(*args);
+        fastlocals[i] = *args++;
+    }
+    result = PyEval_EvalFrameEx(f,0);
+    ++tstate->recursion_depth;
+    Py_DECREF(f);
+    --tstate->recursion_depth;
+    return result;
+}
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) {
+    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
+    PyObject *globals = PyFunction_GET_GLOBALS(func);
+    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
+    PyObject *closure;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *kwdefs;
+#endif
+    PyObject *kwtuple, **k;
+    PyObject **d;
+    Py_ssize_t nd;
+    Py_ssize_t nk;
+    PyObject *result;
+    assert(kwargs == NULL || PyDict_Check(kwargs));
+    nk = kwargs ? PyDict_Size(kwargs) : 0;
+    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
+        return NULL;
+    }
+    if (
+#if PY_MAJOR_VERSION >= 3
+            co->co_kwonlyargcount == 0 &&
+#endif
+            likely(kwargs == NULL || nk == 0) &&
+            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
+        if (argdefs == NULL && co->co_argcount == nargs) {
+            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
+            goto done;
+        }
+        else if (nargs == 0 && argdefs != NULL
+                 && co->co_argcount == Py_SIZE(argdefs)) {
+            /* function called with no arguments, but all parameters have
+               a default value: use default values as arguments .*/
+            args = &PyTuple_GET_ITEM(argdefs, 0);
+            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
+            goto done;
+        }
+    }
+    if (kwargs != NULL) {
+        Py_ssize_t pos, i;
+        kwtuple = PyTuple_New(2 * nk);
+        if (kwtuple == NULL) {
+            result = NULL;
+            goto done;
+        }
+        k = &PyTuple_GET_ITEM(kwtuple, 0);
+        pos = i = 0;
+        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
+            Py_INCREF(k[i]);
+            Py_INCREF(k[i+1]);
+            i += 2;
+        }
+        nk = i / 2;
+    }
+    else {
+        kwtuple = NULL;
+        k = NULL;
+    }
+    closure = PyFunction_GET_CLOSURE(func);
+#if PY_MAJOR_VERSION >= 3
+    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
+#endif
+    if (argdefs != NULL) {
+        d = &PyTuple_GET_ITEM(argdefs, 0);
+        nd = Py_SIZE(argdefs);
+    }
+    else {
+        d = NULL;
+        nd = 0;
+    }
+#if PY_MAJOR_VERSION >= 3
+    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
+                               args, nargs,
+                               k, (int)nk,
+                               d, (int)nd, kwdefs, closure);
+#else
+    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
+                               args, nargs,
+                               k, (int)nk,
+                               d, (int)nd, closure);
+#endif
+    Py_XDECREF(kwtuple);
+done:
+    Py_LeaveRecursiveCall();
+    return result;
+}
+#endif  // CPython < 3.6
+#endif  // CYTHON_FAST_PYCALL
+
+/* PyObjectCall */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
+    PyObject *result;
+    ternaryfunc call = func->ob_type->tp_call;
+    if (unlikely(!call))
+        return PyObject_Call(func, arg, kw);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = (*call)(func, arg, kw);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallMethO */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
+    PyObject *self, *result;
+    PyCFunction cfunc;
+    cfunc = PyCFunction_GET_FUNCTION(func);
+    self = PyCFunction_GET_SELF(func);
+    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
+        return NULL;
+    result = cfunc(self, arg);
+    Py_LeaveRecursiveCall();
+    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
+        PyErr_SetString(
+            PyExc_SystemError,
+            "NULL result without error in PyObject_Call");
+    }
+    return result;
+}
+#endif
+
+/* PyObjectCallOneArg */
+  #if CYTHON_COMPILING_IN_CPYTHON
+static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_New(1);
+    if (unlikely(!args)) return NULL;
+    Py_INCREF(arg);
+    PyTuple_SET_ITEM(args, 0, arg);
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+#if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCall(func, &arg, 1);
+    }
+#endif
+#ifdef __Pyx_CyFunction_USED
+    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
+#else
+    if (likely(PyCFunction_Check(func))) {
+#endif
+        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
+            return __Pyx_PyObject_CallMethO(func, arg);
+#if CYTHON_FAST_PYCCALL
+        } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
+            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
+#endif
+        }
+    }
+    return __Pyx__PyObject_CallOneArg(func, arg);
+}
+#else
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
+    PyObject *result;
+    PyObject *args = PyTuple_Pack(1, arg);
+    if (unlikely(!args)) return NULL;
+    result = __Pyx_PyObject_Call(func, args, NULL);
+    Py_DECREF(args);
+    return result;
+}
+#endif
+
+/* PyErrFetchRestore */
+    #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+}
+#endif
+
+/* WriteUnraisableException */
+    static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
+                                  CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
+                                  int full_traceback, CYTHON_UNUSED int nogil) {
+    PyObject *old_exc, *old_val, *old_tb;
+    PyObject *ctx;
+    __Pyx_PyThreadState_declare
+#ifdef WITH_THREAD
+    PyGILState_STATE state;
+    if (nogil)
+        state = PyGILState_Ensure();
+#ifdef _MSC_VER
+    else state = (PyGILState_STATE)-1;
+#endif
+#endif
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
+    if (full_traceback) {
+        Py_XINCREF(old_exc);
+        Py_XINCREF(old_val);
+        Py_XINCREF(old_tb);
+        __Pyx_ErrRestore(old_exc, old_val, old_tb);
+        PyErr_PrintEx(1);
+    }
+    #if PY_MAJOR_VERSION < 3
+    ctx = PyString_FromString(name);
+    #else
+    ctx = PyUnicode_FromString(name);
+    #endif
+    __Pyx_ErrRestore(old_exc, old_val, old_tb);
+    if (!ctx) {
+        PyErr_WriteUnraisable(Py_None);
+    } else {
+        PyErr_WriteUnraisable(ctx);
+        Py_DECREF(ctx);
+    }
+#ifdef WITH_THREAD
+    if (nogil)
+        PyGILState_Release(state);
+#endif
+}
+
+/* RaiseDoubleKeywords */
+    static void __Pyx_RaiseDoubleKeywordsError(
+    const char* func_name,
+    PyObject* kw_name)
+{
+    PyErr_Format(PyExc_TypeError,
+        #if PY_MAJOR_VERSION >= 3
+        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
+        #else
+        "%s() got multiple values for keyword argument '%s'", func_name,
+        PyString_AsString(kw_name));
+        #endif
+}
+
+/* ParseKeywords */
+    static int __Pyx_ParseOptionalKeywords(
+    PyObject *kwds,
+    PyObject **argnames[],
+    PyObject *kwds2,
+    PyObject *values[],
+    Py_ssize_t num_pos_args,
+    const char* function_name)
+{
+    PyObject *key = 0, *value = 0;
+    Py_ssize_t pos = 0;
+    PyObject*** name;
+    PyObject*** first_kw_arg = argnames + num_pos_args;
+    while (PyDict_Next(kwds, &pos, &key, &value)) {
+        name = first_kw_arg;
+        while (*name && (**name != key)) name++;
+        if (*name) {
+            values[name-argnames] = value;
+            continue;
+        }
+        name = first_kw_arg;
+        #if PY_MAJOR_VERSION < 3
+        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
+            while (*name) {
+                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
+                        && _PyString_Eq(**name, key)) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    if ((**argname == key) || (
+                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
+                             && _PyString_Eq(**argname, key))) {
+                        goto arg_passed_twice;
+                    }
+                    argname++;
+                }
+            }
+        } else
+        #endif
+        if (likely(PyUnicode_Check(key))) {
+            while (*name) {
+                int cmp = (**name == key) ? 0 :
+                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
+                #endif
+                    PyUnicode_Compare(**name, key);
+                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                if (cmp == 0) {
+                    values[name-argnames] = value;
+                    break;
+                }
+                name++;
+            }
+            if (*name) continue;
+            else {
+                PyObject*** argname = argnames;
+                while (argname != first_kw_arg) {
+                    int cmp = (**argname == key) ? 0 :
+                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
+                    #endif
+                        PyUnicode_Compare(**argname, key);
+                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
+                    if (cmp == 0) goto arg_passed_twice;
+                    argname++;
+                }
+            }
+        } else
+            goto invalid_keyword_type;
+        if (kwds2) {
+            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
+        } else {
+            goto invalid_keyword;
+        }
+    }
+    return 0;
+arg_passed_twice:
+    __Pyx_RaiseDoubleKeywordsError(function_name, key);
+    goto bad;
+invalid_keyword_type:
+    PyErr_Format(PyExc_TypeError,
+        "%.200s() keywords must be strings", function_name);
+    goto bad;
+invalid_keyword:
+    PyErr_Format(PyExc_TypeError,
+    #if PY_MAJOR_VERSION < 3
+        "%.200s() got an unexpected keyword argument '%.200s'",
+        function_name, PyString_AsString(key));
+    #else
+        "%s() got an unexpected keyword argument '%U'",
+        function_name, key);
+    #endif
+bad:
+    return -1;
+}
+
+/* ArgTypeTest */
+    static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
+    PyErr_Format(PyExc_TypeError,
+        "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
+        name, type->tp_name, Py_TYPE(obj)->tp_name);
+}
+static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
+    const char *name, int exact)
+{
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (none_allowed && obj == Py_None) return 1;
+    else if (exact) {
+        if (likely(Py_TYPE(obj) == type)) return 1;
+        #if PY_MAJOR_VERSION == 2
+        else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1;
+        #endif
+    }
+    else {
+        if (likely(PyObject_TypeCheck(obj, type))) return 1;
+    }
+    __Pyx_RaiseArgumentTypeInvalid(name, obj, type);
+    return 0;
+}
+
+/* RaiseException */
+    #if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
+                        CYTHON_UNUSED PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+    if (PyType_Check(type)) {
+#if CYTHON_COMPILING_IN_PYPY
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+    } else {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+#else
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    goto bad;
+                } else {
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+#if PY_VERSION_HEX >= 0x03030000
+    if (cause) {
+#else
+    if (cause && cause != Py_None) {
+#endif
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+    PyErr_SetObject(type, value);
+    if (tb) {
+#if CYTHON_COMPILING_IN_PYPY
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#else
+        PyThreadState *tstate = PyThreadState_GET();
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#endif
+    }
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+/* ExtTypeTest */
+      static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+    if (unlikely(!type)) {
+        PyErr_SetString(PyExc_SystemError, "Missing type object");
+        return 0;
+    }
+    if (likely(PyObject_TypeCheck(obj, type)))
+        return 1;
+    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
+                 Py_TYPE(obj)->tp_name, type->tp_name);
+    return 0;
+}
+
+/* BufferFormatCheck */
+      static CYTHON_INLINE int __Pyx_IsLittleEndian(void) {
+  unsigned int n = 1;
+  return *(unsigned char*)(&n) != 0;
+}
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type) {
+  stack[0].field = &ctx->root;
+  stack[0].parent_offset = 0;
+  ctx->root.type = type;
+  ctx->root.name = "buffer dtype";
+  ctx->root.offset = 0;
+  ctx->head = stack;
+  ctx->head->field = &ctx->root;
+  ctx->fmt_offset = 0;
+  ctx->head->parent_offset = 0;
+  ctx->new_packmode = '@';
+  ctx->enc_packmode = '@';
+  ctx->new_count = 1;
+  ctx->enc_count = 0;
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  ctx->is_valid_array = 0;
+  ctx->struct_alignment = 0;
+  while (type->typegroup == 'S') {
+    ++ctx->head;
+    ctx->head->field = type->fields;
+    ctx->head->parent_offset = 0;
+    type = type->fields->type;
+  }
+}
+static int __Pyx_BufFmt_ParseNumber(const char** ts) {
+    int count;
+    const char* t = *ts;
+    if (*t < '0' || *t > '9') {
+      return -1;
+    } else {
+        count = *t++ - '0';
+        while (*t >= '0' && *t < '9') {
+            count *= 10;
+            count += *t++ - '0';
+        }
+    }
+    *ts = t;
+    return count;
+}
+static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
+    int number = __Pyx_BufFmt_ParseNumber(ts);
+    if (number == -1)
+        PyErr_Format(PyExc_ValueError,\
+                     "Does not understand character buffer dtype format string ('%c')", **ts);
+    return number;
+}
+static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
+  PyErr_Format(PyExc_ValueError,
+               "Unexpected format string character: '%c'", ch);
+}
+static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': return "'char'";
+    case 'b': return "'signed char'";
+    case 'B': return "'unsigned char'";
+    case 'h': return "'short'";
+    case 'H': return "'unsigned short'";
+    case 'i': return "'int'";
+    case 'I': return "'unsigned int'";
+    case 'l': return "'long'";
+    case 'L': return "'unsigned long'";
+    case 'q': return "'long long'";
+    case 'Q': return "'unsigned long long'";
+    case 'f': return (is_complex ? "'complex float'" : "'float'");
+    case 'd': return (is_complex ? "'complex double'" : "'double'");
+    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
+    case 'T': return "a struct";
+    case 'O': return "Python object";
+    case 'P': return "a pointer";
+    case 's': case 'p': return "a string";
+    case 0: return "end";
+    default: return "unparseable format string";
+  }
+}
+static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return 2;
+    case 'i': case 'I': case 'l': case 'L': return 4;
+    case 'q': case 'Q': return 8;
+    case 'f': return (is_complex ? 8 : 4);
+    case 'd': return (is_complex ? 16 : 8);
+    case 'g': {
+      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
+      return 0;
+    }
+    case 'O': case 'P': return sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
+  switch (ch) {
+    case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(short);
+    case 'i': case 'I': return sizeof(int);
+    case 'l': case 'L': return sizeof(long);
+    #ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
+    #endif
+    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
+    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
+    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
+    case 'O': case 'P': return sizeof(void*);
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+typedef struct { char c; short x; } __Pyx_st_short;
+typedef struct { char c; int x; } __Pyx_st_int;
+typedef struct { char c; long x; } __Pyx_st_long;
+typedef struct { char c; float x; } __Pyx_st_float;
+typedef struct { char c; double x; } __Pyx_st_double;
+typedef struct { char c; long double x; } __Pyx_st_longdouble;
+typedef struct { char c; void *x; } __Pyx_st_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+/* These are for computing the padding at the end of the struct to align
+   on the first member of the struct. This will probably the same as above,
+   but we don't have any guarantees.
+ */
+typedef struct { short x; char c; } __Pyx_pad_short;
+typedef struct { int x; char c; } __Pyx_pad_int;
+typedef struct { long x; char c; } __Pyx_pad_long;
+typedef struct { float x; char c; } __Pyx_pad_float;
+typedef struct { double x; char c; } __Pyx_pad_double;
+typedef struct { long double x; char c; } __Pyx_pad_longdouble;
+typedef struct { void *x; char c; } __Pyx_pad_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
+#endif
+static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
+  switch (ch) {
+    case 'c':
+        return 'H';
+    case 'b': case 'h': case 'i':
+    case 'l': case 'q': case 's': case 'p':
+        return 'I';
+    case 'B': case 'H': case 'I': case 'L': case 'Q':
+        return 'U';
+    case 'f': case 'd': case 'g':
+        return (is_complex ? 'C' : 'R');
+    case 'O':
+        return 'O';
+    case 'P':
+        return 'P';
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
+  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
+    const char* expected;
+    const char* quote;
+    if (ctx->head == NULL) {
+      expected = "end";
+      quote = "";
+    } else {
+      expected = ctx->head->field->type->name;
+      quote = "'";
+    }
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected %s%s%s but got %s",
+                 quote, expected, quote,
+                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
+  } else {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_StructField* parent = (ctx->head - 1)->field;
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
+                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
+                 parent->type->name, field->name);
+  }
+}
+static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
+  char group;
+  size_t size, offset, arraysize = 1;
+  if (ctx->enc_type == 0) return 0;
+  if (ctx->head->field->type->arraysize[0]) {
+    int i, ndim = 0;
+    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
+        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
+        ndim = 1;
+        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
+            PyErr_Format(PyExc_ValueError,
+                         "Expected a dimension of size %zu, got %zu",
+                         ctx->head->field->type->arraysize[0], ctx->enc_count);
+            return -1;
+        }
+    }
+    if (!ctx->is_valid_array) {
+      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
+                   ctx->head->field->type->ndim, ndim);
+      return -1;
+    }
+    for (i = 0; i < ctx->head->field->type->ndim; i++) {
+      arraysize *= ctx->head->field->type->arraysize[i];
+    }
+    ctx->is_valid_array = 0;
+    ctx->enc_count = 1;
+  }
+  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
+  do {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_TypeInfo* type = field->type;
+    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
+      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
+    } else {
+      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
+    }
+    if (ctx->enc_packmode == '@') {
+      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
+      size_t align_mod_offset;
+      if (align_at == 0) return -1;
+      align_mod_offset = ctx->fmt_offset % align_at;
+      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
+      if (ctx->struct_alignment == 0)
+          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
+                                                                 ctx->is_complex);
+    }
+    if (type->size != size || type->typegroup != group) {
+      if (type->typegroup == 'C' && type->fields != NULL) {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        ++ctx->head;
+        ctx->head->field = type->fields;
+        ctx->head->parent_offset = parent_offset;
+        continue;
+      }
+      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
+      } else {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+      }
+    }
+    offset = ctx->head->parent_offset + field->offset;
+    if (ctx->fmt_offset != offset) {
+      PyErr_Format(PyExc_ValueError,
+                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
+                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
+      return -1;
+    }
+    ctx->fmt_offset += size;
+    if (arraysize)
+      ctx->fmt_offset += (arraysize - 1) * size;
+    --ctx->enc_count;
+    while (1) {
+      if (field == &ctx->root) {
+        ctx->head = NULL;
+        if (ctx->enc_count != 0) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+        }
+        break;
+      }
+      ctx->head->field = ++field;
+      if (field->type == NULL) {
+        --ctx->head;
+        field = ctx->head->field;
+        continue;
+      } else if (field->type->typegroup == 'S') {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        if (field->type->fields->type == NULL) continue;
+        field = field->type->fields;
+        ++ctx->head;
+        ctx->head->field = field;
+        ctx->head->parent_offset = parent_offset;
+        break;
+      } else {
+        break;
+      }
+    }
+  } while (ctx->enc_count);
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  return 0;
+}
+static CYTHON_INLINE PyObject *
+__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
+{
+    const char *ts = *tsp;
+    int i = 0, number;
+    int ndim = ctx->head->field->type->ndim;
+;
+    ++ts;
+    if (ctx->new_count != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Cannot handle repeated arrays in format string");
+        return NULL;
+    }
+    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+    while (*ts && *ts != ')') {
+        switch (*ts) {
+            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
+            default:  break;
+        }
+        number = __Pyx_BufFmt_ExpectNumber(&ts);
+        if (number == -1) return NULL;
+        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i])
+            return PyErr_Format(PyExc_ValueError,
+                        "Expected a dimension of size %zu, got %d",
+                        ctx->head->field->type->arraysize[i], number);
+        if (*ts != ',' && *ts != ')')
+            return PyErr_Format(PyExc_ValueError,
+                                "Expected a comma in format string, got '%c'", *ts);
+        if (*ts == ',') ts++;
+        i++;
+    }
+    if (i != ndim)
+        return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
+                            ctx->head->field->type->ndim, i);
+    if (!*ts) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Unexpected end of format string, expected ')'");
+        return NULL;
+    }
+    ctx->is_valid_array = 1;
+    ctx->new_count = 1;
+    *tsp = ++ts;
+    return Py_None;
+}
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
+  int got_Z = 0;
+  while (1) {
+    switch(*ts) {
+      case 0:
+        if (ctx->enc_type != 0 && ctx->head == NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        if (ctx->head != NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        return ts;
+      case ' ':
+      case '\r':
+      case '\n':
+        ++ts;
+        break;
+      case '<':
+        if (!__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '>':
+      case '!':
+        if (__Pyx_IsLittleEndian()) {
+          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '=':
+      case '@':
+      case '^':
+        ctx->new_packmode = *ts++;
+        break;
+      case 'T':
+        {
+          const char* ts_after_sub;
+          size_t i, struct_count = ctx->new_count;
+          size_t struct_alignment = ctx->struct_alignment;
+          ctx->new_count = 1;
+          ++ts;
+          if (*ts != '{') {
+            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
+            return NULL;
+          }
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          ctx->enc_count = 0;
+          ctx->struct_alignment = 0;
+          ++ts;
+          ts_after_sub = ts;
+          for (i = 0; i != struct_count; ++i) {
+            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
+            if (!ts_after_sub) return NULL;
+          }
+          ts = ts_after_sub;
+          if (struct_alignment) ctx->struct_alignment = struct_alignment;
+        }
+        break;
+      case '}':
+        {
+          size_t alignment = ctx->struct_alignment;
+          ++ts;
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0;
+          if (alignment && ctx->fmt_offset % alignment) {
+            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
+          }
+        }
+        return ts;
+      case 'x':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->fmt_offset += ctx->new_count;
+        ctx->new_count = 1;
+        ctx->enc_count = 0;
+        ctx->enc_type = 0;
+        ctx->enc_packmode = ctx->new_packmode;
+        ++ts;
+        break;
+      case 'Z':
+        got_Z = 1;
+        ++ts;
+        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
+          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
+          return NULL;
+        }
+      case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
+      case 'l': case 'L': case 'q': case 'Q':
+      case 'f': case 'd': case 'g':
+      case 'O': case 'p':
+        if (ctx->enc_type == *ts && got_Z == ctx->is_complex &&
+            ctx->enc_packmode == ctx->new_packmode) {
+          ctx->enc_count += ctx->new_count;
+          ctx->new_count = 1;
+          got_Z = 0;
+          ++ts;
+          break;
+        }
+      case 's':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->enc_count = ctx->new_count;
+        ctx->enc_packmode = ctx->new_packmode;
+        ctx->enc_type = *ts;
+        ctx->is_complex = got_Z;
+        ++ts;
+        ctx->new_count = 1;
+        got_Z = 0;
+        break;
+      case ':':
+        ++ts;
+        while(*ts != ':') ++ts;
+        ++ts;
+        break;
+      case '(':
+        if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL;
+        break;
+      default:
+        {
+          int number = __Pyx_BufFmt_ExpectNumber(&ts);
+          if (number == -1) return NULL;
+          ctx->new_count = (size_t)number;
+        }
+    }
+  }
+}
+static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) {
+  buf->buf = NULL;
+  buf->obj = NULL;
+  buf->strides = __Pyx_zeros;
+  buf->shape = __Pyx_zeros;
+  buf->suboffsets = __Pyx_minusones;
+}
+static CYTHON_INLINE int __Pyx_GetBufferAndValidate(
+        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
+        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
+{
+  if (obj == Py_None || obj == NULL) {
+    __Pyx_ZeroBuffer(buf);
+    return 0;
+  }
+  buf->buf = NULL;
+  if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail;
+  if (buf->ndim != nd) {
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer has wrong number of dimensions (expected %d, got %d)",
+                 nd, buf->ndim);
+    goto fail;
+  }
+  if (!cast) {
+    __Pyx_BufFmt_Context ctx;
+    __Pyx_BufFmt_Init(&ctx, stack, dtype);
+    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
+  }
+  if ((unsigned)buf->itemsize != dtype->size) {
+    PyErr_Format(PyExc_ValueError,
+      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
+      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
+      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
+    goto fail;
+  }
+  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
+  return 0;
+fail:;
+  __Pyx_ZeroBuffer(buf);
+  return -1;
+}
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
+  if (info->buf == NULL) return;
+  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
+  __Pyx_ReleaseBuffer(info);
+}
+
+/* BufferIndexError */
+        static void __Pyx_RaiseBufferIndexError(int axis) {
+  PyErr_Format(PyExc_IndexError,
+     "Out of bounds on buffer access (axis %d)", axis);
+}
+
+/* PyObjectCallNoArg */
+        #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
+#if CYTHON_FAST_PYCALL
+    if (PyFunction_Check(func)) {
+        return __Pyx_PyFunction_FastCall(func, NULL, 0);
+    }
+#endif
+#ifdef __Pyx_CyFunction_USED
+    if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) {
+#else
+    if (likely(PyCFunction_Check(func))) {
+#endif
+        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
+            return __Pyx_PyObject_CallMethO(func, NULL);
+        }
+    }
+    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
+}
+#endif
+
+/* BufferFallbackError */
+          static void __Pyx_RaiseBufferFallbackError(void) {
+  PyErr_SetString(PyExc_ValueError,
+     "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!");
+}
+
+/* PyIntBinop */
+          #if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(op1))) {
+        const long b = intval;
+        long x;
+        long a = PyInt_AS_LONG(op1);
+            x = (long)((unsigned long)a + b);
+            if (likely((x^a) >= 0 || (x^b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_add(op1, op2);
+    }
+    #endif
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact(op1))) {
+        const long b = intval;
+        long a, x;
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG llb = intval;
+        PY_LONG_LONG lla, llx;
+#endif
+        const digit* digits = ((PyLongObject*)op1)->ob_digit;
+        const Py_ssize_t size = Py_SIZE(op1);
+        if (likely(__Pyx_sst_abs(size) <= 1)) {
+            a = likely(size) ? digits[0] : 0;
+            if (size == -1) a = -a;
+        } else {
+            switch (size) {
+                case -2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 2:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case -3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 3:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case -4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                case 4:
+                    if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                        a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]));
+                        break;
+#ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) {
+                        lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0]));
+                        goto long_long;
+#endif
+                    }
+                default: return PyLong_Type.tp_as_number->nb_add(op1, op2);
+            }
+        }
+                x = a + b;
+            return PyLong_FromLong(x);
+#ifdef HAVE_LONG_LONG
+        long_long:
+                llx = lla + llb;
+            return PyLong_FromLongLong(llx);
+#endif
+        
+        
+    }
+    #endif
+    if (PyFloat_CheckExact(op1)) {
+        const long b = intval;
+        double a = PyFloat_AS_DOUBLE(op1);
+            double result;
+            PyFPE_START_PROTECT("add", return NULL)
+            result = ((double)a) + (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+    }
+    return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2);
+}
+#endif
+
+/* RaiseTooManyValuesToUnpack */
+          static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+    PyErr_Format(PyExc_ValueError,
+                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
+}
+
+/* RaiseNeedMoreValuesToUnpack */
+          static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+    PyErr_Format(PyExc_ValueError,
+                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
+                 index, (index == 1) ? "" : "s");
+}
+
+/* IterFinish */
+          static CYTHON_INLINE int __Pyx_IterFinish(void) {
+#if CYTHON_FAST_THREAD_STATE
+    PyThreadState *tstate = PyThreadState_GET();
+    PyObject* exc_type = tstate->curexc_type;
+    if (unlikely(exc_type)) {
+        if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) {
+            PyObject *exc_value, *exc_tb;
+            exc_value = tstate->curexc_value;
+            exc_tb = tstate->curexc_traceback;
+            tstate->curexc_type = 0;
+            tstate->curexc_value = 0;
+            tstate->curexc_traceback = 0;
+            Py_DECREF(exc_type);
+            Py_XDECREF(exc_value);
+            Py_XDECREF(exc_tb);
+            return 0;
+        } else {
+            return -1;
+        }
+    }
+    return 0;
+#else
+    if (unlikely(PyErr_Occurred())) {
+        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
+            PyErr_Clear();
+            return 0;
+        } else {
+            return -1;
+        }
+    }
+    return 0;
+#endif
+}
+
+/* UnpackItemEndCheck */
+          static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+    if (unlikely(retval)) {
+        Py_DECREF(retval);
+        __Pyx_RaiseTooManyValuesError(expected);
+        return -1;
+    } else {
+        return __Pyx_IterFinish();
+    }
+    return 0;
+}
+
+/* RaiseNoneIterError */
+          static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+}
+
+/* SaveResetException */
+          #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+}
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+}
+#endif
+
+/* PyErrExceptionMatches */
+          #if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    PyObject *exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+    return PyErr_GivenExceptionMatches(exc_type, err);
+}
+#endif
+
+/* GetException */
+          #if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
+#endif
+    PyObject *local_type, *local_value, *local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+    Py_XINCREF(local_tb);
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+#if CYTHON_FAST_THREAD_STATE
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+    return 0;
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/* SetVTable */
+            static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
+#if PY_VERSION_HEX >= 0x02070000
+    PyObject *ob = PyCapsule_New(vtable, 0, 0);
+#else
+    PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
+#endif
+    if (!ob)
+        goto bad;
+    if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0)
+        goto bad;
+    Py_DECREF(ob);
+    return 0;
+bad:
+    Py_XDECREF(ob);
+    return -1;
+}
+
+/* Import */
+            static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+    PyObject *empty_list = 0;
+    PyObject *module = 0;
+    PyObject *global_dict = 0;
+    PyObject *empty_dict = 0;
+    PyObject *list;
+    #if PY_VERSION_HEX < 0x03030000
+    PyObject *py_import;
+    py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import);
+    if (!py_import)
+        goto bad;
+    #endif
+    if (from_list)
+        list = from_list;
+    else {
+        empty_list = PyList_New(0);
+        if (!empty_list)
+            goto bad;
+        list = empty_list;
+    }
+    global_dict = PyModule_GetDict(__pyx_m);
+    if (!global_dict)
+        goto bad;
+    empty_dict = PyDict_New();
+    if (!empty_dict)
+        goto bad;
+    {
+        #if PY_MAJOR_VERSION >= 3
+        if (level == -1) {
+            if (strchr(__Pyx_MODULE_NAME, '.')) {
+                #if PY_VERSION_HEX < 0x03030000
+                PyObject *py_level = PyInt_FromLong(1);
+                if (!py_level)
+                    goto bad;
+                module = PyObject_CallFunctionObjArgs(py_import,
+                    name, global_dict, empty_dict, list, py_level, NULL);
+                Py_DECREF(py_level);
+                #else
+                module = PyImport_ImportModuleLevelObject(
+                    name, global_dict, empty_dict, list, 1);
+                #endif
+                if (!module) {
+                    if (!PyErr_ExceptionMatches(PyExc_ImportError))
+                        goto bad;
+                    PyErr_Clear();
+                }
+            }
+            level = 0;
+        }
+        #endif
+        if (!module) {
+            #if PY_VERSION_HEX < 0x03030000
+            PyObject *py_level = PyInt_FromLong(level);
+            if (!py_level)
+                goto bad;
+            module = PyObject_CallFunctionObjArgs(py_import,
+                name, global_dict, empty_dict, list, py_level, NULL);
+            Py_DECREF(py_level);
+            #else
+            module = PyImport_ImportModuleLevelObject(
+                name, global_dict, empty_dict, list, level);
+            #endif
+        }
+    }
+bad:
+    #if PY_VERSION_HEX < 0x03030000
+    Py_XDECREF(py_import);
+    #endif
+    Py_XDECREF(empty_list);
+    Py_XDECREF(empty_dict);
+    return module;
+}
+
+/* ImportFrom */
+            static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+    PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
+    if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Format(PyExc_ImportError,
+        #if PY_MAJOR_VERSION < 3
+            "cannot import name %.230s", PyString_AS_STRING(name));
+        #else
+            "cannot import name %S", name);
+        #endif
+    }
+    return value;
+}
+
+/* CodeObjectCache */
+            static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+    int start = 0, mid = 0, end = count - 1;
+    if (end >= 0 && code_line > entries[end].code_line) {
+        return count;
+    }
+    while (start < end) {
+        mid = start + (end - start) / 2;
+        if (code_line < entries[mid].code_line) {
+            end = mid;
+        } else if (code_line > entries[mid].code_line) {
+             start = mid + 1;
+        } else {
+            return mid;
+        }
+    }
+    if (code_line <= entries[mid].code_line) {
+        return mid;
+    } else {
+        return mid + 1;
+    }
+}
+static PyCodeObject *__pyx_find_code_object(int code_line) {
+    PyCodeObject* code_object;
+    int pos;
+    if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
+        return NULL;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
+        return NULL;
+    }
+    code_object = __pyx_code_cache.entries[pos].code_object;
+    Py_INCREF(code_object);
+    return code_object;
+}
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
+    int pos, i;
+    __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
+    if (unlikely(!code_line)) {
+        return;
+    }
+    if (unlikely(!entries)) {
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (likely(entries)) {
+            __pyx_code_cache.entries = entries;
+            __pyx_code_cache.max_count = 64;
+            __pyx_code_cache.count = 1;
+            entries[0].code_line = code_line;
+            entries[0].code_object = code_object;
+            Py_INCREF(code_object);
+        }
+        return;
+    }
+    pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
+    if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
+        PyCodeObject* tmp = entries[pos].code_object;
+        entries[pos].code_object = code_object;
+        Py_DECREF(tmp);
+        return;
+    }
+    if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
+        int new_max = __pyx_code_cache.max_count + 64;
+        entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
+            __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
+        if (unlikely(!entries)) {
+            return;
+        }
+        __pyx_code_cache.entries = entries;
+        __pyx_code_cache.max_count = new_max;
+    }
+    for (i=__pyx_code_cache.count; i>pos; i--) {
+        entries[i] = entries[i-1];
+    }
+    entries[pos].code_line = code_line;
+    entries[pos].code_object = code_object;
+    __pyx_code_cache.count++;
+    Py_INCREF(code_object);
+}
+
+/* AddTraceback */
+            #include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyObject *py_srcfile = 0;
+    PyObject *py_funcname = 0;
+    #if PY_MAJOR_VERSION < 3
+    py_srcfile = PyString_FromString(filename);
+    #else
+    py_srcfile = PyUnicode_FromString(filename);
+    #endif
+    if (!py_srcfile) goto bad;
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line);
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        #else
+        py_funcname = PyUnicode_FromString(funcname);
+        #endif
+    }
+    if (!py_funcname) goto bad;
+    py_code = __Pyx_PyCode_New(
+        0,
+        0,
+        0,
+        0,
+        0,
+        __pyx_empty_bytes, /*PyObject *code,*/
+        __pyx_empty_tuple, /*PyObject *consts,*/
+        __pyx_empty_tuple, /*PyObject *names,*/
+        __pyx_empty_tuple, /*PyObject *varnames,*/
+        __pyx_empty_tuple, /*PyObject *freevars,*/
+        __pyx_empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,
+        __pyx_empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    Py_DECREF(py_funcname);
+    return py_code;
+bad:
+    Py_XDECREF(py_srcfile);
+    Py_XDECREF(py_funcname);
+    return NULL;
+}
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    py_code = __pyx_find_code_object(c_line ? c_line : py_line);
+    if (!py_code) {
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) goto bad;
+        __pyx_insert_code_object(c_line ? c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        PyThreadState_GET(), /*PyThreadState *tstate,*/
+        py_code,             /*PyCodeObject *code,*/
+        __pyx_d,      /*PyObject *globals,*/
+        0                    /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+
+#if PY_MAJOR_VERSION < 3
+static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
+    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud)) return __pyx_pw_3pcl_4_pcl_10PointCloud_5__getbuffer__(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI)) return __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_5__getbuffer__(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB)) return __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_5__getbuffer__(obj, view, flags);
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA)) return __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_5__getbuffer__(obj, view, flags);
+    PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name);
+    return -1;
+}
+static void __Pyx_ReleaseBuffer(Py_buffer *view) {
+    PyObject *obj = view->obj;
+    if (!obj) return;
+    if (PyObject_CheckBuffer(obj)) {
+        PyBuffer_Release(view);
+        return;
+    }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud)) { __pyx_pw_3pcl_4_pcl_10PointCloud_7__releasebuffer__(obj, view); return; }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZI)) { __pyx_pw_3pcl_4_pcl_20PointCloud_PointXYZI_7__releasebuffer__(obj, view); return; }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGB)) { __pyx_pw_3pcl_4_pcl_22PointCloud_PointXYZRGB_7__releasebuffer__(obj, view); return; }
+        if (PyObject_TypeCheck(obj, __pyx_ptype_3pcl_4_pcl_PointCloud_PointXYZRGBA)) { __pyx_pw_3pcl_4_pcl_23PointCloud_PointXYZRGBA_7__releasebuffer__(obj, view); return; }
+    Py_DECREF(obj);
+    view->obj = NULL;
+}
+#endif
+
+
+            /* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__pcl_3a__3a_SacModel(enum pcl::SacModel value) {
+    const enum pcl::SacModel neg_one = (enum pcl::SacModel) -1, const_zero = (enum pcl::SacModel) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(enum pcl::SacModel) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(enum pcl::SacModel) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum pcl::SacModel) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(enum pcl::SacModel) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum pcl::SacModel) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(enum pcl::SacModel),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPyVerify */
+            #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\
+    {\
+        func_type value = func_value;\
+        if (sizeof(target_type) < sizeof(func_type)) {\
+            if (unlikely(value != (func_type) (target_type) value)) {\
+                func_type zero = 0;\
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\
+                    return (target_type) -1;\
+                if (is_unsigned && unlikely(value < zero))\
+                    goto raise_neg_overflow;\
+                else\
+                    goto raise_overflow;\
+            }\
+        }\
+        return (target_type) value;\
+    }
+
+/* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(long) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(long) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(long) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(long),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_Py_intptr_t(Py_intptr_t value) {
+    const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(Py_intptr_t) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(Py_intptr_t) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(Py_intptr_t),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) {
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(unsigned int) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(unsigned int) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(unsigned int) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(unsigned int),
+                                     little, !is_unsigned);
+    }
+}
+
+/* Print */
+            #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3
+static PyObject *__Pyx_GetStdout(void) {
+    PyObject *f = PySys_GetObject((char *)"stdout");
+    if (!f) {
+        PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout");
+    }
+    return f;
+}
+static int __Pyx_Print(PyObject* f, PyObject *arg_tuple, int newline) {
+    int i;
+    if (!f) {
+        if (!(f = __Pyx_GetStdout()))
+            return -1;
+    }
+    Py_INCREF(f);
+    for (i=0; i < PyTuple_GET_SIZE(arg_tuple); i++) {
+        PyObject* v;
+        if (PyFile_SoftSpace(f, 1)) {
+            if (PyFile_WriteString(" ", f) < 0)
+                goto error;
+        }
+        v = PyTuple_GET_ITEM(arg_tuple, i);
+        if (PyFile_WriteObject(v, f, Py_PRINT_RAW) < 0)
+            goto error;
+        if (PyString_Check(v)) {
+            char *s = PyString_AsString(v);
+            Py_ssize_t len = PyString_Size(v);
+            if (len > 0) {
+                switch (s[len-1]) {
+                    case ' ': break;
+                    case '\f': case '\r': case '\n': case '\t': case '\v':
+                        PyFile_SoftSpace(f, 0);
+                        break;
+                    default:  break;
+                }
+            }
+        }
+    }
+    if (newline) {
+        if (PyFile_WriteString("\n", f) < 0)
+            goto error;
+        PyFile_SoftSpace(f, 0);
+    }
+    Py_DECREF(f);
+    return 0;
+error:
+    Py_DECREF(f);
+    return -1;
+}
+#else
+static int __Pyx_Print(PyObject* stream, PyObject *arg_tuple, int newline) {
+    PyObject* kwargs = 0;
+    PyObject* result = 0;
+    PyObject* end_string;
+    if (unlikely(!__pyx_print)) {
+        __pyx_print = PyObject_GetAttr(__pyx_b, __pyx_n_s_print);
+        if (!__pyx_print)
+            return -1;
+    }
+    if (stream) {
+        kwargs = PyDict_New();
+        if (unlikely(!kwargs))
+            return -1;
+        if (unlikely(PyDict_SetItem(kwargs, __pyx_n_s_file, stream) < 0))
+            goto bad;
+        if (!newline) {
+            end_string = PyUnicode_FromStringAndSize(" ", 1);
+            if (unlikely(!end_string))
+                goto bad;
+            if (PyDict_SetItem(kwargs, __pyx_n_s_end, end_string) < 0) {
+                Py_DECREF(end_string);
+                goto bad;
+            }
+            Py_DECREF(end_string);
+        }
+    } else if (!newline) {
+        if (unlikely(!__pyx_print_kwargs)) {
+            __pyx_print_kwargs = PyDict_New();
+            if (unlikely(!__pyx_print_kwargs))
+                return -1;
+            end_string = PyUnicode_FromStringAndSize(" ", 1);
+            if (unlikely(!end_string))
+                return -1;
+            if (PyDict_SetItem(__pyx_print_kwargs, __pyx_n_s_end, end_string) < 0) {
+                Py_DECREF(end_string);
+                return -1;
+            }
+            Py_DECREF(end_string);
+        }
+        kwargs = __pyx_print_kwargs;
+    }
+    result = PyObject_Call(__pyx_print, arg_tuple, kwargs);
+    if (unlikely(kwargs) && (kwargs != __pyx_print_kwargs))
+        Py_DECREF(kwargs);
+    if (!result)
+        return -1;
+    Py_DECREF(result);
+    return 0;
+bad:
+    if (kwargs != __pyx_print_kwargs)
+        Py_XDECREF(kwargs);
+    return -1;
+}
+#endif
+
+/* Declarations */
+            #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return ::std::complex< float >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      return x + y*(__pyx_t_float_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) {
+      __pyx_t_float_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+            #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        __pyx_t_float_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabsf(b.real) >= fabsf(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                float r = b.imag / b.real;
+                float s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_float_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            float r = b.real / b.imag;
+            float s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_float_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            float denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_float_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) {
+        __pyx_t_float_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrtf(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypotf(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) {
+            __pyx_t_float_complex z;
+            float r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    float denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_float(a, a);
+                        return __Pyx_c_prod_float(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = powf(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2f(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_float(a);
+                theta = atan2f(a.imag, a.real);
+            }
+            lnr = logf(r);
+            z_r = expf(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cosf(z_theta);
+            z.imag = z_r * sinf(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* Declarations */
+            #if CYTHON_CCOMPLEX
+  #ifdef __cplusplus
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return ::std::complex< double >(x, y);
+    }
+  #else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      return x + y*(__pyx_t_double_complex)_Complex_I;
+    }
+  #endif
+#else
+    static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) {
+      __pyx_t_double_complex z;
+      z.real = x;
+      z.imag = y;
+      return z;
+    }
+#endif
+
+/* Arithmetic */
+            #if CYTHON_CCOMPLEX
+#else
+    static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+       return (a.real == b.real) && (a.imag == b.imag);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real + b.real;
+        z.imag = a.imag + b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real - b.real;
+        z.imag = a.imag - b.imag;
+        return z;
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        __pyx_t_double_complex z;
+        z.real = a.real * b.real - a.imag * b.imag;
+        z.imag = a.real * b.imag + a.imag * b.real;
+        return z;
+    }
+    #if 1
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else if (fabs(b.real) >= fabs(b.imag)) {
+            if (b.real == 0 && b.imag == 0) {
+                return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag);
+            } else {
+                double r = b.imag / b.real;
+                double s = 1.0 / (b.real + b.imag * r);
+                return __pyx_t_double_complex_from_parts(
+                    (a.real + a.imag * r) * s, (a.imag - a.real * r) * s);
+            }
+        } else {
+            double r = b.real / b.imag;
+            double s = 1.0 / (b.imag + b.real * r);
+            return __pyx_t_double_complex_from_parts(
+                (a.real * r + a.imag) * s, (a.imag * r - a.real) * s);
+        }
+    }
+    #else
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+        if (b.imag == 0) {
+            return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real);
+        } else {
+            double denom = b.real * b.real + b.imag * b.imag;
+            return __pyx_t_double_complex_from_parts(
+                (a.real * b.real + a.imag * b.imag) / denom,
+                (a.imag * b.real - a.real * b.imag) / denom);
+        }
+    }
+    #endif
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real = -a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) {
+       return (a.real == 0) && (a.imag == 0);
+    }
+    static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) {
+        __pyx_t_double_complex z;
+        z.real =  a.real;
+        z.imag = -a.imag;
+        return z;
+    }
+    #if 1
+        static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) {
+          #if !defined(HAVE_HYPOT) || defined(_MSC_VER)
+            return sqrt(z.real*z.real + z.imag*z.imag);
+          #else
+            return hypot(z.real, z.imag);
+          #endif
+        }
+        static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) {
+            __pyx_t_double_complex z;
+            double r, lnr, theta, z_r, z_theta;
+            if (b.imag == 0 && b.real == (int)b.real) {
+                if (b.real < 0) {
+                    double denom = a.real * a.real + a.imag * a.imag;
+                    a.real = a.real / denom;
+                    a.imag = -a.imag / denom;
+                    b.real = -b.real;
+                }
+                switch ((int)b.real) {
+                    case 0:
+                        z.real = 1;
+                        z.imag = 0;
+                        return z;
+                    case 1:
+                        return a;
+                    case 2:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(a, a);
+                    case 3:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, a);
+                    case 4:
+                        z = __Pyx_c_prod_double(a, a);
+                        return __Pyx_c_prod_double(z, z);
+                }
+            }
+            if (a.imag == 0) {
+                if (a.real == 0) {
+                    return a;
+                } else if (b.imag == 0) {
+                    z.real = pow(a.real, b.real);
+                    z.imag = 0;
+                    return z;
+                } else if (a.real > 0) {
+                    r = a.real;
+                    theta = 0;
+                } else {
+                    r = -a.real;
+                    theta = atan2(0, -1);
+                }
+            } else {
+                r = __Pyx_c_abs_double(a);
+                theta = atan2(a.imag, a.real);
+            }
+            lnr = log(r);
+            z_r = exp(lnr * b.real - theta * b.imag);
+            z_theta = theta * b.real + lnr * b.imag;
+            z.real = z_r * cos(z_theta);
+            z.imag = z_r * sin(z_theta);
+            return z;
+        }
+    #endif
+#endif
+
+/* CIntToPy */
+            static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) {
+    const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0;
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof(enum NPY_TYPES) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof(enum NPY_TYPES) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&value;
+        return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES),
+                                     little, !is_unsigned);
+    }
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE enum pcl::SacModel __Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(PyObject *x) {
+    const enum pcl::SacModel neg_one = (enum pcl::SacModel) -1, const_zero = (enum pcl::SacModel) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(enum pcl::SacModel) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (enum pcl::SacModel) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (enum pcl::SacModel) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(enum pcl::SacModel) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) >= 2 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) (((((enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(enum pcl::SacModel) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) >= 3 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) (((((((enum pcl::SacModel)digits[2]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(enum pcl::SacModel) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) >= 4 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) (((((((((enum pcl::SacModel)digits[3]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[2]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (enum pcl::SacModel) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(enum pcl::SacModel) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(enum pcl::SacModel, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(enum pcl::SacModel) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(enum pcl::SacModel, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (enum pcl::SacModel) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(enum pcl::SacModel,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(enum pcl::SacModel) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) - 1 > 2 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) (((enum pcl::SacModel)-1)*(((((enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(enum pcl::SacModel) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) - 1 > 2 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) ((((((enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(enum pcl::SacModel) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) - 1 > 3 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) (((enum pcl::SacModel)-1)*(((((((enum pcl::SacModel)digits[2]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(enum pcl::SacModel) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) - 1 > 3 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) ((((((((enum pcl::SacModel)digits[2]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(enum pcl::SacModel) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) - 1 > 4 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) (((enum pcl::SacModel)-1)*(((((((((enum pcl::SacModel)digits[3]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[2]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(enum pcl::SacModel) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(enum pcl::SacModel, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(enum pcl::SacModel) - 1 > 4 * PyLong_SHIFT) {
+                            return (enum pcl::SacModel) ((((((((((enum pcl::SacModel)digits[3]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[2]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[1]) << PyLong_SHIFT) | (enum pcl::SacModel)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(enum pcl::SacModel) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(enum pcl::SacModel, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(enum pcl::SacModel) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(enum pcl::SacModel, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            enum pcl::SacModel val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (enum pcl::SacModel) -1;
+        }
+    } else {
+        enum pcl::SacModel val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (enum pcl::SacModel) -1;
+        val = __Pyx_PyInt_As_enum__pcl_3a__3a_SacModel(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to enum pcl::SacModel");
+    return (enum pcl::SacModel) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to enum pcl::SacModel");
+    return (enum pcl::SacModel) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+    const int neg_one = (int) -1, const_zero = (int) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+                            return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+                            return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+                            return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(int) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (int) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(int,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                            return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                            return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+                            return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(int) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (int) -1;
+        }
+    } else {
+        int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (int) -1;
+        val = __Pyx_PyInt_As_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to int");
+    return (int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to int");
+    return (int) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) {
+    const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(unsigned int) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (unsigned int) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (unsigned int) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) {
+                            return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) {
+                            return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) {
+                            return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (unsigned int) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(unsigned int) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (unsigned int) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(unsigned int,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                            return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                            return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                            return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                            return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                            return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) {
+                            return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(unsigned int) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            unsigned int val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (unsigned int) -1;
+        }
+    } else {
+        unsigned int val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (unsigned int) -1;
+        val = __Pyx_PyInt_As_unsigned_int(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to unsigned int");
+    return (unsigned int) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to unsigned int");
+    return (unsigned int) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE Py_intptr_t __Pyx_PyInt_As_Py_intptr_t(PyObject *x) {
+    const Py_intptr_t neg_one = (Py_intptr_t) -1, const_zero = (Py_intptr_t) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(Py_intptr_t) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (Py_intptr_t) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (Py_intptr_t) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(Py_intptr_t, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(Py_intptr_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) >= 2 * PyLong_SHIFT) {
+                            return (Py_intptr_t) (((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(Py_intptr_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) >= 3 * PyLong_SHIFT) {
+                            return (Py_intptr_t) (((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(Py_intptr_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) >= 4 * PyLong_SHIFT) {
+                            return (Py_intptr_t) (((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (Py_intptr_t) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(Py_intptr_t) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(Py_intptr_t) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (Py_intptr_t) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(Py_intptr_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(Py_intptr_t,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(Py_intptr_t) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (Py_intptr_t) (((Py_intptr_t)-1)*(((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(Py_intptr_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (Py_intptr_t) ((((((Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(Py_intptr_t) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (Py_intptr_t) (((Py_intptr_t)-1)*(((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(Py_intptr_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (Py_intptr_t) ((((((((Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(Py_intptr_t) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (Py_intptr_t) (((Py_intptr_t)-1)*(((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(Py_intptr_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(Py_intptr_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(Py_intptr_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (Py_intptr_t) ((((((((((Py_intptr_t)digits[3]) << PyLong_SHIFT) | (Py_intptr_t)digits[2]) << PyLong_SHIFT) | (Py_intptr_t)digits[1]) << PyLong_SHIFT) | (Py_intptr_t)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(Py_intptr_t) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(Py_intptr_t) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(Py_intptr_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            Py_intptr_t val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (Py_intptr_t) -1;
+        }
+    } else {
+        Py_intptr_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (Py_intptr_t) -1;
+        val = __Pyx_PyInt_As_Py_intptr_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to Py_intptr_t");
+    return (Py_intptr_t) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to Py_intptr_t");
+    return (Py_intptr_t) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE pcl::ComparisonOps::CompareOp __Pyx_PyInt_As_pcl_3a__3a_ComparisonOps_3a__3a_CompareOp(PyObject *x) {
+    const pcl::ComparisonOps::CompareOp neg_one = (pcl::ComparisonOps::CompareOp) -1, const_zero = (pcl::ComparisonOps::CompareOp) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(pcl::ComparisonOps::CompareOp) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (pcl::ComparisonOps::CompareOp) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (pcl::ComparisonOps::CompareOp) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) >= 2 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) (((((pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) >= 3 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) (((((((pcl::ComparisonOps::CompareOp)digits[2]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) >= 4 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) (((((((((pcl::ComparisonOps::CompareOp)digits[3]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[2]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (pcl::ComparisonOps::CompareOp) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(pcl::ComparisonOps::CompareOp) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::ComparisonOps::CompareOp, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(pcl::ComparisonOps::CompareOp) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::ComparisonOps::CompareOp, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (pcl::ComparisonOps::CompareOp) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 2 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) (((pcl::ComparisonOps::CompareOp)-1)*(((((pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 2 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) ((((((pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 3 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) (((pcl::ComparisonOps::CompareOp)-1)*(((((((pcl::ComparisonOps::CompareOp)digits[2]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 3 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) ((((((((pcl::ComparisonOps::CompareOp)digits[2]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 4 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) (((pcl::ComparisonOps::CompareOp)-1)*(((((((((pcl::ComparisonOps::CompareOp)digits[3]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[2]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(pcl::ComparisonOps::CompareOp) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::ComparisonOps::CompareOp, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::ComparisonOps::CompareOp) - 1 > 4 * PyLong_SHIFT) {
+                            return (pcl::ComparisonOps::CompareOp) ((((((((((pcl::ComparisonOps::CompareOp)digits[3]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[2]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[1]) << PyLong_SHIFT) | (pcl::ComparisonOps::CompareOp)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(pcl::ComparisonOps::CompareOp) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::ComparisonOps::CompareOp, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(pcl::ComparisonOps::CompareOp) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::ComparisonOps::CompareOp, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            pcl::ComparisonOps::CompareOp val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (pcl::ComparisonOps::CompareOp) -1;
+        }
+    } else {
+        pcl::ComparisonOps::CompareOp val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (pcl::ComparisonOps::CompareOp) -1;
+        val = __Pyx_PyInt_As_pcl_3a__3a_ComparisonOps_3a__3a_CompareOp(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to pcl::ComparisonOps::CompareOp");
+    return (pcl::ComparisonOps::CompareOp) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to pcl::ComparisonOps::CompareOp");
+    return (pcl::ComparisonOps::CompareOp) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE pcl::RangeImage::CoordinateFrame __Pyx_PyInt_As_pcl_3a__3a_RangeImage_3a__3a_CoordinateFrame(PyObject *x) {
+    const pcl::RangeImage::CoordinateFrame neg_one = (pcl::RangeImage::CoordinateFrame) -1, const_zero = (pcl::RangeImage::CoordinateFrame) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(pcl::RangeImage::CoordinateFrame) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (pcl::RangeImage::CoordinateFrame) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (pcl::RangeImage::CoordinateFrame) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) >= 2 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) (((((pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) >= 3 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) (((((((pcl::RangeImage::CoordinateFrame)digits[2]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) >= 4 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) (((((((((pcl::RangeImage::CoordinateFrame)digits[3]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[2]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (pcl::RangeImage::CoordinateFrame) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(pcl::RangeImage::CoordinateFrame) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::RangeImage::CoordinateFrame, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(pcl::RangeImage::CoordinateFrame) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::RangeImage::CoordinateFrame, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (pcl::RangeImage::CoordinateFrame) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 2 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) (((pcl::RangeImage::CoordinateFrame)-1)*(((((pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 2 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) ((((((pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 3 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) (((pcl::RangeImage::CoordinateFrame)-1)*(((((((pcl::RangeImage::CoordinateFrame)digits[2]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 3 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) ((((((((pcl::RangeImage::CoordinateFrame)digits[2]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 4 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) (((pcl::RangeImage::CoordinateFrame)-1)*(((((((((pcl::RangeImage::CoordinateFrame)digits[3]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[2]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(pcl::RangeImage::CoordinateFrame) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(pcl::RangeImage::CoordinateFrame, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(pcl::RangeImage::CoordinateFrame) - 1 > 4 * PyLong_SHIFT) {
+                            return (pcl::RangeImage::CoordinateFrame) ((((((((((pcl::RangeImage::CoordinateFrame)digits[3]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[2]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[1]) << PyLong_SHIFT) | (pcl::RangeImage::CoordinateFrame)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(pcl::RangeImage::CoordinateFrame) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::RangeImage::CoordinateFrame, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(pcl::RangeImage::CoordinateFrame) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(pcl::RangeImage::CoordinateFrame, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            pcl::RangeImage::CoordinateFrame val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (pcl::RangeImage::CoordinateFrame) -1;
+        }
+    } else {
+        pcl::RangeImage::CoordinateFrame val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (pcl::RangeImage::CoordinateFrame) -1;
+        val = __Pyx_PyInt_As_pcl_3a__3a_RangeImage_3a__3a_CoordinateFrame(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to pcl::RangeImage::CoordinateFrame");
+    return (pcl::RangeImage::CoordinateFrame) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to pcl::RangeImage::CoordinateFrame");
+    return (pcl::RangeImage::CoordinateFrame) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
+    const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(size_t) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (size_t) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (size_t) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) {
+                            return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) {
+                            return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) {
+                            return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (size_t) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(size_t) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (size_t) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(size_t,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                            return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                            return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) {
+                            return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(size_t) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            size_t val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (size_t) -1;
+        }
+    } else {
+        size_t val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (size_t) -1;
+        val = __Pyx_PyInt_As_size_t(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to size_t");
+    return (size_t) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to size_t");
+    return (size_t) -1;
+}
+
+/* CIntFromPy */
+            static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+    const long neg_one = (long) -1, const_zero = (long) 0;
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if (sizeof(long) < sizeof(long)) {
+            __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return (long) val;
+        }
+    } else
+#endif
+    if (likely(PyLong_Check(x))) {
+        if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case  1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0])
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) {
+                            return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) {
+                            return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) {
+                            return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]));
+                        }
+                    }
+                    break;
+            }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+            if (unlikely(Py_SIZE(x) < 0)) {
+                goto raise_neg_overflow;
+            }
+#else
+            {
+                int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+                if (unlikely(result < 0))
+                    return (long) -1;
+                if (unlikely(result == 1))
+                    goto raise_neg_overflow;
+            }
+#endif
+            if (sizeof(long) <= sizeof(unsigned long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+            }
+        } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+            const digit* digits = ((PyLongObject*)x)->ob_digit;
+            switch (Py_SIZE(x)) {
+                case  0: return (long) 0;
+                case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
+                case  1: __PYX_VERIFY_RETURN_INT(long,  digit, +digits[0])
+                case -2:
+                    if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 2:
+                    if (8 * sizeof(long) > 1 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                            return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -3:
+                    if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 3:
+                    if (8 * sizeof(long) > 2 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                            return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case -4:
+                    if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+                case 4:
+                    if (8 * sizeof(long) > 3 * PyLong_SHIFT) {
+                        if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+                            __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+                        } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) {
+                            return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])));
+                        }
+                    }
+                    break;
+            }
+#endif
+            if (sizeof(long) <= sizeof(long)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+            } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) {
+                __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+            }
+        }
+        {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+            PyErr_SetString(PyExc_RuntimeError,
+                            "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+            long val;
+            PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+            if (likely(v) && !PyLong_Check(v)) {
+                PyObject *tmp = v;
+                v = PyNumber_Long(tmp);
+                Py_DECREF(tmp);
+            }
+ #endif
+            if (likely(v)) {
+                int one = 1; int is_little = (int)*(unsigned char *)&one;
+                unsigned char *bytes = (unsigned char *)&val;
+                int ret = _PyLong_AsByteArray((PyLongObject *)v,
+                                              bytes, sizeof(val),
+                                              is_little, !is_unsigned);
+                Py_DECREF(v);
+                if (likely(!ret))
+                    return val;
+            }
+#endif
+            return (long) -1;
+        }
+    } else {
+        long val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return (long) -1;
+        val = __Pyx_PyInt_As_long(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to long");
+    return (long) -1;
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to long");
+    return (long) -1;
+}
+
+/* PrintOne */
+            #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION < 3
+static int __Pyx_PrintOne(PyObject* f, PyObject *o) {
+    if (!f) {
+        if (!(f = __Pyx_GetStdout()))
+            return -1;
+    }
+    Py_INCREF(f);
+    if (PyFile_SoftSpace(f, 0)) {
+        if (PyFile_WriteString(" ", f) < 0)
+            goto error;
+    }
+    if (PyFile_WriteObject(o, f, Py_PRINT_RAW) < 0)
+        goto error;
+    if (PyFile_WriteString("\n", f) < 0)
+        goto error;
+    Py_DECREF(f);
+    return 0;
+error:
+    Py_DECREF(f);
+    return -1;
+    /* the line below is just to avoid C compiler
+     * warnings about unused functions */
+    return __Pyx_Print(f, NULL, 0);
+}
+#else
+static int __Pyx_PrintOne(PyObject* stream, PyObject *o) {
+    int res;
+    PyObject* arg_tuple = PyTuple_Pack(1, o);
+    if (unlikely(!arg_tuple))
+        return -1;
+    res = __Pyx_Print(stream, arg_tuple, 1);
+    Py_DECREF(arg_tuple);
+    return res;
+}
+#endif
+
+/* CheckBinaryVersion */
+            static int __Pyx_check_binary_version(void) {
+    char ctversion[4], rtversion[4];
+    PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
+    PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
+    if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
+        char message[200];
+        PyOS_snprintf(message, sizeof(message),
+                      "compiletime version %s of module '%.100s' "
+                      "does not match runtime version %s",
+                      ctversion, __Pyx_MODULE_NAME, rtversion);
+        return PyErr_WarnEx(NULL, message, 1);
+    }
+    return 0;
+}
+
+/* ModuleImport */
+            #ifndef __PYX_HAVE_RT_ImportModule
+#define __PYX_HAVE_RT_ImportModule
+static PyObject *__Pyx_ImportModule(const char *name) {
+    PyObject *py_name = 0;
+    PyObject *py_module = 0;
+    py_name = __Pyx_PyIdentifier_FromString(name);
+    if (!py_name)
+        goto bad;
+    py_module = PyImport_Import(py_name);
+    Py_DECREF(py_name);
+    return py_module;
+bad:
+    Py_XDECREF(py_name);
+    return 0;
+}
+#endif
+
+/* TypeImport */
+            #ifndef __PYX_HAVE_RT_ImportType
+#define __PYX_HAVE_RT_ImportType
+static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
+    size_t size, int strict)
+{
+    PyObject *py_module = 0;
+    PyObject *result = 0;
+    PyObject *py_name = 0;
+    char warning[200];
+    Py_ssize_t basicsize;
+#ifdef Py_LIMITED_API
+    PyObject *py_basicsize;
+#endif
+    py_module = __Pyx_ImportModule(module_name);
+    if (!py_module)
+        goto bad;
+    py_name = __Pyx_PyIdentifier_FromString(class_name);
+    if (!py_name)
+        goto bad;
+    result = PyObject_GetAttr(py_module, py_name);
+    Py_DECREF(py_name);
+    py_name = 0;
+    Py_DECREF(py_module);
+    py_module = 0;
+    if (!result)
+        goto bad;
+    if (!PyType_Check(result)) {
+        PyErr_Format(PyExc_TypeError,
+            "%.200s.%.200s is not a type object",
+            module_name, class_name);
+        goto bad;
+    }
+#ifndef Py_LIMITED_API
+    basicsize = ((PyTypeObject *)result)->tp_basicsize;
+#else
+    py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
+    if (!py_basicsize)
+        goto bad;
+    basicsize = PyLong_AsSsize_t(py_basicsize);
+    Py_DECREF(py_basicsize);
+    py_basicsize = 0;
+    if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
+        goto bad;
+#endif
+    if (!strict && (size_t)basicsize > size) {
+        PyOS_snprintf(warning, sizeof(warning),
+            "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
+    }
+    else if ((size_t)basicsize != size) {
+        PyErr_Format(PyExc_ValueError,
+            "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
+            module_name, class_name, basicsize, size);
+        goto bad;
+    }
+    return (PyTypeObject *)result;
+bad:
+    Py_XDECREF(py_module);
+    Py_XDECREF(result);
+    return NULL;
+}
+#endif
+
+/* InitStrings */
+            static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+    while (t->p) {
+        #if PY_MAJOR_VERSION < 3
+        if (t->is_unicode) {
+            *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL);
+        } else if (t->intern) {
+            *t->p = PyString_InternFromString(t->s);
+        } else {
+            *t->p = PyString_FromStringAndSize(t->s, t->n - 1);
+        }
+        #else
+        if (t->is_unicode | t->is_str) {
+            if (t->intern) {
+                *t->p = PyUnicode_InternFromString(t->s);
+            } else if (t->encoding) {
+                *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL);
+            } else {
+                *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1);
+            }
+        } else {
+            *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1);
+        }
+        #endif
+        if (!*t->p)
+            return -1;
+        ++t;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str));
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+#if PY_VERSION_HEX < 0x03030000
+        char* defenc_c;
+        PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+        if (!defenc) return NULL;
+        defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        {
+            char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+            char* c;
+            for (c = defenc_c; c < end; c++) {
+                if ((unsigned char) (*c) >= 128) {
+                    PyUnicode_AsASCIIString(o);
+                    return NULL;
+                }
+            }
+        }
+#endif
+        *length = PyBytes_GET_SIZE(defenc);
+        return defenc_c;
+#else
+        if (__Pyx_PyUnicode_READY(o) == -1) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+        if (PyUnicode_IS_ASCII(o)) {
+            *length = PyUnicode_GET_LENGTH(o);
+            return PyUnicode_AsUTF8(o);
+        } else {
+            PyUnicode_AsASCIIString(o);
+            return NULL;
+        }
+#else
+        return PyUnicode_AsUTF8AndSize(o, length);
+#endif
+#endif
+    } else
+#endif
+#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (PyInt_Check(x) || PyLong_Check(x))
+#else
+  if (PyLong_Check(x))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = PyNumber_Long(x);
+  }
+  #else
+  if (m && m->nb_int) {
+    name = "int";
+    res = PyNumber_Long(x);
+  }
+  #endif
+#else
+  res = PyNumber_Int(x);
+#endif
+  if (res) {
+#if PY_MAJOR_VERSION < 3
+    if (!PyInt_Check(res) && !PyLong_Check(res)) {
+#else
+    if (!PyLong_Check(res)) {
+#endif
+      PyErr_Format(PyExc_TypeError,
+                   "__%.4s__ returned non-%.4s (type %.200s)",
+                   name, name, Py_TYPE(res)->tp_name);
+      Py_DECREF(res);
+      return NULL;
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(x);
+  }
+#endif
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    const digit* digits = ((PyLongObject*)b)->ob_digit;
+    const Py_ssize_t size = Py_SIZE(b);
+    if (likely(__Pyx_sst_abs(size) <= 1)) {
+        ival = likely(size) ? digits[0] : 0;
+        if (size == -1) ival = -ival;
+        return ival;
+    } else {
+      switch (size) {
+         case 2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -2:
+           if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -3:
+           if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case 4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+         case -4:
+           if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) {
+             return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]));
+           }
+           break;
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+
+#endif /* Py_PYTHON_H */
diff --git a/pcl/_pcl_180.pyx b/pcl/_pcl_180.pyx
new file mode 100644
index 0000000..b4cc599
--- /dev/null
+++ b/pcl/_pcl_180.pyx
@@ -0,0 +1,160 @@
+# -*- coding: utf-8 -*-
+# cython: embedsignature=True
+
+from collections import Sequence
+import numbers
+import numpy as np
+cimport numpy as cnp
+
+cimport pcl_common as pcl_cmn
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus_180 as pcl_sc
+cimport pcl_features_180 as pcl_ftr
+cimport pcl_filters_180 as pcl_fil
+cimport pcl_range_image_180 as pcl_r_img
+cimport pcl_segmentation_180 as pclseg
+# cimport pcl_octree_180 as pcl_fil
+
+cimport cython
+# from cython.operator import dereference as deref
+from cython.operator cimport dereference as deref, preincrement as inc
+from cython cimport address
+
+from cpython cimport Py_buffer
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# cimport pcl_segmentation as pclseg
+
+from boost_shared_ptr cimport sp_assign
+
+cnp.import_array()
+
+### Enum ###
+
+## Enum Setting
+SAC_RANSAC = pcl_sc.SAC_RANSAC
+SAC_LMEDS = pcl_sc.SAC_LMEDS
+SAC_MSAC = pcl_sc.SAC_MSAC
+SAC_RRANSAC = pcl_sc.SAC_RRANSAC
+SAC_RMSAC = pcl_sc.SAC_RMSAC
+SAC_MLESAC = pcl_sc.SAC_MLESAC
+SAC_PROSAC = pcl_sc.SAC_PROSAC
+
+SACMODEL_PLANE = pcl_sc.SACMODEL_PLANE
+SACMODEL_LINE = pcl_sc.SACMODEL_LINE
+SACMODEL_CIRCLE2D = pcl_sc.SACMODEL_CIRCLE2D
+SACMODEL_CIRCLE3D = pcl_sc.SACMODEL_CIRCLE3D
+SACMODEL_SPHERE = pcl_sc.SACMODEL_SPHERE
+SACMODEL_CYLINDER = pcl_sc.SACMODEL_CYLINDER
+SACMODEL_CONE = pcl_sc.SACMODEL_CONE
+SACMODEL_TORUS = pcl_sc.SACMODEL_TORUS
+SACMODEL_PARALLEL_LINE = pcl_sc.SACMODEL_PARALLEL_LINE
+SACMODEL_PERPENDICULAR_PLANE = pcl_sc.SACMODEL_PERPENDICULAR_PLANE
+SACMODEL_PARALLEL_LINES = pcl_sc.SACMODEL_PARALLEL_LINES
+SACMODEL_NORMAL_PLANE = pcl_sc.SACMODEL_NORMAL_PLANE 
+SACMODEL_NORMAL_SPHERE = pcl_sc.SACMODEL_NORMAL_SPHERE
+SACMODEL_REGISTRATION = pcl_sc.SACMODEL_REGISTRATION
+SACMODEL_PARALLEL_PLANE = pcl_sc.SACMODEL_PARALLEL_PLANE
+SACMODEL_NORMAL_PARALLEL_PLANE = pcl_sc.SACMODEL_NORMAL_PARALLEL_PLANE
+SACMODEL_STICK = pcl_sc.SACMODEL_STICK
+
+### Enum Setting(define Class InternalType) ###
+
+# CythonCompareOp
+@cython.internal
+cdef class _CythonCompareOp_Type:
+    cdef:
+        readonly int GT
+        readonly int GE
+        readonly int LT
+        readonly int LE
+        readonly int EQ
+
+
+    def __cinit__(self):
+        self.GT = pcl_fil.COMPAREOP_GT
+        self.GE = pcl_fil.COMPAREOP_GE
+        self.LT = pcl_fil.COMPAREOP_LT
+        self.LE = pcl_fil.COMPAREOP_LE
+        self.EQ = pcl_fil.COMPAREOP_EQ
+
+CythonCompareOp_Type = _CythonCompareOp_Type()
+
+# RangeImage 
+# CythonCoordinateFrame
+@cython.internal
+cdef class _CythonCoordinateFrame_Type:
+    cdef:
+        readonly int CAMERA_FRAME
+        readonly int LASER_FRAME
+
+    def __cinit__(self):
+        self.CAMERA_FRAME = pcl_r_img.COORDINATEFRAME_CAMERA
+        self.LASER_FRAME = pcl_r_img.COORDINATEFRAME_LASER
+
+CythonCoordinateFrame_Type = _CythonCoordinateFrame_Type()
+
+# # features
+# # CythonBorderPolicy
+# @cython.internal
+# cdef class _CythonBorderPolicy_Type:
+#     cdef:
+#         readonly int BORDER_POLICY_IGNORE
+#         readonly int BORDER_POLICY_MIRROR
+# 
+#     def __cinit__(self):
+#         self.BORDER_POLICY_IGNORE = pcl_ftr.BORDERPOLICY2_IGNORE
+#         self.BORDER_POLICY_MIRROR = pcl_ftr.BORDERPOLICY2_MIRROR
+# 
+# CythonBorderPolicy_Type = _CythonBorderPolicy_Type()
+###
+
+
+# CythonNormalEstimationMethod
+# @cython.internal
+# cdef class _CythonNormalEstimationMethod_Type:
+#     cdef:
+#         readonly int COVARIANCE_MATRIX
+#         readonly int AVERAGE_3D_GRADIENT
+#         readonly int AVERAGE_DEPTH_CHANGE
+#         readonly int SIMPLE_3D_GRADIENT
+# 
+#     def __cinit__(self):
+#         self.COVARIANCE_MATRIX = pcl_ftr.ESTIMATIONMETHOD2_COVARIANCE_MATRIX
+#         self.AVERAGE_3D_GRADIENT = pcl_ftr.ESTIMATIONMETHOD2_AVERAGE_3D_GRADIENT
+#         self.AVERAGE_DEPTH_CHANGE = pcl_ftr.ESTIMATIONMETHOD2_AVERAGE_DEPTH_CHANGE
+#         self.SIMPLE_3D_GRADIENT = pcl_ftr.ESTIMATIONMETHOD2_SIMPLE_3D_GRADIENT
+# 
+# CythonNormalEstimationMethod_Type = _CythonNormalEstimationMethod_Type()
+###
+
+include "pxi/pxiInclude_180.pxi"
+
+include "pxi/PointCloud_PointXYZ_180.pxi"
+include "pxi/PointCloud_PointXYZI_180.pxi"
+include "pxi/PointCloud_PointXYZRGB_180.pxi"
+include "pxi/PointCloud_PointXYZRGBA_180.pxi"
+include "pxi/PointCloud_PointWithViewpoint.pxi"
+# include "pxi/PointCloud_Normal.pxi"
+include "pxi/PointCloud_PointNormal.pxi"
+
+
+### common ###
+def deg2rad(float alpha):
+    return pcl_cmn.deg2rad(alpha)
+
+def rad2deg(float alpha):
+    return pcl_cmn.rad2deg(alpha)
+
+# cdef double deg2rad(double alpha):
+#     return pcl_cmn.rad2deg(alpha)
+# 
+# cdef double rad2deg(double alpha):
+#     return pcl_cmn.rad2deg(alpha)
+# 
+# cdef float normAngle (float alpha):
+#     return pcl_cmn.normAngle(alpha)
+
diff --git a/pcl/bind.h b/pcl/bind.h
new file mode 100644
index 0000000..805cf0c
--- /dev/null
+++ b/pcl/bind.h
@@ -0,0 +1,12 @@
+#ifndef __BIND_CPP__
+#define __BIND_CPP__
+
+#include <iostream>
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <boost/signals2.hpp>
+
+// void some_callback(void* some_ptr);
+boost::signals2::connection register_callback(boost::function<void (void*)> callback);
+
+#endif
diff --git a/pcl/boost_function.pxd b/pcl/boost_function.pxd
new file mode 100644
index 0000000..f4c6583
--- /dev/null
+++ b/pcl/boost_function.pxd
@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+from libcpp cimport bool
+
+###############################################################################
+# Types
+###############################################################################
+
+# cdef extern from "boost/function/function.hpp" namespace "boost" nogil:
+cdef extern from "boost/function.hpp" namespace "boost" nogil:
+    cdef cppclass function[T]:
+        function()
+        function(T*)
+        
+        T* get()
+        bool unique()
+        long use_count()
+        void swap(shared_ptr[T])
+        void reset(T*)
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
diff --git a/pcl/boost_shared_ptr.pxd b/pcl/boost_shared_ptr.pxd
new file mode 100644
index 0000000..acf55f6
--- /dev/null
+++ b/pcl/boost_shared_ptr.pxd
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+from libcpp cimport bool
+
+###############################################################################
+# Types
+###############################################################################
+
+# cdef extern from "boost/smart_ptr/shared_ptr.hpp" namespace "boost" nogil:
+cdef extern from "boost/shared_ptr.hpp" namespace "boost" nogil:
+    cdef cppclass shared_ptr[T]:
+        shared_ptr()
+        shared_ptr(T*)
+        # shared_ptr(T*, T*)
+        # shared_ptr(T*, T*, T*)
+        # shared_ptr(weak_ptr[T])
+        # shared_ptr(weak_ptr[T], boost::detail::sp_nothrow_tag)
+        
+        T* get()
+        bool unique()
+        long use_count()
+        void swap(shared_ptr[T])
+        void reset(T*)
+
+cdef extern from "boost_shared_ptr_assign.h" nogil:
+     # void sp_assign(shared_ptr[cpp.PointCloud[cpp.PointXYZ]] &t, cpp.PointCloud[cpp.PointXYZ] *value)
+     void sp_assign[T](shared_ptr[T] &p, T *value)
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
diff --git a/pcl/boost_shared_ptr_assign.h b/pcl/boost_shared_ptr_assign.h
new file mode 100644
index 0000000..0150fb3
--- /dev/null
+++ b/pcl/boost_shared_ptr_assign.h
@@ -0,0 +1,11 @@
+#include <pcl/point_cloud.h>
+#include <pcl/point_types.h>
+
+namespace {
+    // Workaround for lack of operator= support in Cython.
+    template <typename T>
+    void sp_assign(boost::shared_ptr<T> &p, T *v)
+    {
+        p = boost::shared_ptr<T>(v);
+    }
+}
diff --git a/pcl/boost_signal2_connection.pxd b/pcl/boost_signal2_connection.pxd
new file mode 100644
index 0000000..b258894
--- /dev/null
+++ b/pcl/boost_signal2_connection.pxd
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+from libcpp cimport bool
+
+###############################################################################
+# Types
+###############################################################################
+
+# cdef extern from "boost/signals2.hpp" namespace "boost" nogil:
+# http://www.boost.org/doc/libs/1_63_0/doc/html/signals2/reference.html#header.boost.signals2.connection_hpp
+cdef extern from "boost/signals2.hpp" namespace "boost::signals2" nogil:
+    cdef cppclass connection[T]:
+        connection()
+
+# cdef extern from "boost/signals2.hpp" namespace "boost::signals2" nogil:
+#     cdef void swap(connection&, connection&)
+
+# cdef extern from "boost/signals2.hpp" namespace "boost::signals2" nogil:
+#     cdef class scoped_connection;
+
+# cdef extern from "boost/signals2.hpp" namespace "boost::signals2" nogil:
+#     cdef class deconstruct_access;
+#     cdef class postconstructor_invoker;
+#     cdef template<typename T> postconstructor_invoker<T> deconstruct();
+#     cdef template<typename T, typename A1> postconstructor_invoker<T> deconstruct(const A1 &);
+#     cdef template<typename T, typename A1, typename A2> postconstructor_invoker<T> deconstruct(const A1 &, const A2 &);
+#     cdef template<typename T, typename A1, typename A2, ..., typename AN> postconstructor_invoker<T> deconstruct(const A1 &, const A2 &, ..., const AN &);
+
+# cdef extern from "boost/signals2.hpp" namespace "boost::signals2" nogil:
+#     cdef class dummy_mutex;
+
+# Header <boost/signals2/last_value.hpp>
+#     cdef template<typename T> class last_value;
+#     cdef template<> class last_value<void>;
+#     cdef class no_slots_error;
+
+# Header <boost/signals2/mutex.hpp>
+#     cdef class mutex;
+
+# Header <boost/signals2/optional_last_value.hpp>
+#     cdef template<typename T> class optional_last_value;
+#     cdef template<> class optional_last_value<void>;
+
+# Header <boost/signals2/shared_connection_block.hpp>
+#     cdef class shared_connection_block;
+
+# Header <boost/signals2/signal.hpp>
+    # cdef enum connect_position { at_front, at_back };
+
+    # template<typename Signature, 
+    #          typename Combiner = boost::signals2::optional_last_value<R>, 
+    #          typename Group = int, typename GroupCompare = std::less<Group>, 
+    #          typename SlotFunction = boost::function<Signature>, 
+    #          typename ExtendedSlotFunction = boost::function<R (const connection &, T1, T2, ..., TN)>, 
+    #          typename Mutex = boost::signals2::mutex> 
+    #   class signal;
+    
+    # template<typename Signature, typename Combiner, typename Group, 
+    #          typename GroupCompare, typename SlotFunction, 
+    #          typename ExtendedSlotFunction, typename Mutex> 
+    #   void swap(signal<Signature, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex>&, 
+    #             signal<Signature, Combiner, Group, GroupCompare, SlotFunction, ExtendedSlotFunction, Mutex>&);
+
+# Header <boost/signals2/signal_base.hpp>
+    # cdef class signal_base;
+
+
+# Header <boost/signals2/signal_type.hpp>
+    # template<typename A0, typename A1 = boost::parameter::void_, 
+    #          typename A2 = boost::parameter::void_, 
+    #          typename A3 = boost::parameter::void_, 
+    #          typename A4 = boost::parameter::void_, 
+    #          typename A5 = boost::parameter::void_, 
+    #          typename A6 = boost::parameter::void_> 
+    #   class signal_type;
+    
+    # namespace keywords {
+    #   template<typename Signature> class signature_type;
+    #   template<typename Combiner> class combiner_type;
+    #   template<typename Group> class group_type;
+    #   template<typename GroupCompare> class group_compare_type;
+    #   template<typename SlotFunction> class slot_function_type;
+    #   template<typename ExtendedSlotFunction> class extended_slot_function_type;
+    #   template<typename Mutex> class mutex_type;
+    # 
+
+
+# Header <boost/signals2/slot.hpp>
+    # template<typename Signature, typename SlotFunction = boost::function<R (T1, T2, ..., TN)> > class slot;
+
+# Header <boost/signals2/slot_base.hpp>
+    # cdef class slot_base;
+    # cdef class expired_slot;
+
+# Header <boost/signals2/trackable.hpp>
+    # cdef class trackable;
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
diff --git a/pcl/eigen.pxd b/pcl/eigen.pxd
new file mode 100644
index 0000000..f33390d
--- /dev/null
+++ b/pcl/eigen.pxd
@@ -0,0 +1,150 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+from vector cimport vector as vector2
+
+# Cython C++ wrapper operator() overloading error
+# http://stackoverflow.com/questions/18690005/cython-c-wrapper-operator-overloading-error
+
+# Cython/Python/C++ - Inheritance: Passing Derived Class as Argument to Function expecting base class
+# http://stackoverflow.com/questions/28573479/cython-python-c-inheritance-passing-derived-class-as-argument-to-function-e
+###
+
+###############################################################################
+# Types
+###############################################################################
+
+# Array
+# cdef extern from "Eigen/Array" namespace "Eigen" nogil:
+###
+
+# Cholesky
+# cdef extern from "Eigen/Cholesky" namespace "Eigen" nogil:
+###
+
+# Core?
+# cdef extern from "Eigen/Core" namespace "Eigen" nogil:
+###
+
+# Dense
+# http://stackoverflow.com/questions/29913524/set-coefficient-element-of-eigenmatrix3d-in-cython
+cdef extern from "Eigen/Dense" namespace "Eigen":
+    # I'm also unsure if you want a Matrix3d or a Vector3d so I assumed matrix
+    cdef cppclass Matrix3d:
+        Matrix3d() except +
+        # NG
+        # double coeff(int row, int col)
+        double& element "operator()"(int row, int col)
+
+
+###
+
+# Eigen
+cdef extern from "Eigen/Eigen" namespace "Eigen" nogil:
+    cdef cppclass Matrix4f:
+        Matrix4f() except +
+        float *data()
+    cdef cppclass Matrix3f:
+        Matrix3f() except +
+        float coeff(int row, int col)
+        float *data()
+        double& element "operator()"(int row,int col)
+    cdef cppclass Vector4f:
+        float *data()
+    cdef cppclass Vector3f:
+        float *data()
+    cdef cppclass Vector3i:
+        int *data()
+    cdef cppclass Vector3d: 
+        Vector3d() except + 
+        Vector3d(double c0, double c1, double c2) except + 
+        double coeff(int row, int col) 
+    cdef cppclass Quaternionf:
+        float w()
+        float x()
+        float y()
+        float z()
+    cdef cppclass Affine3f:
+        Affine3f() except +
+        float *data()
+    cdef cppclass aligned_allocator[T]:
+        pass
+
+
+###
+
+# VectorXf
+
+ctypedef aligned_allocator[cpp.PointXYZ] aligned_allocator_t 
+ctypedef aligned_allocator[cpp.PointXYZI] aligned_allocator_PointXYZI_t 
+ctypedef aligned_allocator[cpp.PointXYZRGB] aligned_allocator_PointXYZRGB_t 
+ctypedef aligned_allocator[cpp.PointXYZRGBA] aligned_allocator_PointXYZRGBA_t 
+ctypedef vector2[cpp.PointXYZ, aligned_allocator_t] AlignedPointTVector_t
+ctypedef vector2[cpp.PointXYZI, aligned_allocator_PointXYZI_t] AlignedPointTVector_PointXYZI_t
+ctypedef vector2[cpp.PointXYZRGB, aligned_allocator_PointXYZRGB_t] AlignedPointTVector_PointXYZRGB_t
+ctypedef vector2[cpp.PointXYZRGBA, aligned_allocator_PointXYZRGBA_t] AlignedPointTVector_PointXYZRGBA_t
+
+# Eigen2Support?
+# cdef extern from "Eigen/Eigen2Support" namespace "Eigen" nogil:
+
+# Eigenvalues
+# cdef extern from "Eigen/Eigenvalues" namespace "Eigen" nogil:
+
+# Geometry
+cdef extern from "Eigen/Geometry" namespace "Eigen" nogil:
+    cdef cppclass Translation2f:
+        Translation2f() except +
+        Translation2f(float a, float b) except +
+    cdef cppclass Translation2d:
+        Translation2d() except +
+        Translation2d(double a, double b) except +
+    cdef cppclass Translation3f:
+        Translation3f() except +
+        Translation3f(float a, float b, float c) except +
+        float *data()
+    cdef cppclass Translation3d:
+        Translation3d() except +
+        Translation3d(double a, double b, double c) except +
+        double *data()
+
+# Householder
+# cdef extern from "Eigen/Householder" namespace "Eigen" nogil:
+
+# Jacobi
+# cdef extern from "Eigen/Jacobi" namespace "Eigen" nogil:
+
+# LeastSquares
+# cdef extern from "Eigen/LeastSquares" namespace "Eigen" nogil:
+
+# LU
+# cdef extern from "Eigen/LU" namespace "Eigen" nogil:
+
+# QR
+# cdef extern from "Eigen/QR" namespace "Eigen" nogil:
+
+# QtAlignedMalloc
+# cdef extern from "Eigen/QtAlignedMalloc" namespace "Eigen" nogil:
+
+# Sparse
+# cdef extern from "Eigen/Sparse" namespace "Eigen" nogil:
+
+# StdDeque
+# cdef extern from "Eigen/StdDeque" namespace "Eigen" nogil:
+
+# StdList
+# cdef extern from "Eigen/StdList" namespace "Eigen" nogil:
+
+# StdVector
+# cdef extern from "Eigen/StdVector" namespace "Eigen" nogil:
+
+# SVD
+# cdef extern from "Eigen/SVD" namespace "Eigen" nogil:
+
+###
+
diff --git a/pcl/grabber_callback.cpp b/pcl/grabber_callback.cpp
new file mode 100644
index 0000000..51e06e6
--- /dev/null
+++ b/pcl/grabber_callback.cpp
@@ -0,0 +1,26 @@
+#include "grabber_callback.h"
+
+namespace grabber_callback {
+
+PyLibCallBack::PyLibCallBack() 
+{
+    is_cy_call = true;
+};
+
+PyLibCallBack::PyLibCallBack(Method method, void *user_data)
+{
+	is_cy_call = true;
+	_method = method;
+    _user_data = user_data;
+};
+
+PyLibCallBack::~PyLibCallBack()
+{
+};
+
+double PyLibCallBack::cy_execute (void *parameter)
+{
+	return this->_method(parameter, _user_data);
+};
+
+} // namespace grabber_callback
\ No newline at end of file
diff --git a/pcl/grabber_callback.h b/pcl/grabber_callback.h
new file mode 100644
index 0000000..1cc060a
--- /dev/null
+++ b/pcl/grabber_callback.h
@@ -0,0 +1,33 @@
+#ifndef GRABBER_CALLBACK_H_
+#define GRABBER_CALLBACK_H_
+
+namespace grabber_callback
+{
+    class PyLibCallBack
+    {
+    public:
+        // This is wrapper of Python fuction.
+        typedef double (*Method)(void *param, void *user_data);
+
+        // Constructor
+    	PyLibCallBack();
+        PyLibCallBack(Method method, void *user_data);
+        // Destructor
+        virtual ~PyLibCallBack();
+
+        double cy_execute(void *parameter);
+
+        bool IsCythonCall()
+        {
+            return is_cy_call;
+        }
+
+    protected:
+        bool is_cy_call;
+
+    private:
+        Method _method;
+        void *_user_data;
+    };
+}
+#endif
\ No newline at end of file
diff --git a/pcl/grabber_callback.pxd b/pcl/grabber_callback.pxd
new file mode 100644
index 0000000..514e512
--- /dev/null
+++ b/pcl/grabber_callback.pxd
@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+# cimport pcl_defs as cpp
+from libcpp cimport bool
+
+ctypedef double (*Method)(void *param, void *user_data)
+
+cdef extern from "grabber_callback.h" namespace "grabber_callback":
+    cdef cppclass PyLibCallBack:
+        PyLibCallBack(Method method, void *user_data)
+        double cy_execute(void *parameter)
+
+# The pattern/converter method to be used for translating C typed prototype to a Python object call
+cdef inline double callback(void *parameter, void *method):
+    return (<object>method)(<object>parameter)
diff --git a/pcl/indexing.hpp b/pcl/indexing.hpp
index cc8952e..283a7ff 100644
--- a/pcl/indexing.hpp
+++ b/pcl/indexing.hpp
@@ -14,7 +14,7 @@ namespace {
     }
 
     template <typename T>
-    T *getptr_at(pcl::PointCloud<T> *pc, int i, int j)
+    T *getptr_at2(pcl::PointCloud<T> *pc, int i, int j)
     {
         return &(pc->at(i, j));
     }
diff --git a/pcl/indexing.pxd b/pcl/indexing.pxd
new file mode 100644
index 0000000..ad4638b
--- /dev/null
+++ b/pcl/indexing.pxd
@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+cimport pcl_defs as cpp
+# cimport pcl_PointCloud2_160 as cpp2
+
+###############################################################################
+# Types
+###############################################################################
+
+cdef extern from "indexing.hpp" nogil:
+# cdef extern from "indexing.hpp":
+    # Use these instead of operator[] or at.
+    PointCloudType *getptr [PointCloudType](cpp.PointCloud[PointCloudType] *, size_t)
+    PointCloudType *getptr_at [PointCloudType](cpp.PointCloud[PointCloudType] *, size_t) except +
+    PointCloudType *getptr_at2 [PointCloudType](cpp.PointCloud[PointCloudType] *, int, int) except +
+
+
+#cdef extern from "indexing_assign.h" nogil:
+#     #void sp_assign(shared_ptr[cpp.PointCloud[cpp.PointXYZ]] &t, cpp.PointCloud[cpp.PointXYZ] *value)
+#     #void sp_assign[T](shared_ptr[T] &p, T *value)
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/minipcl.cpp b/pcl/minipcl.cpp
index 6dd0153..11afe0c 100644
--- a/pcl/minipcl.cpp
+++ b/pcl/minipcl.cpp
@@ -2,13 +2,19 @@
 #include <pcl/features/normal_3d.h>
 #include <pcl/search/kdtree.h>
 #include <pcl/filters/extract_indices.h>
+#include <pcl/octree/octree_pointcloud.h>
+
+#include <pcl/features/vfh.h>
+#include <pcl/io/pcd_io.h>
 
 #include <Eigen/Dense>
 
+#include <pcl/features/integral_image_normal.h>
+
 #include "minipcl.h"
 
 // set ksearch and radius to < 0 to disable 
-void mpcl_compute_normals(pcl::PointCloud<pcl::PointXYZ> &cloud,
+void mpcl_compute_normals(const pcl::PointCloud<pcl::PointXYZ>& cloud,
                           int ksearch,
                           double searchRadius,
                           pcl::PointCloud<pcl::Normal> &out)
@@ -25,6 +31,59 @@ void mpcl_compute_normals(pcl::PointCloud<pcl::PointXYZ> &cloud,
     ne.compute (out);
 }
 
+void mpcl_compute_normals_PointXYZI(const pcl::PointCloud<pcl::PointXYZI>& cloud,
+                          int ksearch,
+                          double searchRadius,
+                          pcl::PointCloud<pcl::Normal> &out)
+{
+    pcl::search::KdTree<pcl::PointXYZI>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZI> ());
+    pcl::NormalEstimation<pcl::PointXYZI, pcl::Normal> ne;
+
+    ne.setSearchMethod (tree);
+    ne.setInputCloud (cloud.makeShared());
+    if (ksearch >= 0)
+        ne.setKSearch (ksearch);
+    if (searchRadius >= 0.0)
+        ne.setRadiusSearch (searchRadius);
+    ne.compute (out);
+}
+
+void mpcl_compute_normals_PointXYZRGB(const pcl::PointCloud<pcl::PointXYZRGB>& cloud,
+                          int ksearch,
+                          double searchRadius,
+                          pcl::PointCloud<pcl::Normal> &out)
+{
+    pcl::search::KdTree<pcl::PointXYZRGB>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZRGB> ());
+    pcl::NormalEstimation<pcl::PointXYZRGB, pcl::Normal> ne;
+
+    ne.setSearchMethod (tree);
+    ne.setInputCloud (cloud.makeShared());
+    if (ksearch >= 0)
+        ne.setKSearch (ksearch);
+    if (searchRadius >= 0.0)
+        ne.setRadiusSearch (searchRadius);
+    ne.compute (out);
+}
+
+
+void mpcl_compute_normals_PointXYZRGBA(const pcl::PointCloud<pcl::PointXYZRGBA>& cloud,
+                          int ksearch,
+                          double searchRadius,
+                          pcl::PointCloud<pcl::Normal> &out)
+{
+    pcl::search::KdTree<pcl::PointXYZRGBA>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZRGBA> ());
+    pcl::NormalEstimation<pcl::PointXYZRGBA, pcl::Normal> ne;
+
+    ne.setSearchMethod (tree);
+    ne.setInputCloud (cloud.makeShared());
+    if (ksearch >= 0)
+        ne.setKSearch (ksearch);
+    if (searchRadius >= 0.0)
+        ne.setRadiusSearch (searchRadius);
+    ne.compute (out);
+}
+
+// set ksearch and radius to < 0 to disable 
 void mpcl_sacnormal_set_axis(pcl::SACSegmentationFromNormals<pcl::PointXYZ, pcl::Normal> &sac,
                              double ax, double ay, double az)
 {
@@ -32,6 +91,28 @@ void mpcl_sacnormal_set_axis(pcl::SACSegmentationFromNormals<pcl::PointXYZ, pcl:
     sac.setAxis(vect);
 }
 
+void mpcl_sacnormal_set_axis_PointXYZI(pcl::SACSegmentationFromNormals<pcl::PointXYZI, pcl::Normal> &sac,
+                             double ax, double ay, double az)
+{
+    Eigen::Vector3f vect(ax,ay,az);
+    sac.setAxis(vect);
+}
+
+void mpcl_sacnormal_set_axis_PointXYZRGB(pcl::SACSegmentationFromNormals<pcl::PointXYZRGB, pcl::Normal> &sac,
+                             double ax, double ay, double az)
+{
+    Eigen::Vector3f vect(ax,ay,az);
+    sac.setAxis(vect);
+}
+
+void mpcl_sacnormal_set_axis_PointXYZRGBA(pcl::SACSegmentationFromNormals<pcl::PointXYZRGBA, pcl::Normal> &sac,
+                             double ax, double ay, double az)
+{
+    Eigen::Vector3f vect(ax,ay,az);
+    sac.setAxis(vect);
+}
+
+// 
 void mpcl_extract(pcl::PointCloud<pcl::PointXYZ>::Ptr &incloud,
                   pcl::PointCloud<pcl::PointXYZ> *outcloud,
                   pcl::PointIndices *indices,
@@ -44,3 +125,186 @@ void mpcl_extract(pcl::PointCloud<pcl::PointXYZ>::Ptr &incloud,
     ext.setNegative(negative);
     ext.filter(*outcloud);
 }
+
+void mpcl_extract_PointXYZI(pcl::PointCloud<pcl::PointXYZI>::Ptr &incloud,
+                   pcl::PointCloud<pcl::PointXYZI> *outcloud,
+                   pcl::PointIndices *indices,
+                   bool negative)
+{
+    pcl::PointIndices::Ptr indicesptr (indices);
+    pcl::ExtractIndices<pcl::PointXYZI> ext;
+    ext.setInputCloud(incloud);
+    ext.setIndices(indicesptr);
+    ext.setNegative(negative);
+    ext.filter(*outcloud);
+}
+
+void mpcl_extract_PointXYZRGB(pcl::PointCloud<pcl::PointXYZRGB>::Ptr &incloud,
+                   pcl::PointCloud<pcl::PointXYZRGB> *outcloud,
+                   pcl::PointIndices *indices,
+                   bool negative)
+{
+    pcl::PointIndices::Ptr indicesptr (indices);
+    pcl::ExtractIndices<pcl::PointXYZRGB> ext;
+    ext.setInputCloud(incloud);
+    ext.setIndices(indicesptr);
+    ext.setNegative(negative);
+    ext.filter(*outcloud);
+}
+
+void mpcl_extract_PointXYZRGBA(pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &incloud,
+                   pcl::PointCloud<pcl::PointXYZRGBA> *outcloud,
+                   pcl::PointIndices *indices,
+                   bool negative)
+{
+    pcl::PointIndices::Ptr indicesptr (indices);
+    pcl::ExtractIndices<pcl::PointXYZRGBA> ext;
+    ext.setInputCloud(incloud);
+    ext.setIndices(indicesptr);
+    ext.setNegative(negative);
+    ext.filter(*outcloud);
+}
+
+// EuclideanClusterExtraction
+// Octree
+// void mpcl_deleteVoxelAtPoint(pcl::octree::OctreePointCloud<pcl::PointXYZ>& inOctree, pcl::PointXYZ incloud)
+// {
+//     inOctree.deleteVoxelAtPoint(incloud);
+// }
+// 
+// void mpcl_deleteVoxelAtPoint(pcl::octree::OctreePointCloud<pcl::PointXYZI>& inOctree, pcl::PointXYZI incloud)
+// {
+//     inOctree.deleteVoxelAtPoint(incloud);
+// }
+// 
+// void mpcl_deleteVoxelAtPoint(pcl::octree::OctreePointCloud<pcl::PointXYZRGB>& inOctree, pcl::PointXYZRGB incloud)
+// {
+//     inOctree.deleteVoxelAtPoint(incloud);
+// }
+// 
+// void mpcl_deleteVoxelAtPoint(pcl::octree::OctreePointCloud<pcl::PointXYZRGBA>& inOctree, pcl::PointXYZRGBA incloud)
+// {
+//     inOctree.deleteVoxelAtPoint(incloud);
+// }
+// 
+// 
+// int mpcl_getOccupiedVoxelCenters(pcl::octree::OctreePointCloud<pcl::PointXYZ>& inOctree, pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &incloud, vector<pcl::PointXYZ, Eigen::aligned_allocator<pcl::PointXYZ> > alignPoint)
+// {
+//     return inOctree.getOccupiedVoxelCenters(alignPoint);
+// }
+// 
+// int mpcl_getOccupiedVoxelCenters(pcl::octree::OctreePointCloud<pcl::PointXYZI>& inOctree, pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &incloud, vector<pcl::PointXYZI, Eigen::aligned_allocator<pcl::PointXYZI> > alignPoint)
+// {
+//     return inOctree.getOccupiedVoxelCenters(alignPoint);
+// }
+// 
+// int mpcl_getOccupiedVoxelCenters(pcl::octree::OctreePointCloud<pcl::PointXYZRGB>& inOctree, pcl::PointCloud<pcl::PointXYZRGB>::Ptr &incloud, vector<pcl::PointXYZRGB, Eigen::aligned_allocator<pcl::PointXYZRGB> > alignPoint)
+// {
+//     return inOctree.getOccupiedVoxelCenters(alignPoint);
+// }
+// 
+// int mpcl_getOccupiedVoxelCenters(pcl::octree::OctreePointCloud<pcl::PointXYZRGBA>& inOctree, pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &incloud, vector<pcl::PointXYZRGBA, Eigen::aligned_allocator<pcl::PointXYZRGBA> > alignPoint)
+// {
+//     return inOctree.getOccupiedVoxelCenters(alignPoint);
+// }
+// 
+
+void mpcl_extract_VFH(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud)
+{
+    // http://virtuemarket-lab.blogspot.jp/2015/03/viewpoint-feature-histogram.html
+    // pcl::PointCloud<pcl::VFHSignature308>::Ptr Extract_VFH(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud)
+    pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal> ());
+    pcl::VFHEstimation<pcl::PointXYZ, pcl::Normal, pcl::VFHSignature308> vfh;
+    pcl::PointCloud<pcl::VFHSignature308>::Ptr vfhs (new pcl::PointCloud<pcl::VFHSignature308> ());
+    
+    // cloud_normals = surface_normals(cloud);
+    vfh.setInputCloud (cloud);
+    vfh.setInputNormals (cloud_normals);
+    
+    pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ> ());
+    vfh.setSearchMethod (tree);
+    
+    vfh.compute (*vfhs);
+    // return vfhs;
+}
+
+/*
+// pcl1.6 
+#include <pcl/keypoints/harris_keypoint3D.h>
+// use 1.7�`
+#include <pcl/keypoints/harris_3d.h>
+
+// HarrisKeypoint3D
+// NG 
+// outcloud set pcl::PointXYZI
+void mpcl_extract_HarrisKeypoint3D(pcl::PointCloud<pcl::PointXYZ>::Ptr &incloud,
+                                   pcl::PointCloud<pcl::PointXYZ> *outcloud)
+{
+    // pcl::HarrisKeypoint3D<pcl::PointXYZ, pcl::PointXYZ> detector;
+    pcl::HarrisKeypoint3D<pcl::PointXYZ, pcl::PointXYZI> detector;
+
+    detector.setInputCloud(incloud);
+
+    detector.setNonMaxSupression (true);
+    detector.setRadius (0.01);
+    // detector.setRadiusSearch (100);
+    // detector.setIndices(indicesptr);
+    
+    // NG
+    // detector.compute(*outcloud);
+
+    // OK
+    pcl::PointCloud<pcl::PointXYZI>::Ptr keypoints(new pcl::PointCloud<pcl::PointXYZI>());
+    detector.compute(*keypoints);
+}
+
+// HarrisKeypoint3D
+void mpcl_extract_HarrisKeypoint3D(pcl::PointCloud<pcl::PointXYZ>::Ptr &incloud,
+                                   pcl::PointCloud<pcl::PointXYZI> *outcloud)
+{
+    pcl::HarrisKeypoint3D<pcl::PointXYZ, pcl::PointXYZI> detector;
+
+    detector.setInputCloud(incloud);
+
+    detector.setNonMaxSupression (true);
+    detector.setRadius (0.01);
+    //detector.setRadiusSearch (100);
+
+    // detector.setIndices(indicesptr);
+    // detector.compute(*outcloud);
+    detector.compute(*outcloud);
+}
+*/
+
+// features
+// integral_image_normal.h
+void mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne)
+{
+    ne.setNormalEstimationMethod (ne.AVERAGE_3D_GRADIENT);
+}
+
+void mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne)
+{
+    ne.setNormalEstimationMethod (ne.COVARIANCE_MATRIX);
+}
+
+void mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne)
+{
+    ne.setNormalEstimationMethod (ne.AVERAGE_DEPTH_CHANGE);
+}
+
+void mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne)
+{
+    ne.setNormalEstimationMethod (ne.SIMPLE_3D_GRADIENT);
+}
+
+void mpcl_features_NormalEstimationMethod_compute(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne, pcl::PointCloud<pcl::Normal> &out)
+{
+    // NG : out Variant Function end error
+    printf("compute start.\n");
+    // �Q�ƃJ�E���g��NG?(�֐����������ɃG���[)
+    ne.compute (out);
+    // pcl 1.7.2 error
+    // printf("out = %p.\n", out);
+    printf("compute end.\n");
+}
diff --git a/pcl/minipcl.h b/pcl/minipcl.h
index b14c497..37c979d 100644
--- a/pcl/minipcl.h
+++ b/pcl/minipcl.h
@@ -3,18 +3,94 @@
 
 #include <pcl/point_types.h>
 #include <pcl/segmentation/sac_segmentation.h>
+#include <pcl/octree/octree_pointcloud.h>
 
-void mpcl_compute_normals(pcl::PointCloud<pcl::PointXYZ> &cloud,
+#include <vector>
+//
+void mpcl_compute_normals(const pcl::PointCloud<pcl::PointXYZ> &cloud,
+                          int ksearch,
+                          double searchRadius,
+                          pcl::PointCloud<pcl::Normal> &out);
+void mpcl_compute_normals_PointXYZI(const pcl::PointCloud<pcl::PointXYZI> &cloud,
                           int ksearch,
                           double searchRadius,
                           pcl::PointCloud<pcl::Normal> &out);
 
+void mpcl_compute_normals_PointXYZRGB(const pcl::PointCloud<pcl::PointXYZRGB> &cloud,
+                          int ksearch,
+                          double searchRadius,
+                          pcl::PointCloud<pcl::Normal> &out);
+
+void mpcl_compute_normals_PointXYZRGBA(const pcl::PointCloud<pcl::PointXYZRGBA> &cloud,
+                          int ksearch,
+                          double searchRadius,
+                          pcl::PointCloud<pcl::Normal> &out);
+
+// 
 void mpcl_sacnormal_set_axis(pcl::SACSegmentationFromNormals<pcl::PointXYZ, pcl::Normal> &sac,
                              double ax, double ay, double az);
 
+void mpcl_sacnormal_set_axis_PointXYZI(pcl::SACSegmentationFromNormals<pcl::PointXYZI, pcl::Normal> &sac,
+                             double ax, double ay, double az);
+
+void mpcl_sacnormal_set_axis_PointXYZRGB(pcl::SACSegmentationFromNormals<pcl::PointXYZRGB, pcl::Normal> &sac,
+                             double ax, double ay, double az);
+
+void mpcl_sacnormal_set_axis_PointXYZRGBA(pcl::SACSegmentationFromNormals<pcl::PointXYZRGBA, pcl::Normal> &sac,
+                             double ax, double ay, double az);
+
+
+//
 void mpcl_extract(pcl::PointCloud<pcl::PointXYZ>::Ptr &incloud,
                   pcl::PointCloud<pcl::PointXYZ> *outcloud,
                   pcl::PointIndices *indices,
                   bool negative);
 
-#endif
+void mpcl_extract_PointXYZI(pcl::PointCloud<pcl::PointXYZI>::Ptr &incloud,
+                  pcl::PointCloud<pcl::PointXYZI> *outcloud,
+                  pcl::PointIndices *indices,
+                  bool negative);
+
+void mpcl_extract_PointXYZRGB(pcl::PointCloud<pcl::PointXYZRGB>::Ptr &incloud,
+                  pcl::PointCloud<pcl::PointXYZRGB> *outcloud,
+                  pcl::PointIndices *indices,
+                  bool negative);
+
+void mpcl_extract_PointXYZRGBA(pcl::PointCloud<pcl::PointXYZRGBA>::Ptr &incloud,
+                  pcl::PointCloud<pcl::PointXYZRGBA> *outcloud,
+                  pcl::PointIndices *indices,
+                  bool negative);
+
+// Octree(OctreePointCloud)
+// void mpcl_deleteVoxelAtPoint(pcl::octree::OctreePointCloud<pcl::PointXYZ>& inOctree, pcl::PointXYZ incloud);
+// void mpcl_deleteVoxelAtPoint_PointXYZI(pcl::octree::OctreePointCloud<pcl::PointXYZI>& inOctree, pcl::PointXYZI incloud);
+// void mpcl_deleteVoxelAtPoint_PointXYZRGB(pcl::octree::OctreePointCloud<pcl::PointXYZRGB>& inOctree, pcl::PointXYZRGB incloud);
+// void mpcl_deleteVoxelAtPoint_PointXYZRGBA(pcl::octree::OctreePointCloud<pcl::PointXYZRGBA>& inOctree, pcl::PointXYZRGBA incloud);
+
+// int mpcl_getOccupiedVoxelCenters(pcl::octree::OctreePointCloud<pcl::PointXYZ>& inOctree, std::vector<pcl::PointXYZ, Eigen::aligned_allocator<pcl::PointXYZ> > alignPoint);
+// int mpcl_getOccupiedVoxelCenters_PointXYZI(pcl::octree::OctreePointCloud<pcl::PointXYZI>& inOctree, std::vector<pcl::PointXYZI, Eigen::aligned_allocator<pcl::PointXYZI> > alignPoint);
+// int mpcl_getOccupiedVoxelCenters_PointXYZRGB(pcl::octree::OctreePointCloud<pcl::PointXYZRGB>& inOctree, std::vector<pcl::PointXYZRGB, Eigen::aligned_allocator<pcl::PointXYZRGB> > alignPoint);
+// int mpcl_getOccupiedVoxelCenters_PointXYZRGBA(pcl::octree::OctreePointCloud<pcl::PointXYZRGBA>& inOctree, std::vector<pcl::PointXYZRGBA, Eigen::aligned_allocator<pcl::PointXYZRGBA> > alignPoint);
+
+// VFH
+void mpcl_extract_VFH(pcl::PointCloud<pcl::PointXYZ>::Ptr cloud);
+
+// // HarrisKeypoint3D
+// // NG(outcloud pcl::PointXYZI)
+// void mpcl_extract_HarrisKeypoint3D(pcl::PointCloud<pcl::PointXYZ>::Ptr &incloud, pcl::PointCloud<pcl::PointXYZ> *outcloud);
+// 
+// 
+// // HarrisKeypoint3D
+// void mpcl_extract_HarrisKeypoint3D(pcl::PointCloud<pcl::PointXYZ>::Ptr &incloud, pcl::PointCloud<pcl::PointXYZI> *outcloud);
+
+
+// Features
+// NormalEstimationMethod
+void mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne);
+void mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne);
+void mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne);
+void mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne);
+void mpcl_features_NormalEstimationMethod_compute(pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal> ne, pcl::PointCloud<pcl::Normal> &out);
+
+#endif // _MINIPCL_H_
+
diff --git a/pcl/pcl_PCLPointCloud2_172.pxd b/pcl/pcl_PCLPointCloud2_172.pxd
new file mode 100644
index 0000000..31c15fe
--- /dev/null
+++ b/pcl/pcl_PCLPointCloud2_172.pxd
@@ -0,0 +1,220 @@
+from libc.stddef cimport size_t

+

+from libcpp.vector cimport vector

+from libcpp.string cimport string

+from libcpp cimport bool

+

+# main

+cimport pcl_defs as cpp

+

+# boost

+from boost_shared_ptr cimport shared_ptr

+

+###############################################################################

+# Types

+###############################################################################

+

+# PCLHeader.h

+cdef extern from "pcl/PCLHeader.h" namespace "pcl":

+    cdef struct PCLHeader:

+        PCLHeader ()

+        unsigned int seq
+        unsigned long stamp
+        string frame_id
+


+
+# inline std::ostream& operator << (std::ostream& out, const PCLHeader &h)
+


+# typedef boost::shared_ptr<PCLHeader> HeaderPtr;
+# typedef boost::shared_ptr<PCLHeader const> HeaderConstPtr;
+ctypedef shared_ptr[PCLHeader] PCLHeaderPtr_t

+ctypedef shared_ptr[const PCLHeader] PCLHeaderConstPtr_t

+###

+

+# PCLImage.h

+cdef extern from "pcl/PCLImage.h" namespace "pcl":

+    cdef struct PCLImage:

+        PCLImage ()

+        PCLHeader header

+        unsigned int height

+        unsigned int width

+        string encoding

+        unsigned char is_bigendian

+        unsigned int step;

+        vector[unsigned int] data;

+

+

+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::PCLImage & v)

+

+ctypedef shared_ptr[PCLImage] PCLImagePtr_t

+ctypedef shared_ptr[const PCLImage] PCLImageConstPtr_t

+###

+

+# PCLPointField

+cdef extern from "pcl/PCLPointField.h" namespace "pcl":

+    cdef struct PCLPointField:

+        PCLPointField ()

+        string name

+        unsigned int offset

+        unsigned char datatype

+        unsigned int count

+

+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::PCLPointField & v)

+

+ctypedef shared_ptr[PCLPointField] PCLPointFieldPtr_t

+ctypedef shared_ptr[const PCLPointField] PCLPointFieldConstPtr_t

+###

+

+

+######

+# namespace pcl

+cdef extern from "pcl/PCLPointCloud2.h" namespace "pcl":

+    cdef struct PCLPointCloud2:

+        PointCloud2 ()

+        PCLHeader header

+        unsigned int height

+        unsigned int width

+        vector[PCLPointField] fields

+        unsigned char is_bigendian

+        unsigned int point_step

+        unsigned int row_step

+        vector[unsigned char] data

+        unsigned char is_dense

+

+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::PCLPointCloud2 &v)

+

+# ctypedef shared_ptr[PCLPointCloud2] PCLPointCloud2Ptr_t

+# ctypedef shared_ptr[const PCLPointCloud2] PCLPointCloud2ConstPtr_t

+ctypedef cpp.PointCloud[PCLPointCloud2] PointCloud_PCLPointCloud2_t

+ctypedef shared_ptr[cpp.PointCloud[PCLPointCloud2]] PointCloud_PCLPointCloud2Ptr_t

+###

+

+# pcl/conversions.h

+# namespace pcl

+# name space detail

+# // For converting template point cloud to message.

+# template<typename PointT>

+# struct FieldAdder

+# cdef extern from "pcl/conversions.h" namespace "pcl::detail":

+#     cdef struct FieldAdder[PointT]:

+#         FieldAdder (vector[PCLPointField]& fields)

+#         # template<typename U> void operator()

+#         vector[PCLPointField] &fields_

+# 

+# 

+###

+

+# cdef extern from "pcl/conversions.h" namespace "pcl::detail":

+#     cdef struct FieldMapper[PointT]:

+#         FieldMapper (const vector[PCLPointField] &fields, vector[FieldMapping] &map)

+#         # template<typename Tag> void operator ()

+#         const vector[PCLPointField] & fields_

+#         vector[FieldMapping] & map_

+# 

+#     inline bool fieldOrdering (const FieldMapping& a, const FieldMapping& b)

+###

+

+# pcl/conversions.h

+# namespace pcl

+# template<typename PointT> void createMapping (const std::vector<pcl::PCLPointField>& msg_fields, MsgFieldMap& field_map)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void createMapping [PointT](const vector[PCLPointField]& msg_fields, MsgFieldMap& field_map)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.

+# * \param[in] msg the PCLPointCloud2 binary blob

+# * \param[out] cloud the resultant pcl::PointCloud<T>

+# * \param[in] field_map a MsgFieldMap object

+# * \note Use fromPCLPointCloud2 (PCLPointCloud2, PointCloud<T>) directly or create you

+# * own MsgFieldMap using:

+# * \code

+# * MsgFieldMap field_map;

+# * createMapping<PointT> (msg.fields, field_map);

+# * \endcode

+# */

+# template <typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void fromPCLPointCloud2 [PointT](const PCLPointCloud2& msg, PointCloud[PointT] & cloud, const MsgFieldMap& field_map)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object.

+# * \param[in] msg the PCLPointCloud2 binary blob

+# * \param[out] cloud the resultant pcl::PointCloud<T>

+# */

+# template<typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void fromPCLPointCloud2 [PointT](const PCLPointCloud2& msg, PointCloud[PointT]& cloud)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Convert a pcl::PointCloud<T> object to a PCLPointCloud2 binary data blob.

+# * \param[in] cloud the input pcl::PointCloud<T>

+# * \param[out] msg the resultant PCLPointCloud2 binary blob

+# */

+# template<typename PointT> void toPCLPointCloud2 (const pcl::PointCloud<PointT>& cloud, pcl::PCLPointCloud2& msg)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void toPCLPointCloud2 [PointT](const PointCloud[PointT]& cloud, PCLPointCloud2& msg)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Copy the RGB fields of a PointCloud into pcl::PCLImage format

+#  * \param[in] cloud the point cloud message

+#  * \param[out] msg the resultant pcl::PCLImage

+#  * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>

+#  * \note will throw std::runtime_error if there is a problem

+#  */

+# template<typename CloudT> void toPCLPointCloud2 (const CloudT& cloud, pcl::PCLImage& msg)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void toPCLPointCloud2 [CloudT](const CloudT& cloud, PCLImage& msg)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** 

+# * \brief Copy the RGB fields of a PCLPointCloud2 msg into pcl::PCLImage format

+# * \param cloud the point cloud message

+# * \param msg the resultant pcl::PCLImage

+# * will throw std::runtime_error if there is a problem

+# */

+# inline void toPCLPointCloud2 (const pcl::PCLPointCloud2& cloud, pcl::PCLImage& msg)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void toPCLPointCloud2 (const PCLPointCloud2& cloud, PCLImage& msg)

+# 

+# 

+###

+

+###############################################################################

+# Enum

+###############################################################################

+

+cdef extern from "pcl/PCLPointField.h" namespace "pcl":

+    cdef enum:

+        INT8 = 1

+        UINT8 = 2

+        INT16 = 3

+        UINT16 = 4

+        INT32 = 5

+        UINT32 = 6

+        FLOAT32 = 7

+        FLOAT64 = 8

+

+###############################################################################

+# Activation

+###############################################################################

+

diff --git a/pcl/pcl_PCLPointCloud2_180.pxd b/pcl/pcl_PCLPointCloud2_180.pxd
new file mode 100644
index 0000000..31c15fe
--- /dev/null
+++ b/pcl/pcl_PCLPointCloud2_180.pxd
@@ -0,0 +1,220 @@
+from libc.stddef cimport size_t

+

+from libcpp.vector cimport vector

+from libcpp.string cimport string

+from libcpp cimport bool

+

+# main

+cimport pcl_defs as cpp

+

+# boost

+from boost_shared_ptr cimport shared_ptr

+

+###############################################################################

+# Types

+###############################################################################

+

+# PCLHeader.h

+cdef extern from "pcl/PCLHeader.h" namespace "pcl":

+    cdef struct PCLHeader:

+        PCLHeader ()

+        unsigned int seq
+        unsigned long stamp
+        string frame_id
+


+
+# inline std::ostream& operator << (std::ostream& out, const PCLHeader &h)
+


+# typedef boost::shared_ptr<PCLHeader> HeaderPtr;
+# typedef boost::shared_ptr<PCLHeader const> HeaderConstPtr;
+ctypedef shared_ptr[PCLHeader] PCLHeaderPtr_t

+ctypedef shared_ptr[const PCLHeader] PCLHeaderConstPtr_t

+###

+

+# PCLImage.h

+cdef extern from "pcl/PCLImage.h" namespace "pcl":

+    cdef struct PCLImage:

+        PCLImage ()

+        PCLHeader header

+        unsigned int height

+        unsigned int width

+        string encoding

+        unsigned char is_bigendian

+        unsigned int step;

+        vector[unsigned int] data;

+

+

+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::PCLImage & v)

+

+ctypedef shared_ptr[PCLImage] PCLImagePtr_t

+ctypedef shared_ptr[const PCLImage] PCLImageConstPtr_t

+###

+

+# PCLPointField

+cdef extern from "pcl/PCLPointField.h" namespace "pcl":

+    cdef struct PCLPointField:

+        PCLPointField ()

+        string name

+        unsigned int offset

+        unsigned char datatype

+        unsigned int count

+

+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::PCLPointField & v)

+

+ctypedef shared_ptr[PCLPointField] PCLPointFieldPtr_t

+ctypedef shared_ptr[const PCLPointField] PCLPointFieldConstPtr_t

+###

+

+

+######

+# namespace pcl

+cdef extern from "pcl/PCLPointCloud2.h" namespace "pcl":

+    cdef struct PCLPointCloud2:

+        PointCloud2 ()

+        PCLHeader header

+        unsigned int height

+        unsigned int width

+        vector[PCLPointField] fields

+        unsigned char is_bigendian

+        unsigned int point_step

+        unsigned int row_step

+        vector[unsigned char] data

+        unsigned char is_dense

+

+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::PCLPointCloud2 &v)

+

+# ctypedef shared_ptr[PCLPointCloud2] PCLPointCloud2Ptr_t

+# ctypedef shared_ptr[const PCLPointCloud2] PCLPointCloud2ConstPtr_t

+ctypedef cpp.PointCloud[PCLPointCloud2] PointCloud_PCLPointCloud2_t

+ctypedef shared_ptr[cpp.PointCloud[PCLPointCloud2]] PointCloud_PCLPointCloud2Ptr_t

+###

+

+# pcl/conversions.h

+# namespace pcl

+# name space detail

+# // For converting template point cloud to message.

+# template<typename PointT>

+# struct FieldAdder

+# cdef extern from "pcl/conversions.h" namespace "pcl::detail":

+#     cdef struct FieldAdder[PointT]:

+#         FieldAdder (vector[PCLPointField]& fields)

+#         # template<typename U> void operator()

+#         vector[PCLPointField] &fields_

+# 

+# 

+###

+

+# cdef extern from "pcl/conversions.h" namespace "pcl::detail":

+#     cdef struct FieldMapper[PointT]:

+#         FieldMapper (const vector[PCLPointField] &fields, vector[FieldMapping] &map)

+#         # template<typename Tag> void operator ()

+#         const vector[PCLPointField] & fields_

+#         vector[FieldMapping] & map_

+# 

+#     inline bool fieldOrdering (const FieldMapping& a, const FieldMapping& b)

+###

+

+# pcl/conversions.h

+# namespace pcl

+# template<typename PointT> void createMapping (const std::vector<pcl::PCLPointField>& msg_fields, MsgFieldMap& field_map)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void createMapping [PointT](const vector[PCLPointField]& msg_fields, MsgFieldMap& field_map)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.

+# * \param[in] msg the PCLPointCloud2 binary blob

+# * \param[out] cloud the resultant pcl::PointCloud<T>

+# * \param[in] field_map a MsgFieldMap object

+# * \note Use fromPCLPointCloud2 (PCLPointCloud2, PointCloud<T>) directly or create you

+# * own MsgFieldMap using:

+# * \code

+# * MsgFieldMap field_map;

+# * createMapping<PointT> (msg.fields, field_map);

+# * \endcode

+# */

+# template <typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void fromPCLPointCloud2 [PointT](const PCLPointCloud2& msg, PointCloud[PointT] & cloud, const MsgFieldMap& field_map)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object.

+# * \param[in] msg the PCLPointCloud2 binary blob

+# * \param[out] cloud the resultant pcl::PointCloud<T>

+# */

+# template<typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void fromPCLPointCloud2 [PointT](const PCLPointCloud2& msg, PointCloud[PointT]& cloud)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Convert a pcl::PointCloud<T> object to a PCLPointCloud2 binary data blob.

+# * \param[in] cloud the input pcl::PointCloud<T>

+# * \param[out] msg the resultant PCLPointCloud2 binary blob

+# */

+# template<typename PointT> void toPCLPointCloud2 (const pcl::PointCloud<PointT>& cloud, pcl::PCLPointCloud2& msg)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void toPCLPointCloud2 [PointT](const PointCloud[PointT]& cloud, PCLPointCloud2& msg)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** \brief Copy the RGB fields of a PointCloud into pcl::PCLImage format

+#  * \param[in] cloud the point cloud message

+#  * \param[out] msg the resultant pcl::PCLImage

+#  * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>

+#  * \note will throw std::runtime_error if there is a problem

+#  */

+# template<typename CloudT> void toPCLPointCloud2 (const CloudT& cloud, pcl::PCLImage& msg)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void toPCLPointCloud2 [CloudT](const CloudT& cloud, PCLImage& msg)

+# 

+# 

+###

+

+# pcl/conversions.h

+# namespace pcl

+# /** 

+# * \brief Copy the RGB fields of a PCLPointCloud2 msg into pcl::PCLImage format

+# * \param cloud the point cloud message

+# * \param msg the resultant pcl::PCLImage

+# * will throw std::runtime_error if there is a problem

+# */

+# inline void toPCLPointCloud2 (const pcl::PCLPointCloud2& cloud, pcl::PCLImage& msg)

+# cdef extern from "pcl/conversions.h" namespace "pcl":

+#     void toPCLPointCloud2 (const PCLPointCloud2& cloud, PCLImage& msg)

+# 

+# 

+###

+

+###############################################################################

+# Enum

+###############################################################################

+

+cdef extern from "pcl/PCLPointField.h" namespace "pcl":

+    cdef enum:

+        INT8 = 1

+        UINT8 = 2

+        INT16 = 3

+        UINT16 = 4

+        INT32 = 5

+        UINT32 = 6

+        FLOAT32 = 7

+        FLOAT64 = 8

+

+###############################################################################

+# Activation

+###############################################################################

+

diff --git a/pcl/pcl_People_172.pxd b/pcl/pcl_People_172.pxd
new file mode 100644
index 0000000..bb5a1ab
--- /dev/null
+++ b/pcl/pcl_People_172.pxd
@@ -0,0 +1,772 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+cimport eigen as eigen3
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+### base class ###
+
+# person_classifier.h
+# namespace pcl
+# namespace people
+# template <typename PointT> class PersonClassifier;
+# template <typename PointT>
+# class PersonClassifier
+cdef extern from "pcl/people/person_classifier.h" namespace "pcl::people":
+    cdef cppclass PersonClassifier:
+        PersonClassifier()
+        # protected:
+        # /** \brief Height of the image patch to classify. */
+        # int window_height_;          
+        # /** \brief Width of the image patch to classify. */
+        # int window_width_;          
+        # /** \brief SVM offset. */
+        # float SVM_offset_;          
+        # /** \brief SVM weights vector. */
+        # std::vector<float> SVM_weights_;  
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # /** \brief Load SVM parameters from a text file. 
+        # * \param[in] svm_filename Filename containing SVM parameters.
+        # * \return true if SVM has been correctly set, false otherwise.
+        bool loadSVMFromFile (string svm_filename)
+        # * \brief Set trained SVM for person confidence estimation.
+        # * \param[in] window_height Detection window height.
+        # * \param[in] window_width Detection window width.
+        # * \param[in] SVM_weights SVM weights vector.
+        # * \param[in] SVM_offset SVM offset.
+        void setSVM (int window_height, int window_width, vector[float] SVM_weights, float SVM_offset)
+        # * \brief Get trained SVM for person confidence estimation.
+        # * \param[out] window_height Detection window height.
+        # * \param[out] window_width Detection window width.
+        # * \param[out] SVM_weights SVM weights vector.
+        # * \param[out] SVM_offset SVM offset.
+        # void getSVM (int& window_height, int& window_width, vector[float]& SVM_weights, float& SVM_offset);
+        # * \brief Resize an image represented by a pointcloud containing RGB information.
+        # * \param[in] input_image A pointer to a pointcloud containing RGB information.
+        # * \param[out] output_image A pointer to the output pointcloud.
+        # * \param[in] width Output width.
+        # * \param[in] height Output height.
+        # void resize (PointCloudPtr& input_image, PointCloudPtr& output_image, int width, int height)
+        # * \brief Copies an image and makes a black border around it, where the source image is not present.
+        # * \param[in] input_image A pointer to a pointcloud containing RGB information.
+        # * \param[out] output_image A pointer to the output pointcloud.
+        # * \param[in] xmin x coordinate of the top-left point of the bbox to copy from the input image.
+        # * \param[in] ymin y coordinate of the top-left point of the bbox to copy from the input image.
+        # * \param[in] width Output width.
+        # * \param[in] height Output height.
+        # void copyMakeBorder (PointCloudPtr& input_image, PointCloudPtr& output_image, int xmin, int ymin, int width, int height)
+        # * \brief Classify the given portion of image.
+        # * \param[in] height The height of the image patch to classify, in pixels.
+        # * \param[in] xc The x-coordinate of the center of the image patch to classify, in pixels.
+        # * \param[in] yc The y-coordinate of the center of the image patch to classify, in pixels.
+        # * \param[in] image The whole image (pointer to a point cloud containing RGB information) containing the object to classify.
+        # * \return The classification score given by the SVM.
+        # double evaluate (float height, float xc, float yc, PointCloudPtr& image)
+        # * \brief Compute person confidence for a given PersonCluster.
+        # * \param[in] image The input image (pointer to a point cloud containing RGB information).
+        # * \param[in] bottom Theoretical bottom point of the cluster projected to the image.
+        # * \param[in] top Theoretical top point of the cluster projected to the image.
+        # * \param[in] centroid Theoretical centroid point of the cluster projected to the image.
+        # * \param[in] vertical If true, the sensor is considered to be vertically placed (portrait mode).
+        # * \return The person confidence.
+        # double evaluate (PointCloudPtr& image, Eigen::Vector3f& bottom, Eigen::Vector3f& top, Eigen::Vector3f& centroid, bool vertical)
+###
+
+
+# person_cluster.h
+# namespace pcl
+# namespace people
+# /** \brief @b PersonCluster represents a class for representing information about a cluster containing a person.
+#  * \author Filippo Basso, Matteo Munaro
+#  * \ingroup people
+#  */
+# template <typename PointT> class PersonCluster;
+# template <typename PointT> bool operator<(const PersonCluster<PointT>& c1, const PersonCluster<PointT>& c2);
+# 
+# template <typename PointT>
+# class PersonCluster
+cdef extern from "pcl/people/person_cluster.h" namespace "pcl::people":
+    cdef cppclass PersonCluster:
+        PersonClassifier()
+        # PersonCluster (
+        # const PointCloudPtr& input_cloud,
+        # const pcl::PointIndices& indices,
+        # const Eigen::VectorXf& ground_coeffs,
+        # float sqrt_ground_coeffs,
+        # bool head_centroid,
+        # bool vertical = false);
+        # protected:
+        # bool head_centroid_;
+        # /** \brief Minimum x coordinate of the cluster points. */
+        # float min_x_;
+        # /** \brief Minimum y coordinate of the cluster points. */
+        # float min_y_;
+        # /** \brief Minimum z coordinate of the cluster points. */
+        # float min_z_;
+        # /** \brief Maximum x coordinate of the cluster points. */
+        # float max_x_;
+        # /** \brief Maximum y coordinate of the cluster points. */
+        # float max_y_;
+        # /** \brief Maximum z coordinate of the cluster points. */
+        # float max_z_;
+        # /** \brief Sum of x coordinates of the cluster points. */
+        # float sum_x_;
+        # /** \brief Sum of y coordinates of the cluster points. */
+        # float sum_y_;
+        # /** \brief Sum of z coordinates of the cluster points. */
+        # float sum_z_;
+        # /** \brief Number of cluster points. */
+        # int n_;
+        # /** \brief x coordinate of the cluster centroid. */
+        # float c_x_;
+        # /** \brief y coordinate of the cluster centroid. */
+        # float c_y_;
+        # /** \brief z coordinate of the cluster centroid. */
+        # float c_z_;
+        # /** \brief Cluster height from the ground plane. */
+        # float height_;
+        # /** \brief Cluster distance from the sensor. */
+        # float distance_;
+        # /** \brief Cluster centroid horizontal angle with respect to z axis. */
+        # float angle_;
+        # /** \brief Maximum angle of the cluster points. */
+        # float angle_max_;
+        # /** \brief Minimum angle of the cluster points. */
+        # float angle_min_;
+        # /** \brief Cluster top point. */
+        # Eigen::Vector3f top_;
+        # /** \brief Cluster bottom point. */
+        # Eigen::Vector3f bottom_;
+        # /** \brief Cluster centroid. */
+        # Eigen::Vector3f center_;
+        # /** \brief Theoretical cluster top. */
+        # Eigen::Vector3f ttop_;
+        # /** \brief Theoretical cluster bottom (lying on the ground plane). */
+        # Eigen::Vector3f tbottom_;
+        # /** \brief Theoretical cluster center (between ttop_ and tbottom_). */
+        # Eigen::Vector3f tcenter_;
+        # /** \brief Vector containing the minimum coordinates of the cluster. */
+        # Eigen::Vector3f min_;
+        # /** \brief Vector containing the maximum coordinates of the cluster. */
+        # Eigen::Vector3f max_;
+        # /** \brief Point cloud indices of the cluster points. */
+        # pcl::PointIndices points_indices_;
+        # /** \brief If true, the sensor is considered to be vertically placed (portrait mode). */
+        # bool vertical_;
+        # /** \brief PersonCluster HOG confidence. */
+        # float person_confidence_;
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # * \brief Returns the height of the cluster.
+        # * \return the height of the cluster.
+        float getHeight ();
+        # * \brief Update the height of the cluster.
+        # * \param[in] ground_coeffs The coefficients of the ground plane.
+        # * \return the height of the cluster.
+        # float updateHeight (const Eigen::VectorXf& ground_coeffs);
+        # * \brief Update the height of the cluster.
+        # * \param[in] ground_coeffs The coefficients of the ground plane.
+        # * \param[in] sqrt_ground_coeffs The norm of the vector [a, b, c] where a, b and c are the first
+        # * three coefficients of the ground plane (ax + by + cz + d = 0).
+        # * \return the height of the cluster.
+        # float updateHeight (const Eigen::VectorXf& ground_coeffs, float sqrt_ground_coeffs);
+        # * \brief Returns the distance of the cluster from the sensor.
+        # * \return the distance of the cluster (its centroid) from the sensor without considering the
+        # * y dimension.
+        float getDistance ()
+        # * \brief Returns the angle formed by the cluster's centroid with respect to the sensor (in radians).
+        # * \return the angle formed by the cluster's centroid with respect to the sensor (in radians).
+        float getAngle ()
+        # * \brief Returns the minimum angle formed by the cluster with respect to the sensor (in radians).
+        # * \return the minimum angle formed by the cluster with respect to the sensor (in radians).
+        float getAngleMin ()
+        # * \brief Returns the maximum angle formed by the cluster with respect to the sensor (in radians).
+        # * \return the maximum angle formed by the cluster with respect to the sensor (in radians).
+        float getAngleMax ()
+        # * \brief Returns the indices of the point cloud points corresponding to the cluster.
+        # * \return the indices of the point cloud points corresponding to the cluster.
+        # pcl::PointIndices& getIndices ();
+        # * \brief Returns the theoretical top point.
+        # * \return the theoretical top point.
+        # Eigen::Vector3f& getTTop ();
+        # * \brief Returns the theoretical bottom point.
+        # * \return the theoretical bottom point.
+        # Eigen::Vector3f& getTBottom ();
+        # * \brief Returns the theoretical centroid (at half height).
+        # * \return the theoretical centroid (at half height).
+        # Eigen::Vector3f& getTCenter ();
+        # * \brief Returns the top point.
+        # * \return the top point.
+        # Eigen::Vector3f& getTop ();
+        # * \brief Returns the bottom point.
+        # * \return the bottom point.
+        # Eigen::Vector3f& getBottom ();
+        # * \brief Returns the centroid.
+        # * \return the centroid.
+        # Eigen::Vector3f& getCenter ();  
+        # //Eigen::Vector3f& getTMax();
+        # * \brief Returns the point formed by min x, min y and min z.
+        # * \return the point formed by min x, min y and min z.
+        # Eigen::Vector3f& getMin ();
+        # * \brief Returns the point formed by max x, max y and max z.
+        # * \return the point formed by max x, max y and max z.
+        # Eigen::Vector3f& getMax ();
+        # /**
+        # * \brief Returns the HOG confidence.
+        # * \return the HOG confidence.
+        # */
+        # float
+        # getPersonConfidence ();
+        # /**
+        # * \brief Returns the number of points of the cluster.
+        # * \return the number of points of the cluster.
+        # */
+        # int getNumberPoints ();
+        # /**
+        # * \brief Sets the cluster height.
+        # * \param[in] height
+        # */
+        # void setHeight (float height);
+        # /**
+        # * \brief Sets the HOG confidence.
+        # * \param[in] confidence
+        # */
+        # void setPersonConfidence (float confidence);
+        # /**
+        # * \brief Draws the theoretical 3D bounding box of the cluster in the PCL visualizer.
+        # * \param[in] viewer PCL visualizer.
+        # * \param[in] person_number progressive number representing the person.
+        # */
+        # void drawTBoundingBox (pcl::visualization::PCLVisualizer& viewer, int person_number);
+        # /**
+        # * \brief For sorting purpose: sort by distance.
+        # */
+        # friend bool operator< <>(const PersonCluster<PointT>& c1, const PersonCluster<PointT>& c2);
+        # protected:
+        # /**
+        # * \brief PersonCluster initialization.
+        # */
+        # void init(
+        #   const PointCloudPtr& input_cloud,
+        #   const pcl::PointIndices& indices,
+        #   const Eigen::VectorXf& ground_coeffs,
+        #   float sqrt_ground_coeffs,
+        #   bool head_centroid,
+        #   bool vertical);
+###
+
+
+# ground_based_people_detection_app.h
+# namespace pcl
+# namespace people
+# template <typename PointT>
+# class GroundBasedPeopleDetectionApp
+# public:
+cdef extern from "pcl/people/ground_based_people_detection_app.h" namespace "pcl::people":
+    cdef cppclass GroundBasedPeopleDetectionApp[PointT]:
+        GroundBasedPeopleDetectionApp()
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # * \brief Set the pointer to the input cloud.
+        # * \param[in] cloud A pointer to the input cloud.
+        # void setInputCloud (PointCloudPtr& cloud);
+        void setInputCloud (sharedPtr[cpp.PointCloud[PointT]] cloud)
+        #  * \brief Set the ground coefficients.
+        #  * \param[in] ground_coeffs Vector containing the four plane coefficients.
+        # void setGround (Eigen::VectorXf& ground_coeffs);
+        #  * \brief Set the transformation matrix, which is used in order to transform the given point cloud, the ground plane and the intrinsics matrix to the internal coordinate frame.
+        #  * \param[in] cloud A pointer to the input cloud.
+        void setTransformation (eigen3.Matrix3f& transformation);
+        #  * \brief Set sampling factor. 
+        #  * \param[in] sampling_factor Value of the downsampling factor (in each dimension) which is applied to the raw point cloud (default = 1.).
+        void setSamplingFactor (int sampling_factor);
+        #  * \brief Set voxel size. 
+        #  * \param[in] voxel_size Value of the voxel dimension (default = 0.06m.).
+        void setVoxelSize (float voxel_size);
+        #  * \brief Set intrinsic parameters of the RGB camera.
+        #  * \param[in] intrinsics_matrix RGB camera intrinsic parameters matrix.
+        void setIntrinsics (eigen3.Matrix3f intrinsics_matrix);
+        #  * \brief Set SVM-based person classifier.
+        #  * \param[in] person_classifier Needed for people detection on RGB data.
+        # void setClassifier (pcl::people::PersonClassifier<pcl::RGB> person_classifier);
+        #  * \brief Set the field of view of the point cloud in z direction.
+        #  * \param[in] min The beginning of the field of view in z-direction, should be usually set to zero.
+        #  * \param[in] max The end of the field of view in z-direction.
+        void setFOV (float min, float max)
+        #  * \brief Set sensor orientation (vertical = true means portrait mode, vertical = false means landscape mode).
+        #  * \param[in] vertical Set landscape/portait camera orientation (default = false).
+        void setSensorPortraitOrientation (bool vertical)
+        #  * \brief Set head_centroid_ to true (person centroid is in the head) or false (person centroid is the whole body centroid).
+        #  * \param[in] head_centroid Set the location of the person centroid (head or body center) (default = true).
+        void setHeadCentroid (bool head_centroid)
+        #  * \brief Set minimum and maximum allowed height and width for a person cluster.
+        #  * \param[in] min_height Minimum allowed height for a person cluster (default = 1.3).
+        #  * \param[in] max_height Maximum allowed height for a person cluster (default = 2.3).
+        #  * \param[in] min_width Minimum width for a person cluster (default = 0.1).
+        #  * \param[in] max_width Maximum width for a person cluster (default = 8.0).
+        void setPersonClusterLimits (float min_height, float max_height, float min_width, float max_width)
+        #  * \brief Set minimum distance between persons' heads.
+        #  * \param[in] heads_minimum_distance Minimum allowed distance between persons' heads (default = 0.3).
+        void setMinimumDistanceBetweenHeads (float heads_minimum_distance)
+        #  * \brief Get the minimum and maximum allowed height and width for a person cluster.
+        #  * \param[out] min_height Minimum allowed height for a person cluster.
+        #  * \param[out] max_height Maximum allowed height for a person cluster.
+        #  * \param[out] min_width Minimum width for a person cluster.
+        #  * \param[out] max_width Maximum width for a person cluster.
+        void getPersonClusterLimits (float& min_height, float& max_height, float& min_width, float& max_width);
+        #   * \brief Get minimum and maximum allowed number of points for a person cluster.
+        #   * \param[out] min_points Minimum allowed number of points for a person cluster.
+        #   * \param[out] max_points Maximum allowed number of points for a person cluster.
+        void getDimensionLimits (int& min_points, int& max_points)
+        #   * \brief Get minimum distance between persons' heads.
+        float getMinimumDistanceBetweenHeads ()
+        #   * \brief Get floor coefficients.
+        # Eigen::VectorXf getGround ();
+        #   * \brief Get the filtered point cloud.
+        # PointCloudPtr getFilteredCloud ();
+        #   * \brief Get pointcloud after voxel grid filtering and ground removal.
+        # PointCloudPtr getNoGroundCloud ();
+        #   * \brief Extract RGB information from a point cloud and output the corresponding RGB point cloud.
+        #   * \param[in] input_cloud A pointer to a point cloud containing also RGB information.
+        #   * \param[out] output_cloud A pointer to a RGB point cloud.
+        # void extractRGBFromPointCloud (PointCloudPtr input_cloud, pcl::PointCloud<pcl::RGB>::Ptr& output_cloud);
+        #   * \brief Swap rows/cols dimensions of a RGB point cloud (90 degrees counterclockwise rotation).
+        #   * \param[in,out] cloud A pointer to a RGB point cloud.
+        # void swapDimensions (pcl::PointCloud<pcl::RGB>::Ptr& cloud);
+        #   * \brief Estimates min_points_ and max_points_ based on the minimal and maximal cluster size and the voxel size.
+        void updateMinMaxPoints ()
+        #   * \brief Applies the transformation to the input point cloud.
+        void applyTransformationPointCloud ()
+        #   * \brief Applies the transformation to the ground plane.
+        void applyTransformationGround ()
+        #   * \brief Applies the transformation to the intrinsics matrix.
+        void applyTransformationIntrinsics ()
+        #   * \brief Reduces the input cloud to one point per voxel and limits the field of view.
+        void filter ()
+        #   * \brief Perform people detection on the input data and return people clusters information.
+        #   * \param[out] clusters Vector of PersonCluster.
+        #   * \return true if the compute operation is successful, false otherwise.
+        # bool compute (std::vector<pcl::people::PersonCluster<PointT> >& clusters);
+        # protected:
+        # /** \brief sampling factor used to downsample the point cloud */
+        # int sampling_factor_; 
+        # /** \brief voxel size */
+        # float voxel_size_;                  
+        # /** \brief ground plane coefficients */
+        # Eigen::VectorXf ground_coeffs_;
+        # /** \brief flag stating whether the ground coefficients have been set or not */
+        # bool ground_coeffs_set_;
+        # /** \brief the transformed ground coefficients */
+        # Eigen::VectorXf ground_coeffs_transformed_;
+        # /** \brief ground plane normalization factor */
+        # float sqrt_ground_coeffs_;
+        # /** \brief rotation matrix which transforms input point cloud to internal people tracker coordinate frame */
+        # Eigen::Matrix3f transformation_;
+        # /** \brief flag stating whether the transformation matrix has been set or not */
+        # bool transformation_set_;
+        # /** \brief pointer to the input cloud */
+        # PointCloudPtr cloud_;
+        # /** \brief pointer to the filtered cloud */
+        # PointCloudPtr cloud_filtered_;
+        # /** \brief pointer to the cloud after voxel grid filtering and ground removal */
+        # PointCloudPtr no_ground_cloud_;              
+        # /** \brief pointer to a RGB cloud corresponding to cloud_ */
+        # pcl::PointCloud<pcl::RGB>::Ptr rgb_image_;      
+        # /** \brief person clusters maximum height from the ground plane */
+        # float max_height_;                  
+        # /** \brief person clusters minimum height from the ground plane */
+        # float min_height_;
+        # /** \brief person clusters maximum width, used to estimate how many points maximally represent a person cluster */
+        # float max_width_;
+        # /** \brief person clusters minimum width, used to estimate how many points minimally represent a person cluster */
+        # float min_width_;
+        # /** \brief the beginning of the field of view in z-direction, should be usually set to zero */
+        # float min_fov_;
+        # /** \brief the end of the field of view in z-direction */
+        # float max_fov_;
+        # /** \brief if true, the sensor is considered to be vertically placed (portrait mode) */
+        # bool vertical_;                    
+        # /** \brief if true, the person centroid is computed as the centroid of the cluster points belonging to the head;  
+        # * if false, the person centroid is computed as the centroid of the whole cluster points (default = true) */
+        # bool head_centroid_;    // if true, the person centroid is computed as the centroid of the cluster points belonging to the head (default = true)
+        #                       // if false, the person centroid is computed as the centroid of the whole cluster points 
+        # /** \brief maximum number of points for a person cluster */
+        # int max_points_;                  
+        # /** \brief minimum number of points for a person cluster */
+        # int min_points_;                  
+        # /** \brief minimum distance between persons' heads */
+        # float heads_minimum_distance_;            
+        # /** \brief intrinsic parameters matrix of the RGB camera */
+        # Eigen::Matrix3f intrinsics_matrix_;
+        # /** \brief flag stating whether the intrinsics matrix has been set or not */
+        # bool intrinsics_matrix_set_;
+        # /** \brief the transformed intrinsics matrix */
+        # Eigen::Matrix3f intrinsics_matrix_transformed_;
+        # /** \brief SVM-based person classifier */
+        # pcl::people::PersonClassifier<pcl::RGB> person_classifier_;  
+        # /** \brief flag stating if the classifier has been set or not */
+        # bool person_classifier_set_flag_;
+###
+
+# head_based_subcluster.h
+# namespace pcl
+# namespace people
+# /** \brief @b HeadBasedSubclustering represents a class for searching for people inside a HeightMap2D based on a 3D head detection algorithm
+#   * \author Matteo Munaro
+#   * \ingroup people
+# */
+# template <typename PointT> class HeadBasedSubclustering;
+# 
+# template <typename PointT>
+# class HeadBasedSubclustering
+cdef extern from "pcl/people/head_based_subcluster.h" namespace "pcl::people":
+    cdef cppclass HeadBasedSubclustering[PointT]:
+        HeadBasedSubclustering()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        #  * \brief Compute subclusters and return them into a vector of PersonCluster.
+        #  * \param[in] clusters Vector of PersonCluster.
+        # void subcluster (std::vector<pcl::people::PersonCluster<PointT> >& clusters);
+        # /**
+        # * \brief Merge clusters close in floor coordinates.
+        # * 
+        # * \param[in] input_clusters Input vector of PersonCluster.
+        # * \param[in] output_clusters Output vector of PersonCluster (after merging).
+        # */
+        # void
+        # mergeClustersCloseInFloorCoordinates (std::vector<pcl::people::PersonCluster<PointT> >& input_clusters,
+        #   std::vector<pcl::people::PersonCluster<PointT> >& output_clusters);
+        # /**
+        # * \brief Create subclusters centered on the heads position from the current cluster.
+        # * 
+        # * \param[in] cluster A PersonCluster.
+        # * \param[in] maxima_number_after_filtering Number of local maxima to use as centers of the new cluster.
+        # * \param[in] maxima_cloud_indices_filtered Cloud indices of local maxima to use as centers of the new cluster.
+        # * \param[out] subclusters Output vector of PersonCluster objects derived from the input cluster.
+        # */
+        # void
+        # createSubClusters (pcl::people::PersonCluster<PointT>& cluster, int maxima_number_after_filtering,  std::vector<int>& maxima_cloud_indices_filtered,
+        #   std::vector<pcl::people::PersonCluster<PointT> >& subclusters);
+        # /**
+        # * \brief Set input cloud.
+        # * 
+        # * \param[in] cloud A pointer to the input point cloud.
+        # */
+        # void
+        # setInputCloud (PointCloudPtr& cloud);
+        # /**
+        # * \brief Set the ground coefficients.
+        # * 
+        # * \param[in] ground_coeffs The ground plane coefficients.
+        # */
+        # void
+        # setGround (Eigen::VectorXf& ground_coeffs);
+        # /**
+        # * \brief Set sensor orientation to landscape mode (false) or portrait mode (true).
+        # * 
+        # * \param[in] vertical Landscape (false) or portrait (true) mode (default = false).
+        # */
+        # void
+        # setSensorPortraitOrientation (bool vertical);
+        # /**
+        # * \brief Set head_centroid_ to true (person centroid is in the head) or false (person centroid is the whole body centroid).
+        # *
+        # * \param[in] head_centroid Set the location of the person centroid (head or body center) (default = true).
+        # */
+        # void
+        # setHeadCentroid (bool head_centroid);
+        # /**
+        # * \brief Set initial cluster indices.
+        # * 
+        # * \param[in] cluster_indices Point cloud indices corresponding to the initial clusters (before subclustering).
+        # */
+        # void
+        # setInitialClusters (std::vector<pcl::PointIndices>& cluster_indices);
+        # /**
+        # * \brief Set minimum and maximum allowed height for a person cluster.
+        # *
+        # * \param[in] min_height Minimum allowed height for a person cluster (default = 1.3).
+        # * \param[in] max_height Maximum allowed height for a person cluster (default = 2.3).
+        # */
+        # void
+        # setHeightLimits (float min_height, float max_height);
+        # /**
+        # * \brief Set minimum and maximum allowed number of points for a person cluster.
+        # *
+        # * \param[in] min_points Minimum allowed number of points for a person cluster.
+        # * \param[in] max_points Maximum allowed number of points for a person cluster.
+        # */
+        # void
+        # setDimensionLimits (int min_points, int max_points);
+        # /**
+        # * \brief Set minimum distance between persons' heads.
+        # *
+        # * \param[in] heads_minimum_distance Minimum allowed distance between persons' heads (default = 0.3).
+        # */
+        # void
+        # setMinimumDistanceBetweenHeads (float heads_minimum_distance);
+        # /**
+        # * \brief Get minimum and maximum allowed height for a person cluster.
+        # *
+        # * \param[out] min_height Minimum allowed height for a person cluster.
+        # * \param[out] max_height Maximum allowed height for a person cluster.
+        # */
+        # void
+        # getHeightLimits (float& min_height, float& max_height);
+        # /**
+        # * \brief Get minimum and maximum allowed number of points for a person cluster.
+        # *
+        # * \param[out] min_points Minimum allowed number of points for a person cluster.
+        # * \param[out] max_points Maximum allowed number of points for a person cluster.
+        # */
+        # void
+        # getDimensionLimits (int& min_points, int& max_points);
+        # /**
+        # * \brief Get minimum distance between persons' heads.
+        # */
+        # float
+        # getMinimumDistanceBetweenHeads ();
+        # protected:
+        # /** \brief ground plane coefficients */
+        # Eigen::VectorXf ground_coeffs_;            
+        # /** \brief ground plane normalization factor */
+        # float sqrt_ground_coeffs_;              
+        # /** \brief initial clusters indices */
+        # std::vector<pcl::PointIndices> cluster_indices_;   
+        # /** \brief pointer to the input cloud */
+        # PointCloudPtr cloud_;                
+        # /** \brief person clusters maximum height from the ground plane */
+        # float max_height_;                  
+        # /** \brief person clusters minimum height from the ground plane */
+        # float min_height_;                  
+        # /** \brief if true, the sensor is considered to be vertically placed (portrait mode) */
+        # bool vertical_;                   
+        # /** \brief if true, the person centroid is computed as the centroid of the cluster points belonging to the head 
+        #          if false, the person centroid is computed as the centroid of the whole cluster points (default = true) */
+        # bool head_centroid_;                                            
+        # /** \brief maximum number of points for a person cluster */
+        # int max_points_;                  
+        # /** \brief minimum number of points for a person cluster */
+        # int min_points_;                  
+        # /** \brief minimum distance between persons' heads */
+        # float heads_minimum_distance_;           
+###
+
+# height_map_2d.h
+# namespace pcl
+# namespace people
+# /** \brief @b HeightMap2D represents a class for creating a 2D height map from a point cloud and searching for its local maxima
+#   * \author Matteo Munaro
+#   * \ingroup people
+# */
+# template <typename PointT> class HeightMap2D;
+# template <typename PointT>
+cdef extern from "pcl/people/height_map_2d.h" namespace "pcl::people":
+    cdef cppclass HeightMap2D:
+        HeightMap2D()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # /**
+        # * \brief Compute the height map with the projection of cluster points onto the ground plane.
+        # * \param[in] cluster The PersonCluster used to compute the height map.
+        # */
+        # void
+        # compute (pcl::people::PersonCluster<PointT>& cluster);
+        # /**
+        # * \brief Compute local maxima of the height map.
+        # */
+        # void
+        # searchLocalMaxima ();
+        # /**
+        # * \brief Filter maxima of the height map by imposing a minimum distance between them.
+        # */
+        # void
+        # filterMaxima ();
+        # /**
+        # * \brief Set initial cluster indices.
+        # * 
+        # * \param[in] cloud A pointer to the input cloud.
+        # */
+        # void
+        # setInputCloud (PointCloudPtr& cloud);
+        # /**
+        # * \brief Set the ground coefficients.
+        # * 
+        # * \param[in] ground_coeffs The ground plane coefficients.
+        # */
+        # void
+        # setGround (Eigen::VectorXf& ground_coeffs);
+        # /**
+        # * \brief Set bin size for the height map. 
+        # * 
+        # * \param[in] bin_size Bin size for the height map (default = 0.06).
+        # */
+        # void
+        # setBinSize (float bin_size);
+        # /**
+        # * \brief Set minimum distance between maxima. 
+        # * 
+        # * \param[in] minimum_distance_between_maxima Minimum allowed distance between maxima (default = 0.3).
+        # */
+        # void
+        # setMinimumDistanceBetweenMaxima (float minimum_distance_between_maxima);
+        # /**
+        # * \brief Set sensor orientation to landscape mode (false) or portrait mode (true).
+        # * 
+        # * \param[in] vertical Landscape (false) or portrait (true) mode (default = false).
+        # */
+        # void
+        # setSensorPortraitOrientation (bool vertical);
+        # /**
+        # * \brief Get the height map as a vector of int.
+        # */
+        # std::vector<int>& getHeightMap ();
+        # /**
+        # * \brief Get bin size for the height map. 
+        # */
+        # float getBinSize ();
+        # /**
+        # * \brief Get minimum distance between maxima of the height map. 
+        # */
+        # float getMinimumDistanceBetweenMaxima ();
+        # /**
+        # * \brief Return the maxima number after the filterMaxima method.
+        # */
+        # int& getMaximaNumberAfterFiltering ();
+        # /**
+        # * \brief Return the point cloud indices corresponding to the maxima computed after the filterMaxima method.
+        # */
+        # std::vector<int>& getMaximaCloudIndicesFiltered ();
+        # protected:
+        # /** \brief ground plane coefficients */
+        # Eigen::VectorXf ground_coeffs_;            
+        # /** \brief ground plane normalization factor */
+        # float sqrt_ground_coeffs_;              
+        # /** \brief pointer to the input cloud */
+        # PointCloudPtr cloud_;                
+        # /** \brief if true, the sensor is considered to be vertically placed (portrait mode) */
+        # bool vertical_;                    
+        # /** \brief vector with maximum height values for every bin (height map) */
+        # std::vector<int> buckets_;              
+        # /** \brief indices of the pointcloud points with maximum height for every bin */
+        # std::vector<int> buckets_cloud_indices_;      
+        # /** \brief bin dimension */
+        # float bin_size_;                  
+        # /** \brief number of local maxima in the height map */
+        # int maxima_number_;                  
+        # /** \brief contains the position of the maxima in the buckets vector */
+        # std::vector<int> maxima_indices_;          
+        # /** \brief contains the point cloud position of the maxima (indices of the point cloud) */
+        # std::vector<int> maxima_cloud_indices_;        
+        # /** \brief number of local maxima after filtering */
+        # int maxima_number_after_filtering_;          
+        # /** \brief contains the position of the maxima in the buckets array after filtering */
+        # std::vector<int> maxima_indices_filtered_;      
+        # /** \brief contains the point cloud position of the maxima after filtering */
+        # std::vector<int> maxima_cloud_indices_filtered_;  
+        # /** \brief minimum allowed distance between maxima */
+        # float min_dist_between_maxima_;            
+###
+
+# hog.h
+# namespace pcl
+# namespace people
+# /** \brief @b HOG represents a class for computing the HOG descriptor described in 
+# * Dalal, N. and Triggs, B., "Histograms of oriented gradients for human detection", CVPR 2005.
+# * \author Matteo Munaro, Stefano Ghidoni, Stefano Michieletto
+# * \ingroup people
+# */
+# class PCL_EXPORTS HOG
+cdef extern from "pcl/people/hog.h" namespace "pcl::people":
+    cdef cppclass HOG:
+        HOG()
+        # public:
+        # /** 
+        # * \brief Compute gradient magnitude and orientation at each location (uses sse). 
+        # * 
+        # * \param[in] I Image as array of float.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] d Image number of channels.
+        # * \param[out] M Gradient magnitude for each image point.
+        # * \param[out] O Gradient orientation for each image point.
+        # */
+        # void gradMag ( float *I, int h, int w, int d, float *M, float *O ) const;
+        # /** 
+        # * \brief Compute n_orients gradient histograms per bin_size x bin_size block of pixels.  
+        # * 
+        # * \param[in] M Gradient magnitude for each image point.
+        # * \param[in] O Gradient orientation for each image point.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] bin_size Spatial bin size.
+        # * \param[in] n_orients Number of orientation bins.
+        # * \param[in] soft_bin If true, each pixel can contribute to multiple spatial bins (using bilinear interpolation).
+        # * \param[out] H Gradient histograms.
+        # */
+        # void gradHist ( float *M, float *O, int h, int w, int bin_size, int n_orients, bool soft_bin, float *H) const;
+        # /** 
+        # * \brief Normalize histogram of gradients. 
+        # * 
+        # * \param[in] H Gradient histograms.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] bin_size Spatial bin size.
+        # * \param[in] n_orients Number of orientation bins.  
+        # * \param[in] clip Value at which to clip histogram bins.      
+        # * \param[out] G Normalized gradient histograms.
+        # */
+        # void normalization ( float *H, int h, int w, int bin_size, int n_orients, float clip, float *G ) const;
+        # /**
+        # * \brief Compute HOG descriptor.
+        # * 
+        # * \param[in] I Image as array of float between 0 and 1.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] n_channels Image number of channels.
+        # * \param[in] bin_size Spatial bin size.  
+        # * \param[in] n_orients Number of orientation bins.     
+        # * \param[in] soft_bin If true, each pixel can contribute to multiple spatial bins (using bilinear interpolation).
+        # * \param[out] descriptor HOG descriptor.
+        # */
+        # void compute (float *I, int h, int w, int n_channels, int bin_size, int n_orients, bool soft_bin, float *descriptor);
+        # /**
+        # * \brief Compute HOG descriptor with default parameters.
+        # * \param[in] I Image as array of float between 0 and 1.
+        # * \param[out] descriptor HOG descriptor.
+        # */
+        # void compute (float *I, float *descriptor) const;
+        # protected:
+        # /** \brief image height (default = 128) */
+        # int h_;
+        # /** \brief image width (default = 64) */
+        # int w_;
+        # /** \brief image number of channels (default = 3) */
+        # int n_channels_;
+        # /** \brief spatial bin size (default = 8) */
+        # int bin_size_; 
+        # /** \brief number of orientation bins (default = 9) */
+        # int n_orients_;
+        # /** \brief if true, each pixel can contribute to multiple spatial bins (using bilinear interpolation) (default = true) */
+        # bool soft_bin_;   
+        # /** \brief value at which to clip histogram bins (default = 0.2) */
+        # float clip_; 
+###
+
+
diff --git a/pcl/pcl_People_180.pxd b/pcl/pcl_People_180.pxd
new file mode 100644
index 0000000..bb5a1ab
--- /dev/null
+++ b/pcl/pcl_People_180.pxd
@@ -0,0 +1,772 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+cimport eigen as eigen3
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+### base class ###
+
+# person_classifier.h
+# namespace pcl
+# namespace people
+# template <typename PointT> class PersonClassifier;
+# template <typename PointT>
+# class PersonClassifier
+cdef extern from "pcl/people/person_classifier.h" namespace "pcl::people":
+    cdef cppclass PersonClassifier:
+        PersonClassifier()
+        # protected:
+        # /** \brief Height of the image patch to classify. */
+        # int window_height_;          
+        # /** \brief Width of the image patch to classify. */
+        # int window_width_;          
+        # /** \brief SVM offset. */
+        # float SVM_offset_;          
+        # /** \brief SVM weights vector. */
+        # std::vector<float> SVM_weights_;  
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # /** \brief Load SVM parameters from a text file. 
+        # * \param[in] svm_filename Filename containing SVM parameters.
+        # * \return true if SVM has been correctly set, false otherwise.
+        bool loadSVMFromFile (string svm_filename)
+        # * \brief Set trained SVM for person confidence estimation.
+        # * \param[in] window_height Detection window height.
+        # * \param[in] window_width Detection window width.
+        # * \param[in] SVM_weights SVM weights vector.
+        # * \param[in] SVM_offset SVM offset.
+        void setSVM (int window_height, int window_width, vector[float] SVM_weights, float SVM_offset)
+        # * \brief Get trained SVM for person confidence estimation.
+        # * \param[out] window_height Detection window height.
+        # * \param[out] window_width Detection window width.
+        # * \param[out] SVM_weights SVM weights vector.
+        # * \param[out] SVM_offset SVM offset.
+        # void getSVM (int& window_height, int& window_width, vector[float]& SVM_weights, float& SVM_offset);
+        # * \brief Resize an image represented by a pointcloud containing RGB information.
+        # * \param[in] input_image A pointer to a pointcloud containing RGB information.
+        # * \param[out] output_image A pointer to the output pointcloud.
+        # * \param[in] width Output width.
+        # * \param[in] height Output height.
+        # void resize (PointCloudPtr& input_image, PointCloudPtr& output_image, int width, int height)
+        # * \brief Copies an image and makes a black border around it, where the source image is not present.
+        # * \param[in] input_image A pointer to a pointcloud containing RGB information.
+        # * \param[out] output_image A pointer to the output pointcloud.
+        # * \param[in] xmin x coordinate of the top-left point of the bbox to copy from the input image.
+        # * \param[in] ymin y coordinate of the top-left point of the bbox to copy from the input image.
+        # * \param[in] width Output width.
+        # * \param[in] height Output height.
+        # void copyMakeBorder (PointCloudPtr& input_image, PointCloudPtr& output_image, int xmin, int ymin, int width, int height)
+        # * \brief Classify the given portion of image.
+        # * \param[in] height The height of the image patch to classify, in pixels.
+        # * \param[in] xc The x-coordinate of the center of the image patch to classify, in pixels.
+        # * \param[in] yc The y-coordinate of the center of the image patch to classify, in pixels.
+        # * \param[in] image The whole image (pointer to a point cloud containing RGB information) containing the object to classify.
+        # * \return The classification score given by the SVM.
+        # double evaluate (float height, float xc, float yc, PointCloudPtr& image)
+        # * \brief Compute person confidence for a given PersonCluster.
+        # * \param[in] image The input image (pointer to a point cloud containing RGB information).
+        # * \param[in] bottom Theoretical bottom point of the cluster projected to the image.
+        # * \param[in] top Theoretical top point of the cluster projected to the image.
+        # * \param[in] centroid Theoretical centroid point of the cluster projected to the image.
+        # * \param[in] vertical If true, the sensor is considered to be vertically placed (portrait mode).
+        # * \return The person confidence.
+        # double evaluate (PointCloudPtr& image, Eigen::Vector3f& bottom, Eigen::Vector3f& top, Eigen::Vector3f& centroid, bool vertical)
+###
+
+
+# person_cluster.h
+# namespace pcl
+# namespace people
+# /** \brief @b PersonCluster represents a class for representing information about a cluster containing a person.
+#  * \author Filippo Basso, Matteo Munaro
+#  * \ingroup people
+#  */
+# template <typename PointT> class PersonCluster;
+# template <typename PointT> bool operator<(const PersonCluster<PointT>& c1, const PersonCluster<PointT>& c2);
+# 
+# template <typename PointT>
+# class PersonCluster
+cdef extern from "pcl/people/person_cluster.h" namespace "pcl::people":
+    cdef cppclass PersonCluster:
+        PersonClassifier()
+        # PersonCluster (
+        # const PointCloudPtr& input_cloud,
+        # const pcl::PointIndices& indices,
+        # const Eigen::VectorXf& ground_coeffs,
+        # float sqrt_ground_coeffs,
+        # bool head_centroid,
+        # bool vertical = false);
+        # protected:
+        # bool head_centroid_;
+        # /** \brief Minimum x coordinate of the cluster points. */
+        # float min_x_;
+        # /** \brief Minimum y coordinate of the cluster points. */
+        # float min_y_;
+        # /** \brief Minimum z coordinate of the cluster points. */
+        # float min_z_;
+        # /** \brief Maximum x coordinate of the cluster points. */
+        # float max_x_;
+        # /** \brief Maximum y coordinate of the cluster points. */
+        # float max_y_;
+        # /** \brief Maximum z coordinate of the cluster points. */
+        # float max_z_;
+        # /** \brief Sum of x coordinates of the cluster points. */
+        # float sum_x_;
+        # /** \brief Sum of y coordinates of the cluster points. */
+        # float sum_y_;
+        # /** \brief Sum of z coordinates of the cluster points. */
+        # float sum_z_;
+        # /** \brief Number of cluster points. */
+        # int n_;
+        # /** \brief x coordinate of the cluster centroid. */
+        # float c_x_;
+        # /** \brief y coordinate of the cluster centroid. */
+        # float c_y_;
+        # /** \brief z coordinate of the cluster centroid. */
+        # float c_z_;
+        # /** \brief Cluster height from the ground plane. */
+        # float height_;
+        # /** \brief Cluster distance from the sensor. */
+        # float distance_;
+        # /** \brief Cluster centroid horizontal angle with respect to z axis. */
+        # float angle_;
+        # /** \brief Maximum angle of the cluster points. */
+        # float angle_max_;
+        # /** \brief Minimum angle of the cluster points. */
+        # float angle_min_;
+        # /** \brief Cluster top point. */
+        # Eigen::Vector3f top_;
+        # /** \brief Cluster bottom point. */
+        # Eigen::Vector3f bottom_;
+        # /** \brief Cluster centroid. */
+        # Eigen::Vector3f center_;
+        # /** \brief Theoretical cluster top. */
+        # Eigen::Vector3f ttop_;
+        # /** \brief Theoretical cluster bottom (lying on the ground plane). */
+        # Eigen::Vector3f tbottom_;
+        # /** \brief Theoretical cluster center (between ttop_ and tbottom_). */
+        # Eigen::Vector3f tcenter_;
+        # /** \brief Vector containing the minimum coordinates of the cluster. */
+        # Eigen::Vector3f min_;
+        # /** \brief Vector containing the maximum coordinates of the cluster. */
+        # Eigen::Vector3f max_;
+        # /** \brief Point cloud indices of the cluster points. */
+        # pcl::PointIndices points_indices_;
+        # /** \brief If true, the sensor is considered to be vertically placed (portrait mode). */
+        # bool vertical_;
+        # /** \brief PersonCluster HOG confidence. */
+        # float person_confidence_;
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # * \brief Returns the height of the cluster.
+        # * \return the height of the cluster.
+        float getHeight ();
+        # * \brief Update the height of the cluster.
+        # * \param[in] ground_coeffs The coefficients of the ground plane.
+        # * \return the height of the cluster.
+        # float updateHeight (const Eigen::VectorXf& ground_coeffs);
+        # * \brief Update the height of the cluster.
+        # * \param[in] ground_coeffs The coefficients of the ground plane.
+        # * \param[in] sqrt_ground_coeffs The norm of the vector [a, b, c] where a, b and c are the first
+        # * three coefficients of the ground plane (ax + by + cz + d = 0).
+        # * \return the height of the cluster.
+        # float updateHeight (const Eigen::VectorXf& ground_coeffs, float sqrt_ground_coeffs);
+        # * \brief Returns the distance of the cluster from the sensor.
+        # * \return the distance of the cluster (its centroid) from the sensor without considering the
+        # * y dimension.
+        float getDistance ()
+        # * \brief Returns the angle formed by the cluster's centroid with respect to the sensor (in radians).
+        # * \return the angle formed by the cluster's centroid with respect to the sensor (in radians).
+        float getAngle ()
+        # * \brief Returns the minimum angle formed by the cluster with respect to the sensor (in radians).
+        # * \return the minimum angle formed by the cluster with respect to the sensor (in radians).
+        float getAngleMin ()
+        # * \brief Returns the maximum angle formed by the cluster with respect to the sensor (in radians).
+        # * \return the maximum angle formed by the cluster with respect to the sensor (in radians).
+        float getAngleMax ()
+        # * \brief Returns the indices of the point cloud points corresponding to the cluster.
+        # * \return the indices of the point cloud points corresponding to the cluster.
+        # pcl::PointIndices& getIndices ();
+        # * \brief Returns the theoretical top point.
+        # * \return the theoretical top point.
+        # Eigen::Vector3f& getTTop ();
+        # * \brief Returns the theoretical bottom point.
+        # * \return the theoretical bottom point.
+        # Eigen::Vector3f& getTBottom ();
+        # * \brief Returns the theoretical centroid (at half height).
+        # * \return the theoretical centroid (at half height).
+        # Eigen::Vector3f& getTCenter ();
+        # * \brief Returns the top point.
+        # * \return the top point.
+        # Eigen::Vector3f& getTop ();
+        # * \brief Returns the bottom point.
+        # * \return the bottom point.
+        # Eigen::Vector3f& getBottom ();
+        # * \brief Returns the centroid.
+        # * \return the centroid.
+        # Eigen::Vector3f& getCenter ();  
+        # //Eigen::Vector3f& getTMax();
+        # * \brief Returns the point formed by min x, min y and min z.
+        # * \return the point formed by min x, min y and min z.
+        # Eigen::Vector3f& getMin ();
+        # * \brief Returns the point formed by max x, max y and max z.
+        # * \return the point formed by max x, max y and max z.
+        # Eigen::Vector3f& getMax ();
+        # /**
+        # * \brief Returns the HOG confidence.
+        # * \return the HOG confidence.
+        # */
+        # float
+        # getPersonConfidence ();
+        # /**
+        # * \brief Returns the number of points of the cluster.
+        # * \return the number of points of the cluster.
+        # */
+        # int getNumberPoints ();
+        # /**
+        # * \brief Sets the cluster height.
+        # * \param[in] height
+        # */
+        # void setHeight (float height);
+        # /**
+        # * \brief Sets the HOG confidence.
+        # * \param[in] confidence
+        # */
+        # void setPersonConfidence (float confidence);
+        # /**
+        # * \brief Draws the theoretical 3D bounding box of the cluster in the PCL visualizer.
+        # * \param[in] viewer PCL visualizer.
+        # * \param[in] person_number progressive number representing the person.
+        # */
+        # void drawTBoundingBox (pcl::visualization::PCLVisualizer& viewer, int person_number);
+        # /**
+        # * \brief For sorting purpose: sort by distance.
+        # */
+        # friend bool operator< <>(const PersonCluster<PointT>& c1, const PersonCluster<PointT>& c2);
+        # protected:
+        # /**
+        # * \brief PersonCluster initialization.
+        # */
+        # void init(
+        #   const PointCloudPtr& input_cloud,
+        #   const pcl::PointIndices& indices,
+        #   const Eigen::VectorXf& ground_coeffs,
+        #   float sqrt_ground_coeffs,
+        #   bool head_centroid,
+        #   bool vertical);
+###
+
+
+# ground_based_people_detection_app.h
+# namespace pcl
+# namespace people
+# template <typename PointT>
+# class GroundBasedPeopleDetectionApp
+# public:
+cdef extern from "pcl/people/ground_based_people_detection_app.h" namespace "pcl::people":
+    cdef cppclass GroundBasedPeopleDetectionApp[PointT]:
+        GroundBasedPeopleDetectionApp()
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # * \brief Set the pointer to the input cloud.
+        # * \param[in] cloud A pointer to the input cloud.
+        # void setInputCloud (PointCloudPtr& cloud);
+        void setInputCloud (sharedPtr[cpp.PointCloud[PointT]] cloud)
+        #  * \brief Set the ground coefficients.
+        #  * \param[in] ground_coeffs Vector containing the four plane coefficients.
+        # void setGround (Eigen::VectorXf& ground_coeffs);
+        #  * \brief Set the transformation matrix, which is used in order to transform the given point cloud, the ground plane and the intrinsics matrix to the internal coordinate frame.
+        #  * \param[in] cloud A pointer to the input cloud.
+        void setTransformation (eigen3.Matrix3f& transformation);
+        #  * \brief Set sampling factor. 
+        #  * \param[in] sampling_factor Value of the downsampling factor (in each dimension) which is applied to the raw point cloud (default = 1.).
+        void setSamplingFactor (int sampling_factor);
+        #  * \brief Set voxel size. 
+        #  * \param[in] voxel_size Value of the voxel dimension (default = 0.06m.).
+        void setVoxelSize (float voxel_size);
+        #  * \brief Set intrinsic parameters of the RGB camera.
+        #  * \param[in] intrinsics_matrix RGB camera intrinsic parameters matrix.
+        void setIntrinsics (eigen3.Matrix3f intrinsics_matrix);
+        #  * \brief Set SVM-based person classifier.
+        #  * \param[in] person_classifier Needed for people detection on RGB data.
+        # void setClassifier (pcl::people::PersonClassifier<pcl::RGB> person_classifier);
+        #  * \brief Set the field of view of the point cloud in z direction.
+        #  * \param[in] min The beginning of the field of view in z-direction, should be usually set to zero.
+        #  * \param[in] max The end of the field of view in z-direction.
+        void setFOV (float min, float max)
+        #  * \brief Set sensor orientation (vertical = true means portrait mode, vertical = false means landscape mode).
+        #  * \param[in] vertical Set landscape/portait camera orientation (default = false).
+        void setSensorPortraitOrientation (bool vertical)
+        #  * \brief Set head_centroid_ to true (person centroid is in the head) or false (person centroid is the whole body centroid).
+        #  * \param[in] head_centroid Set the location of the person centroid (head or body center) (default = true).
+        void setHeadCentroid (bool head_centroid)
+        #  * \brief Set minimum and maximum allowed height and width for a person cluster.
+        #  * \param[in] min_height Minimum allowed height for a person cluster (default = 1.3).
+        #  * \param[in] max_height Maximum allowed height for a person cluster (default = 2.3).
+        #  * \param[in] min_width Minimum width for a person cluster (default = 0.1).
+        #  * \param[in] max_width Maximum width for a person cluster (default = 8.0).
+        void setPersonClusterLimits (float min_height, float max_height, float min_width, float max_width)
+        #  * \brief Set minimum distance between persons' heads.
+        #  * \param[in] heads_minimum_distance Minimum allowed distance between persons' heads (default = 0.3).
+        void setMinimumDistanceBetweenHeads (float heads_minimum_distance)
+        #  * \brief Get the minimum and maximum allowed height and width for a person cluster.
+        #  * \param[out] min_height Minimum allowed height for a person cluster.
+        #  * \param[out] max_height Maximum allowed height for a person cluster.
+        #  * \param[out] min_width Minimum width for a person cluster.
+        #  * \param[out] max_width Maximum width for a person cluster.
+        void getPersonClusterLimits (float& min_height, float& max_height, float& min_width, float& max_width);
+        #   * \brief Get minimum and maximum allowed number of points for a person cluster.
+        #   * \param[out] min_points Minimum allowed number of points for a person cluster.
+        #   * \param[out] max_points Maximum allowed number of points for a person cluster.
+        void getDimensionLimits (int& min_points, int& max_points)
+        #   * \brief Get minimum distance between persons' heads.
+        float getMinimumDistanceBetweenHeads ()
+        #   * \brief Get floor coefficients.
+        # Eigen::VectorXf getGround ();
+        #   * \brief Get the filtered point cloud.
+        # PointCloudPtr getFilteredCloud ();
+        #   * \brief Get pointcloud after voxel grid filtering and ground removal.
+        # PointCloudPtr getNoGroundCloud ();
+        #   * \brief Extract RGB information from a point cloud and output the corresponding RGB point cloud.
+        #   * \param[in] input_cloud A pointer to a point cloud containing also RGB information.
+        #   * \param[out] output_cloud A pointer to a RGB point cloud.
+        # void extractRGBFromPointCloud (PointCloudPtr input_cloud, pcl::PointCloud<pcl::RGB>::Ptr& output_cloud);
+        #   * \brief Swap rows/cols dimensions of a RGB point cloud (90 degrees counterclockwise rotation).
+        #   * \param[in,out] cloud A pointer to a RGB point cloud.
+        # void swapDimensions (pcl::PointCloud<pcl::RGB>::Ptr& cloud);
+        #   * \brief Estimates min_points_ and max_points_ based on the minimal and maximal cluster size and the voxel size.
+        void updateMinMaxPoints ()
+        #   * \brief Applies the transformation to the input point cloud.
+        void applyTransformationPointCloud ()
+        #   * \brief Applies the transformation to the ground plane.
+        void applyTransformationGround ()
+        #   * \brief Applies the transformation to the intrinsics matrix.
+        void applyTransformationIntrinsics ()
+        #   * \brief Reduces the input cloud to one point per voxel and limits the field of view.
+        void filter ()
+        #   * \brief Perform people detection on the input data and return people clusters information.
+        #   * \param[out] clusters Vector of PersonCluster.
+        #   * \return true if the compute operation is successful, false otherwise.
+        # bool compute (std::vector<pcl::people::PersonCluster<PointT> >& clusters);
+        # protected:
+        # /** \brief sampling factor used to downsample the point cloud */
+        # int sampling_factor_; 
+        # /** \brief voxel size */
+        # float voxel_size_;                  
+        # /** \brief ground plane coefficients */
+        # Eigen::VectorXf ground_coeffs_;
+        # /** \brief flag stating whether the ground coefficients have been set or not */
+        # bool ground_coeffs_set_;
+        # /** \brief the transformed ground coefficients */
+        # Eigen::VectorXf ground_coeffs_transformed_;
+        # /** \brief ground plane normalization factor */
+        # float sqrt_ground_coeffs_;
+        # /** \brief rotation matrix which transforms input point cloud to internal people tracker coordinate frame */
+        # Eigen::Matrix3f transformation_;
+        # /** \brief flag stating whether the transformation matrix has been set or not */
+        # bool transformation_set_;
+        # /** \brief pointer to the input cloud */
+        # PointCloudPtr cloud_;
+        # /** \brief pointer to the filtered cloud */
+        # PointCloudPtr cloud_filtered_;
+        # /** \brief pointer to the cloud after voxel grid filtering and ground removal */
+        # PointCloudPtr no_ground_cloud_;              
+        # /** \brief pointer to a RGB cloud corresponding to cloud_ */
+        # pcl::PointCloud<pcl::RGB>::Ptr rgb_image_;      
+        # /** \brief person clusters maximum height from the ground plane */
+        # float max_height_;                  
+        # /** \brief person clusters minimum height from the ground plane */
+        # float min_height_;
+        # /** \brief person clusters maximum width, used to estimate how many points maximally represent a person cluster */
+        # float max_width_;
+        # /** \brief person clusters minimum width, used to estimate how many points minimally represent a person cluster */
+        # float min_width_;
+        # /** \brief the beginning of the field of view in z-direction, should be usually set to zero */
+        # float min_fov_;
+        # /** \brief the end of the field of view in z-direction */
+        # float max_fov_;
+        # /** \brief if true, the sensor is considered to be vertically placed (portrait mode) */
+        # bool vertical_;                    
+        # /** \brief if true, the person centroid is computed as the centroid of the cluster points belonging to the head;  
+        # * if false, the person centroid is computed as the centroid of the whole cluster points (default = true) */
+        # bool head_centroid_;    // if true, the person centroid is computed as the centroid of the cluster points belonging to the head (default = true)
+        #                       // if false, the person centroid is computed as the centroid of the whole cluster points 
+        # /** \brief maximum number of points for a person cluster */
+        # int max_points_;                  
+        # /** \brief minimum number of points for a person cluster */
+        # int min_points_;                  
+        # /** \brief minimum distance between persons' heads */
+        # float heads_minimum_distance_;            
+        # /** \brief intrinsic parameters matrix of the RGB camera */
+        # Eigen::Matrix3f intrinsics_matrix_;
+        # /** \brief flag stating whether the intrinsics matrix has been set or not */
+        # bool intrinsics_matrix_set_;
+        # /** \brief the transformed intrinsics matrix */
+        # Eigen::Matrix3f intrinsics_matrix_transformed_;
+        # /** \brief SVM-based person classifier */
+        # pcl::people::PersonClassifier<pcl::RGB> person_classifier_;  
+        # /** \brief flag stating if the classifier has been set or not */
+        # bool person_classifier_set_flag_;
+###
+
+# head_based_subcluster.h
+# namespace pcl
+# namespace people
+# /** \brief @b HeadBasedSubclustering represents a class for searching for people inside a HeightMap2D based on a 3D head detection algorithm
+#   * \author Matteo Munaro
+#   * \ingroup people
+# */
+# template <typename PointT> class HeadBasedSubclustering;
+# 
+# template <typename PointT>
+# class HeadBasedSubclustering
+cdef extern from "pcl/people/head_based_subcluster.h" namespace "pcl::people":
+    cdef cppclass HeadBasedSubclustering[PointT]:
+        HeadBasedSubclustering()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        #  * \brief Compute subclusters and return them into a vector of PersonCluster.
+        #  * \param[in] clusters Vector of PersonCluster.
+        # void subcluster (std::vector<pcl::people::PersonCluster<PointT> >& clusters);
+        # /**
+        # * \brief Merge clusters close in floor coordinates.
+        # * 
+        # * \param[in] input_clusters Input vector of PersonCluster.
+        # * \param[in] output_clusters Output vector of PersonCluster (after merging).
+        # */
+        # void
+        # mergeClustersCloseInFloorCoordinates (std::vector<pcl::people::PersonCluster<PointT> >& input_clusters,
+        #   std::vector<pcl::people::PersonCluster<PointT> >& output_clusters);
+        # /**
+        # * \brief Create subclusters centered on the heads position from the current cluster.
+        # * 
+        # * \param[in] cluster A PersonCluster.
+        # * \param[in] maxima_number_after_filtering Number of local maxima to use as centers of the new cluster.
+        # * \param[in] maxima_cloud_indices_filtered Cloud indices of local maxima to use as centers of the new cluster.
+        # * \param[out] subclusters Output vector of PersonCluster objects derived from the input cluster.
+        # */
+        # void
+        # createSubClusters (pcl::people::PersonCluster<PointT>& cluster, int maxima_number_after_filtering,  std::vector<int>& maxima_cloud_indices_filtered,
+        #   std::vector<pcl::people::PersonCluster<PointT> >& subclusters);
+        # /**
+        # * \brief Set input cloud.
+        # * 
+        # * \param[in] cloud A pointer to the input point cloud.
+        # */
+        # void
+        # setInputCloud (PointCloudPtr& cloud);
+        # /**
+        # * \brief Set the ground coefficients.
+        # * 
+        # * \param[in] ground_coeffs The ground plane coefficients.
+        # */
+        # void
+        # setGround (Eigen::VectorXf& ground_coeffs);
+        # /**
+        # * \brief Set sensor orientation to landscape mode (false) or portrait mode (true).
+        # * 
+        # * \param[in] vertical Landscape (false) or portrait (true) mode (default = false).
+        # */
+        # void
+        # setSensorPortraitOrientation (bool vertical);
+        # /**
+        # * \brief Set head_centroid_ to true (person centroid is in the head) or false (person centroid is the whole body centroid).
+        # *
+        # * \param[in] head_centroid Set the location of the person centroid (head or body center) (default = true).
+        # */
+        # void
+        # setHeadCentroid (bool head_centroid);
+        # /**
+        # * \brief Set initial cluster indices.
+        # * 
+        # * \param[in] cluster_indices Point cloud indices corresponding to the initial clusters (before subclustering).
+        # */
+        # void
+        # setInitialClusters (std::vector<pcl::PointIndices>& cluster_indices);
+        # /**
+        # * \brief Set minimum and maximum allowed height for a person cluster.
+        # *
+        # * \param[in] min_height Minimum allowed height for a person cluster (default = 1.3).
+        # * \param[in] max_height Maximum allowed height for a person cluster (default = 2.3).
+        # */
+        # void
+        # setHeightLimits (float min_height, float max_height);
+        # /**
+        # * \brief Set minimum and maximum allowed number of points for a person cluster.
+        # *
+        # * \param[in] min_points Minimum allowed number of points for a person cluster.
+        # * \param[in] max_points Maximum allowed number of points for a person cluster.
+        # */
+        # void
+        # setDimensionLimits (int min_points, int max_points);
+        # /**
+        # * \brief Set minimum distance between persons' heads.
+        # *
+        # * \param[in] heads_minimum_distance Minimum allowed distance between persons' heads (default = 0.3).
+        # */
+        # void
+        # setMinimumDistanceBetweenHeads (float heads_minimum_distance);
+        # /**
+        # * \brief Get minimum and maximum allowed height for a person cluster.
+        # *
+        # * \param[out] min_height Minimum allowed height for a person cluster.
+        # * \param[out] max_height Maximum allowed height for a person cluster.
+        # */
+        # void
+        # getHeightLimits (float& min_height, float& max_height);
+        # /**
+        # * \brief Get minimum and maximum allowed number of points for a person cluster.
+        # *
+        # * \param[out] min_points Minimum allowed number of points for a person cluster.
+        # * \param[out] max_points Maximum allowed number of points for a person cluster.
+        # */
+        # void
+        # getDimensionLimits (int& min_points, int& max_points);
+        # /**
+        # * \brief Get minimum distance between persons' heads.
+        # */
+        # float
+        # getMinimumDistanceBetweenHeads ();
+        # protected:
+        # /** \brief ground plane coefficients */
+        # Eigen::VectorXf ground_coeffs_;            
+        # /** \brief ground plane normalization factor */
+        # float sqrt_ground_coeffs_;              
+        # /** \brief initial clusters indices */
+        # std::vector<pcl::PointIndices> cluster_indices_;   
+        # /** \brief pointer to the input cloud */
+        # PointCloudPtr cloud_;                
+        # /** \brief person clusters maximum height from the ground plane */
+        # float max_height_;                  
+        # /** \brief person clusters minimum height from the ground plane */
+        # float min_height_;                  
+        # /** \brief if true, the sensor is considered to be vertically placed (portrait mode) */
+        # bool vertical_;                   
+        # /** \brief if true, the person centroid is computed as the centroid of the cluster points belonging to the head 
+        #          if false, the person centroid is computed as the centroid of the whole cluster points (default = true) */
+        # bool head_centroid_;                                            
+        # /** \brief maximum number of points for a person cluster */
+        # int max_points_;                  
+        # /** \brief minimum number of points for a person cluster */
+        # int min_points_;                  
+        # /** \brief minimum distance between persons' heads */
+        # float heads_minimum_distance_;           
+###
+
+# height_map_2d.h
+# namespace pcl
+# namespace people
+# /** \brief @b HeightMap2D represents a class for creating a 2D height map from a point cloud and searching for its local maxima
+#   * \author Matteo Munaro
+#   * \ingroup people
+# */
+# template <typename PointT> class HeightMap2D;
+# template <typename PointT>
+cdef extern from "pcl/people/height_map_2d.h" namespace "pcl::people":
+    cdef cppclass HeightMap2D:
+        HeightMap2D()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # /**
+        # * \brief Compute the height map with the projection of cluster points onto the ground plane.
+        # * \param[in] cluster The PersonCluster used to compute the height map.
+        # */
+        # void
+        # compute (pcl::people::PersonCluster<PointT>& cluster);
+        # /**
+        # * \brief Compute local maxima of the height map.
+        # */
+        # void
+        # searchLocalMaxima ();
+        # /**
+        # * \brief Filter maxima of the height map by imposing a minimum distance between them.
+        # */
+        # void
+        # filterMaxima ();
+        # /**
+        # * \brief Set initial cluster indices.
+        # * 
+        # * \param[in] cloud A pointer to the input cloud.
+        # */
+        # void
+        # setInputCloud (PointCloudPtr& cloud);
+        # /**
+        # * \brief Set the ground coefficients.
+        # * 
+        # * \param[in] ground_coeffs The ground plane coefficients.
+        # */
+        # void
+        # setGround (Eigen::VectorXf& ground_coeffs);
+        # /**
+        # * \brief Set bin size for the height map. 
+        # * 
+        # * \param[in] bin_size Bin size for the height map (default = 0.06).
+        # */
+        # void
+        # setBinSize (float bin_size);
+        # /**
+        # * \brief Set minimum distance between maxima. 
+        # * 
+        # * \param[in] minimum_distance_between_maxima Minimum allowed distance between maxima (default = 0.3).
+        # */
+        # void
+        # setMinimumDistanceBetweenMaxima (float minimum_distance_between_maxima);
+        # /**
+        # * \brief Set sensor orientation to landscape mode (false) or portrait mode (true).
+        # * 
+        # * \param[in] vertical Landscape (false) or portrait (true) mode (default = false).
+        # */
+        # void
+        # setSensorPortraitOrientation (bool vertical);
+        # /**
+        # * \brief Get the height map as a vector of int.
+        # */
+        # std::vector<int>& getHeightMap ();
+        # /**
+        # * \brief Get bin size for the height map. 
+        # */
+        # float getBinSize ();
+        # /**
+        # * \brief Get minimum distance between maxima of the height map. 
+        # */
+        # float getMinimumDistanceBetweenMaxima ();
+        # /**
+        # * \brief Return the maxima number after the filterMaxima method.
+        # */
+        # int& getMaximaNumberAfterFiltering ();
+        # /**
+        # * \brief Return the point cloud indices corresponding to the maxima computed after the filterMaxima method.
+        # */
+        # std::vector<int>& getMaximaCloudIndicesFiltered ();
+        # protected:
+        # /** \brief ground plane coefficients */
+        # Eigen::VectorXf ground_coeffs_;            
+        # /** \brief ground plane normalization factor */
+        # float sqrt_ground_coeffs_;              
+        # /** \brief pointer to the input cloud */
+        # PointCloudPtr cloud_;                
+        # /** \brief if true, the sensor is considered to be vertically placed (portrait mode) */
+        # bool vertical_;                    
+        # /** \brief vector with maximum height values for every bin (height map) */
+        # std::vector<int> buckets_;              
+        # /** \brief indices of the pointcloud points with maximum height for every bin */
+        # std::vector<int> buckets_cloud_indices_;      
+        # /** \brief bin dimension */
+        # float bin_size_;                  
+        # /** \brief number of local maxima in the height map */
+        # int maxima_number_;                  
+        # /** \brief contains the position of the maxima in the buckets vector */
+        # std::vector<int> maxima_indices_;          
+        # /** \brief contains the point cloud position of the maxima (indices of the point cloud) */
+        # std::vector<int> maxima_cloud_indices_;        
+        # /** \brief number of local maxima after filtering */
+        # int maxima_number_after_filtering_;          
+        # /** \brief contains the position of the maxima in the buckets array after filtering */
+        # std::vector<int> maxima_indices_filtered_;      
+        # /** \brief contains the point cloud position of the maxima after filtering */
+        # std::vector<int> maxima_cloud_indices_filtered_;  
+        # /** \brief minimum allowed distance between maxima */
+        # float min_dist_between_maxima_;            
+###
+
+# hog.h
+# namespace pcl
+# namespace people
+# /** \brief @b HOG represents a class for computing the HOG descriptor described in 
+# * Dalal, N. and Triggs, B., "Histograms of oriented gradients for human detection", CVPR 2005.
+# * \author Matteo Munaro, Stefano Ghidoni, Stefano Michieletto
+# * \ingroup people
+# */
+# class PCL_EXPORTS HOG
+cdef extern from "pcl/people/hog.h" namespace "pcl::people":
+    cdef cppclass HOG:
+        HOG()
+        # public:
+        # /** 
+        # * \brief Compute gradient magnitude and orientation at each location (uses sse). 
+        # * 
+        # * \param[in] I Image as array of float.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] d Image number of channels.
+        # * \param[out] M Gradient magnitude for each image point.
+        # * \param[out] O Gradient orientation for each image point.
+        # */
+        # void gradMag ( float *I, int h, int w, int d, float *M, float *O ) const;
+        # /** 
+        # * \brief Compute n_orients gradient histograms per bin_size x bin_size block of pixels.  
+        # * 
+        # * \param[in] M Gradient magnitude for each image point.
+        # * \param[in] O Gradient orientation for each image point.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] bin_size Spatial bin size.
+        # * \param[in] n_orients Number of orientation bins.
+        # * \param[in] soft_bin If true, each pixel can contribute to multiple spatial bins (using bilinear interpolation).
+        # * \param[out] H Gradient histograms.
+        # */
+        # void gradHist ( float *M, float *O, int h, int w, int bin_size, int n_orients, bool soft_bin, float *H) const;
+        # /** 
+        # * \brief Normalize histogram of gradients. 
+        # * 
+        # * \param[in] H Gradient histograms.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] bin_size Spatial bin size.
+        # * \param[in] n_orients Number of orientation bins.  
+        # * \param[in] clip Value at which to clip histogram bins.      
+        # * \param[out] G Normalized gradient histograms.
+        # */
+        # void normalization ( float *H, int h, int w, int bin_size, int n_orients, float clip, float *G ) const;
+        # /**
+        # * \brief Compute HOG descriptor.
+        # * 
+        # * \param[in] I Image as array of float between 0 and 1.
+        # * \param[in] h Image height.
+        # * \param[in] w Image width.
+        # * \param[in] n_channels Image number of channels.
+        # * \param[in] bin_size Spatial bin size.  
+        # * \param[in] n_orients Number of orientation bins.     
+        # * \param[in] soft_bin If true, each pixel can contribute to multiple spatial bins (using bilinear interpolation).
+        # * \param[out] descriptor HOG descriptor.
+        # */
+        # void compute (float *I, int h, int w, int n_channels, int bin_size, int n_orients, bool soft_bin, float *descriptor);
+        # /**
+        # * \brief Compute HOG descriptor with default parameters.
+        # * \param[in] I Image as array of float between 0 and 1.
+        # * \param[out] descriptor HOG descriptor.
+        # */
+        # void compute (float *I, float *descriptor) const;
+        # protected:
+        # /** \brief image height (default = 128) */
+        # int h_;
+        # /** \brief image width (default = 64) */
+        # int w_;
+        # /** \brief image number of channels (default = 3) */
+        # int n_channels_;
+        # /** \brief spatial bin size (default = 8) */
+        # int bin_size_; 
+        # /** \brief number of orientation bins (default = 9) */
+        # int n_orients_;
+        # /** \brief if true, each pixel can contribute to multiple spatial bins (using bilinear interpolation) (default = true) */
+        # bool soft_bin_;   
+        # /** \brief value at which to clip histogram bins (default = 0.2) */
+        # float clip_; 
+###
+
+
diff --git a/pcl/pcl_PointCloud2_160.pxd b/pcl/pcl_PointCloud2_160.pxd
new file mode 100644
index 0000000..b772bda
--- /dev/null
+++ b/pcl/pcl_PointCloud2_160.pxd
@@ -0,0 +1,107 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+cdef extern from "sensor_msgs/Image.h" namespace "std_msgs":
+    cdef struct Header:
+        Header ()
+        # pcl::uint32_t seq
+        # pcl::uint64_t stamp
+        unsigned int seq
+        unsigned long stamp
+        string frame_id
+
+# typedef boost::shared_ptr<Header> HeaderPtr;
+# typedef boost::shared_ptr<Header const> HeaderConstPtr;
+# inline std::ostream& operator << (std::ostream& out, const Header &h)
+
+ctypedef shared_ptr[Header] HeaderPtr_t
+ctypedef shared_ptr[const Header] HeaderConstPtr_t
+###
+
+
+cdef extern from "sensor_msgs/Image.h" namespace "sensor_msgs":
+    cdef struct Image:
+        Image ()
+        Header header
+        unsigned int height
+        unsigned int width
+        string encoding
+        unsigned char is_bigendian
+        unsigned int step;
+        vector[unsigned int] data;
+
+# inline std::ostream& operator<<(std::ostream& s, const  ::sensor_msgs::Image & v)
+
+ctypedef shared_ptr[Image] ImagePtr_t
+ctypedef shared_ptr[const Image] ImageConstPtr_t
+###
+
+cdef extern from "sensor_msgs/PointCloud2.h" namespace "sensor_msgs":
+    cdef struct PointCloud2:
+        PointCloud2 ()
+        Header header
+        unsigned int height
+        unsigned int width
+        vector[PointField] fields
+        unsigned char is_bigendian
+        unsigned int point_step
+        unsigned int row_step
+        vector[unsigned char] data
+        unsigned char is_dense
+
+#  inline std::ostream& operator<<(std::ostream& s, const  ::sensor_msgs::PointCloud2 &v)
+
+# ctypedef sharedptr[PointCloud2] PointCloud2Ptr_t
+# ctypedef sharedptr[const PointCloud2] PointCloud2ConstPtr_t
+ctypedef cpp.PointCloud[PointCloud2] PointCloud_PointCloud2_t
+ctypedef shared_ptr[cpp.PointCloud[PointCloud2]] PointCloud_PointCloud2Ptr_t
+###
+
+cdef extern from "sensor_msgs/PointField.h" namespace "sensor_msgs":
+    cdef struct PointField:
+        PointField ()
+        string name
+        unsigned int offset
+        unsigned char datatype
+        unsigned int count
+
+# inline std::ostream& operator<<(std::ostream& s, const  ::sensor_msgs::PointField & v)
+
+# ctypedef sharedptr[PointField] PointFieldPtr_t
+# ctypedef sharedptr[const PointField] PointFieldConstPtr_t
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+cdef extern from "sensor_msgs/PointField.h" namespace "sensor_msgs":
+    cdef enum:
+        INT8 = 1
+        UINT8 = 2
+        INT16 = 3
+        UINT16 = 4
+        INT32 = 5
+        UINT32 = 6
+        FLOAT32 = 7
+        FLOAT64 = 8
+
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_Recognition_172.pxd b/pcl/pcl_Recognition_172.pxd
new file mode 100644
index 0000000..a205b9a
--- /dev/null
+++ b/pcl/pcl_Recognition_172.pxd
@@ -0,0 +1,5192 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# quantizable_modality.h
+# namespace pcl
+# {
+# /** \brief Interface for a quantizable modality. 
+#  * \author Stefan Holzer
+#  */
+# class PCL_EXPORTS QuantizableModality
+cdef extern from "pcl/Recognition/quantizable_modality.h" namespace "pcl":
+    cdef cppclass Feature[In, Out](cpp.PCLBase[In]):
+        QuantizableModality ()
+        # /** \brief Destructor. */
+        # virtual ~QuantizableModality ();
+        
+        # /** \brief Returns a reference to the internally computed quantized map. */
+        # virtual QuantizedMap & getQuantizedMap () = 0;
+        
+        # /** \brief Returns a reference to the internally computed spreaded quantized map. */
+        # virtual QuantizedMap & getSpreadedQuantizedMap () = 0;
+        
+        # /** \brief Extracts features from this modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features defines the number of features to be extracted 
+        #   *            (might be less if not sufficient information is present in the modality).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # virtual void extractFeatures (
+        #       const MaskMap & mask, size_t nr_features, size_t modality_index, 
+        #         std::vector<QuantizedMultiModFeature> & features) const = 0;
+        # 
+        # /** \brief Extracts all possible features from the modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features IGNORED (TODO: remove this parameter).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # virtual void  extractAllFeatures (const MaskMap & mask, size_t nr_features, size_t modality_index, 
+        #                                       std::vector<QuantizedMultiModFeature> & features) const = 0;
+
+###
+
+### Inheritance class ###
+
+# auxiliary.h
+# #include <pcl/recognition/ransac_based/auxiliary.h>
+###
+
+# boost.h
+# #include <boost/unordered_map.hpp>
+# #include <boost/graph/graph_traits.hpp>
+###
+
+# bvh.h
+# #include <pcl/recognition/ransac_based/bvh.h>
+###
+
+# color_gradient_dot_modality.h
+# namespace pcl
+# {
+# 
+#   /** \brief A point structure for representing RGB color
+#     * \ingroup common
+#     */
+#   struct EIGEN_ALIGN16 PointRGB
+#   {
+#     union
+#     {
+#       union
+#       {
+#         struct
+#         {
+#           uint8_t b;
+#           uint8_t g;
+#           uint8_t r;
+#           uint8_t _unused;
+#         };
+#         float rgb;
+#       };
+#       uint32_t rgba;
+#     };
+# 
+#     inline PointRGB ()
+#     {}
+# 
+#     inline PointRGB (const uint8_t b, const uint8_t g, const uint8_t r)
+#       : b (b), g (g), r (r), _unused (0)
+#     {}
+# 
+#     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+# 
+#   /** \brief A point structure representing Euclidean xyz coordinates, and the intensity value.
+#     * \ingroup common
+#     */
+#   struct EIGEN_ALIGN16 GradientXY
+#   {
+#     union
+#     {
+#       struct
+#       {
+#         float x;
+#         float y;
+#         float angle;
+#         float magnitude;
+#       };
+#       float data[4];
+#     };
+#     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+# 
+#     inline bool operator< (const GradientXY & rhs)
+#     {
+#       return (magnitude > rhs.magnitude);
+#     }
+#   };
+#   inline std::ostream & operator << (std::ostream & os, const GradientXY & p)
+#   {
+#     os << "(" << p.x << "," << p.y << " - " << p.magnitude << ")";
+#    return (os);
+#   }
+# 
+#   // --------------------------------------------------------------------------
+
+
+#   template <typename PointInT>
+#   class ColorGradientDOTModality : public DOTModality, public PCLBase<PointInT>
+#   {
+#     protected:
+#       using PCLBase<PointInT>::input_;
+# 
+#     struct Candidate
+#     {
+#       GradientXY gradient;
+#     
+#       int x;
+#       int y;  
+#     
+#       bool operator< (const Candidate & rhs)
+#       {
+#         return (gradient.magnitude > rhs.gradient.magnitude);
+#       }
+#     };
+# 
+#     public:
+#       typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+# 
+#       ColorGradientDOTModality (size_t bin_size);
+#   
+#       virtual ~ColorGradientDOTModality ();
+#   
+#       inline void
+#       setGradientMagnitudeThreshold (const float threshold)
+#       {
+#         gradient_magnitude_threshold_ = threshold;
+#       }
+#   
+#       //inline QuantizedMap &
+#       //getDominantQuantizedMap () 
+#       //{ 
+#       //  return (dominant_quantized_color_gradients_);
+#       //}
+#   
+#       inline QuantizedMap &
+#       getDominantQuantizedMap () 
+#       { 
+#         return (dominant_quantized_color_gradients_);
+#       }
+# 
+#       QuantizedMap
+#       computeInvariantQuantizedMap (const MaskMap & mask,
+#                                    const RegionXY & region);
+#   
+#       /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+#         * \param cloud the const boost shared pointer to a PointCloud message
+#         */
+#       virtual void 
+#       setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+#       { 
+#         input_ = cloud;
+#         //processInputData ();
+#       }
+# 
+#       virtual void
+#       processInputData ();
+# 
+#     protected:
+# 
+#       void
+#       computeMaxColorGradients ();
+#   
+#       void
+#       computeDominantQuantizedGradients ();
+#   
+#       //void
+#       //computeInvariantQuantizedGradients ();
+#   
+#     private:
+#       size_t bin_size_;
+# 
+#       float gradient_magnitude_threshold_;
+#       pcl::PointCloud<pcl::GradientXY> color_gradients_;
+#   
+#       pcl::QuantizedMap dominant_quantized_color_gradients_;
+#       //pcl::QuantizedMap invariant_quantized_color_gradients_;
+#   
+#   };
+# 
+# }
+
+# template <typename PointInT>
+# pcl::ColorGradientDOTModality<PointInT>::ColorGradientDOTModality (const size_t bin_size)
+#   : bin_size_ (bin_size), gradient_magnitude_threshold_ (80.0f), color_gradients_ (), dominant_quantized_color_gradients_ ()
+# {
+# }
+# 
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# pcl::ColorGradientDOTModality<PointInT>::
+# ~ColorGradientDOTModality ()
+# {
+# }
+# 
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# void
+# pcl::ColorGradientDOTModality<PointInT>::
+# processInputData ()
+# {
+#   // extract color gradients
+#   computeMaxColorGradients ();
+# 
+#   // compute dominant quantized gradient map
+#   computeDominantQuantizedGradients ();
+# 
+#   // compute invariant quantized gradient map
+#   //computeInvariantQuantizedGradients ();
+# }
+# 
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# void
+# pcl::ColorGradientDOTModality<PointInT>::
+# computeMaxColorGradients ()
+# {
+#   const int width = input_->width;
+#   const int height = input_->height;
+# 
+#   color_gradients_.points.resize (width*height);
+#   color_gradients_.width = width;
+#   color_gradients_.height = height;
+# 
+#   const float pi = tan(1.0f)*4;
+#   for (int row_index = 0; row_index < height-2; ++row_index)
+#   {
+#     for (int col_index = 0; col_index < width-2; ++col_index)
+#     {
+#       const int index0 = row_index*width+col_index;
+#       const int index_c = row_index*width+col_index+2;
+#       const int index_r = (row_index+2)*width+col_index;
+# 
+#       //const int index_d = (row_index+1)*width+col_index+1;
+# 
+#       const unsigned char r0 = input_->points[index0].r;
+#       const unsigned char g0 = input_->points[index0].g;
+#       const unsigned char b0 = input_->points[index0].b;
+# 
+#       const unsigned char r_c = input_->points[index_c].r;
+#       const unsigned char g_c = input_->points[index_c].g;
+#       const unsigned char b_c = input_->points[index_c].b;
+# 
+#       const unsigned char r_r = input_->points[index_r].r;
+#       const unsigned char g_r = input_->points[index_r].g;
+#       const unsigned char b_r = input_->points[index_r].b;
+# 
+#       const float r_dx = static_cast<float> (r_c) - static_cast<float> (r0);
+#       const float g_dx = static_cast<float> (g_c) - static_cast<float> (g0);
+#       const float b_dx = static_cast<float> (b_c) - static_cast<float> (b0);
+# 
+#       const float r_dy = static_cast<float> (r_r) - static_cast<float> (r0);
+#       const float g_dy = static_cast<float> (g_r) - static_cast<float> (g0);
+#       const float b_dy = static_cast<float> (b_r) - static_cast<float> (b0);
+# 
+#       const float sqr_mag_r = r_dx*r_dx + r_dy*r_dy;
+#       const float sqr_mag_g = g_dx*g_dx + g_dy*g_dy;
+#       const float sqr_mag_b = b_dx*b_dx + b_dy*b_dy;
+# 
+#       GradientXY gradient;
+#       gradient.x = col_index;
+#       gradient.y = row_index;
+#       if (sqr_mag_r > sqr_mag_g && sqr_mag_r > sqr_mag_b)
+#       {
+#         gradient.magnitude = sqrt (sqr_mag_r);
+#         gradient.angle = atan2 (r_dy, r_dx) * 180.0f / pi;
+#       }
+#       else if (sqr_mag_g > sqr_mag_b)
+#       {
+#         //GradientXY gradient;
+#         gradient.magnitude = sqrt (sqr_mag_g);
+#         gradient.angle = atan2 (g_dy, g_dx) * 180.0f / pi;
+#         //gradient.x = col_index;
+#         //gradient.y = row_index;
+# 
+#         //color_gradients_ (col_index+1, row_index+1) = gradient;
+#       }
+#       else
+#       {
+#         //GradientXY gradient;
+#         gradient.magnitude = sqrt (sqr_mag_b);
+#         gradient.angle = atan2 (b_dy, b_dx) * 180.0f / pi;
+#         //gradient.x = col_index;
+#         //gradient.y = row_index;
+# 
+#         //color_gradients_ (col_index+1, row_index+1) = gradient;
+#       }
+# 
+#       assert (color_gradients_ (col_index+1, row_index+1).angle >= -180 &&
+#               color_gradients_ (col_index+1, row_index+1).angle <=  180);
+# 
+#       color_gradients_ (col_index+1, row_index+1) = gradient;
+#     }
+#   }
+# 
+#   return;
+# }
+
+
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# void
+# pcl::ColorGradientDOTModality<PointInT>::
+# computeDominantQuantizedGradients ()
+# {
+#   const size_t input_width = input_->width;
+#   const size_t input_height = input_->height;
+# 
+#   const size_t output_width = input_width / bin_size_;
+#   const size_t output_height = input_height / bin_size_;
+# 
+#   dominant_quantized_color_gradients_.resize (output_width, output_height);
+# 
+#   //size_t offset_x = 0;
+#   //size_t offset_y = 0;
+#   
+#   const size_t num_gradient_bins = 7;
+#   const size_t max_num_of_gradients = 1;
+#   
+#   const float divisor = 180.0f / (num_gradient_bins - 1.0f);
+#   
+#   float global_max_gradient = 0.0f;
+#   float local_max_gradient = 0.0f;
+#   
+#   unsigned char * peak_pointer = dominant_quantized_color_gradients_.getData ();
+#   memset (peak_pointer, 0, output_width*output_height);
+#   
+#   //int tmpCounter = 0;
+#   for (size_t row_bin_index = 0; row_bin_index < output_height; ++row_bin_index)
+#   {
+#     for (size_t col_bin_index = 0; col_bin_index < output_width; ++col_bin_index)
+#     {
+#       const size_t x_position = col_bin_index * bin_size_;
+#       const size_t y_position = row_bin_index * bin_size_;
+# 
+#       //std::vector<int> x_coordinates;
+#       //std::vector<int> y_coordinates;
+#       //std::vector<float> values;
+#       
+#       // iteratively search for the largest gradients, set it to -1, search the next largest ... etc.
+#       //while (counter < max_num_of_gradients)
+#       {
+#         float max_gradient;
+#         size_t max_gradient_pos_x;
+#         size_t max_gradient_pos_y;
+#             
+#         // find next location and value of maximum gradient magnitude in current region
+#         {
+#           max_gradient = 0.0f;
+#           for (size_t row_sub_index = 0; row_sub_index < bin_size_; ++row_sub_index)
+#           {
+#             for (size_t col_sub_index = 0; col_sub_index < bin_size_; ++col_sub_index)
+#             {
+#               const float magnitude = color_gradients_ (col_sub_index + x_position, row_sub_index + y_position).magnitude;
+# 
+#               if (magnitude > max_gradient)
+#               {
+#                 max_gradient = magnitude;
+#                 max_gradient_pos_x = col_sub_index;
+#                 max_gradient_pos_y = row_sub_index;
+#               }
+#             }
+#           }
+#         }
+#             
+#         if (max_gradient >= gradient_magnitude_threshold_)
+#         {
+#           const size_t angle = static_cast<size_t> (180 + color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).angle + 0.5f);
+#           const size_t bin_index = static_cast<size_t> ((angle >= 180 ? angle-180 : angle)/divisor);
+#             
+#           *peak_pointer |= 1 << bin_index;
+#         }
+#             
+#         //++counter;
+#             
+#         //x_coordinates.push_back (max_gradient_pos_x + x_position);
+#         //y_coordinates.push_back (max_gradient_pos_y + y_position);
+#         //values.push_back (max_gradient);
+#             
+#         //color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).magnitude = -1.0f;
+#       }
+# 
+#       //// reset values which have been set to -1
+#       //for (size_t value_index = 0; value_index < values.size (); ++value_index)
+#       //{
+#       //  color_gradients_ (x_coordinates[value_index], y_coordinates[value_index]).magnitude = values[value_index];
+#       //}
+# 
+# 
+#       if (*peak_pointer == 0)
+#       {
+#         *peak_pointer |= 1 << 7;
+#       }
+# 
+#       //if (*peakPointer != 0)
+#       //{
+#       //  ++tmpCounter;
+#       //}
+#       
+#       //++stringPointer;
+#       ++peak_pointer;
+#       
+#       //offset_x += bin_size;
+#     }
+#     
+#     //offset_y += bin_size;
+#     //offset_x = bin_size/2+1;
+#   }
+# }
+
+
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# pcl::QuantizedMap
+# pcl::ColorGradientDOTModality<PointInT>::
+# computeInvariantQuantizedMap (const MaskMap & mask,
+#                               const RegionXY & region)
+# {
+#   const size_t input_width = input_->width;
+#   const size_t input_height = input_->height;
+# 
+#   const size_t output_width = input_width / bin_size_;
+#   const size_t output_height = input_height / bin_size_;
+# 
+#   const size_t sub_start_x = region.x / bin_size_;
+#   const size_t sub_start_y = region.y / bin_size_;
+#   const size_t sub_width = region.width / bin_size_;
+#   const size_t sub_height = region.height / bin_size_;
+# 
+#   QuantizedMap map;
+#   map.resize (sub_width, sub_height);
+# 
+#   //size_t offset_x = 0;
+#   //size_t offset_y = 0;
+#   
+#   const size_t num_gradient_bins = 7;
+#   const size_t max_num_of_gradients = 7;
+#   
+#   const float divisor = 180.0f / (num_gradient_bins - 1.0f);
+#   
+#   float global_max_gradient = 0.0f;
+#   float local_max_gradient = 0.0f;
+#   
+#   unsigned char * peak_pointer = map.getData ();
+#   
+#   //int tmpCounter = 0;
+#   for (size_t row_bin_index = 0; row_bin_index < sub_height; ++row_bin_index)
+#   {
+#     for (size_t col_bin_index = 0; col_bin_index < sub_width; ++col_bin_index)
+#     {
+#       std::vector<size_t> x_coordinates;
+#       std::vector<size_t> y_coordinates;
+#       std::vector<float> values;
+#       
+#       for (int row_pixel_index = -static_cast<int> (bin_size_)/2; 
+#            row_pixel_index <= static_cast<int> (bin_size_)/2; 
+#            row_pixel_index += static_cast<int> (bin_size_)/2)
+#       {
+#         const size_t y_position = /*offset_y +*/ row_pixel_index + (sub_start_y + row_bin_index)*bin_size_;
+# 
+#         if (y_position < 0 || y_position >= input_height) 
+#           continue;
+# 
+#         for (int col_pixel_index = -static_cast<int> (bin_size_)/2; 
+#              col_pixel_index <= static_cast<int> (bin_size_)/2; 
+#              col_pixel_index += static_cast<int> (bin_size_)/2)
+#         {
+#           const size_t x_position = /*offset_x +*/ col_pixel_index + (sub_start_x + col_bin_index)*bin_size_;
+#           size_t counter = 0;
+#           
+#           if (x_position < 0 || x_position >= input_width) 
+#             continue;
+# 
+#           // find maximum gradient magnitude in current bin
+#           {
+#             local_max_gradient = 0.0f;
+#             for (size_t row_sub_index = 0; row_sub_index < bin_size_; ++row_sub_index)
+#             {
+#               for (size_t col_sub_index = 0; col_sub_index < bin_size_; ++col_sub_index)
+#               {
+#                 const float magnitude = color_gradients_ (col_sub_index + x_position, row_sub_index + y_position).magnitude;
+# 
+#                 if (magnitude > local_max_gradient)
+#                   local_max_gradient = magnitude;
+#               }
+#             }
+#           }
+#           
+#           //*stringPointer += localMaxGradient;
+#           
+#           if (local_max_gradient > global_max_gradient)
+#           {
+#             global_max_gradient = local_max_gradient;
+#           }
+#           
+#           // iteratively search for the largest gradients, set it to -1, search the next largest ... etc.
+#           while (true)
+#           {
+#             float max_gradient;
+#             size_t max_gradient_pos_x;
+#             size_t max_gradient_pos_y;
+#             
+#             // find next location and value of maximum gradient magnitude in current region
+#             {
+#               max_gradient = 0.0f;
+#               for (size_t row_sub_index = 0; row_sub_index < bin_size_; ++row_sub_index)
+#               {
+#                 for (size_t col_sub_index = 0; col_sub_index < bin_size_; ++col_sub_index)
+#                 {
+#                   const float magnitude = color_gradients_ (col_sub_index + x_position, row_sub_index + y_position).magnitude;
+# 
+#                   if (magnitude > max_gradient)
+#                   {
+#                     max_gradient = magnitude;
+#                     max_gradient_pos_x = col_sub_index;
+#                     max_gradient_pos_y = row_sub_index;
+#                   }
+#                 }
+#               }
+#             }
+#             
+#             // TODO: really localMaxGradient and not maxGradient???
+#             if (local_max_gradient < gradient_magnitude_threshold_)
+#             {
+#               //*peakPointer |= 1 << (numOfGradientBins-1);
+#               break;
+#             }
+#             
+#             // TODO: replace gradient_magnitude_threshold_ here by a fixed ratio?
+#             if (/*max_gradient < (local_max_gradient * gradient_magnitude_threshold_) ||*/
+#                 counter >= max_num_of_gradients)
+#             {
+#               break;
+#             }
+#             
+#             ++counter;
+#             
+#             const size_t angle = static_cast<size_t> (180 + color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).angle + 0.5f);
+#             const size_t bin_index = static_cast<size_t> ((angle >= 180 ? angle-180 : angle)/divisor);
+#             
+#             *peak_pointer |= 1 << bin_index;
+#             
+#             x_coordinates.push_back (max_gradient_pos_x + x_position);
+#             y_coordinates.push_back (max_gradient_pos_y + y_position);
+#             values.push_back (max_gradient);
+#             
+#             color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).magnitude = -1.0f;
+#           }
+#           
+#           // reset values which have been set to -1
+#           for (size_t value_index = 0; value_index < values.size (); ++value_index)
+#           {
+#             color_gradients_ (x_coordinates[value_index], y_coordinates[value_index]).magnitude = values[value_index];
+#           }
+#           
+#           x_coordinates.clear ();
+#           y_coordinates.clear ();
+#           values.clear ();
+#         }
+#       }
+# 
+#       if (*peak_pointer == 0)
+#       {
+#         *peak_pointer |= 1 << 7;
+#       }
+# 
+#       //if (*peakPointer != 0)
+#       //{
+#       //  ++tmpCounter;
+#       //}
+#       
+#       //++stringPointer;
+#       ++peak_pointer;
+#       
+#       //offset_x += bin_size;
+#     }
+#     
+#     //offset_y += bin_size;
+#     //offset_x = bin_size/2+1;
+#   }
+# 
+#   return map;
+# }
+# 
+# #endif
+
+# color_gradient_modality.h
+# namespace pcl
+# 
+# /** \brief Modality based on max-RGB gradients.
+#   * \author Stefan Holzer
+#   */
+# template <typename PointInT>
+# class ColorGradientModality : public QuantizableModality, public PCLBase<PointInT>
+  {
+    protected:
+      using PCLBase<PointInT>::input_;
+
+      /** \brief Candidate for a feature (used in feature extraction methods). */
+      struct Candidate
+      {
+        /** \brief The gradient. */
+        GradientXY gradient;
+    
+        /** \brief The x-position. */
+        int x;
+        /** \brief The y-position. */
+        int y;  
+    
+        /** \brief Operator for comparing to candidates (by magnitude of the gradient).
+          * \param[in] rhs the candidate to compare with.
+          */
+        bool operator< (const Candidate & rhs) const
+        {
+          return (gradient.magnitude > rhs.gradient.magnitude);
+        }
+      };
+
+    public:
+      typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+
+      /** \brief Different methods for feature selection/extraction. */
+      enum FeatureSelectionMethod
+      {
+        MASK_BORDER_HIGH_GRADIENTS,
+        MASK_BORDER_EQUALLY, // this gives templates most equally to the OpenCV implementation
+        DISTANCE_MAGNITUDE_SCORE
+      };
+
+      /** \brief Constructor. */
+      ColorGradientModality ();
+      /** \brief Destructor. */
+      virtual ~ColorGradientModality ();
+  
+      /** \brief Sets the threshold for the gradient magnitude which is used when quantizing the data.
+        *        Gradients with a smaller magnitude are ignored. 
+        * \param[in] threshold the new gradient magnitude threshold.
+        */
+      inline void
+      setGradientMagnitudeThreshold (const float threshold)
+      {
+        gradient_magnitude_threshold_ = threshold;
+      }
+
+      /** \brief Sets the threshold for the gradient magnitude which is used for feature extraction.
+        *        Gradients with a smaller magnitude are ignored. 
+        * \param[in] threshold the new gradient magnitude threshold.
+        */
+      inline void
+      setGradientMagnitudeThresholdForFeatureExtraction (const float threshold)
+      {
+        gradient_magnitude_threshold_feature_extraction_ = threshold;
+      }
+
+      /** \brief Sets the feature selection method.
+        * \param[in] method the feature selection method.
+        */
+      inline void
+      setFeatureSelectionMethod (const FeatureSelectionMethod method)
+      {
+        feature_selection_method_ = method;
+      }
+  
+      /** \brief Sets the spreading size for spreading the quantized data. */
+      inline void
+      setSpreadingSize (const size_t spreading_size)
+      {
+        spreading_size_ = spreading_size;
+      }
+
+      /** \brief Sets whether variable feature numbers for feature extraction is enabled.
+        * \param[in] enabled enables/disables variable feature numbers for feature extraction.
+        */
+      inline void
+      setVariableFeatureNr (const bool enabled)
+      {
+        variable_feature_nr_ = enabled;
+      }
+
+      /** \brief Returns a reference to the internally computed quantized map. */
+      inline QuantizedMap &
+      getQuantizedMap () 
+      { 
+        return (filtered_quantized_color_gradients_);
+      }
+  
+      /** \brief Returns a reference to the internally computed spreaded quantized map. */
+      inline QuantizedMap &
+      getSpreadedQuantizedMap () 
+      { 
+        return (spreaded_filtered_quantized_color_gradients_);
+      }
+
+      /** \brief Returns a point cloud containing the max-RGB gradients. */
+      inline pcl::PointCloud<pcl::GradientXY> &
+      getMaxColorGradients ()
+      {
+        return (color_gradients_);
+      }
+  
+      /** \brief Extracts features from this modality within the specified mask.
+        * \param[in] mask defines the areas where features are searched in. 
+        * \param[in] nr_features defines the number of features to be extracted 
+        *            (might be less if not sufficient information is present in the modality).
+        * \param[in] modalityIndex the index which is stored in the extracted features.
+        * \param[out] features the destination for the extracted features.
+        */
+      void
+      extractFeatures (const MaskMap & mask, size_t nr_features, size_t modalityIndex,
+                       std::vector<QuantizedMultiModFeature> & features) const;
+  
+      /** \brief Extracts all possible features from the modality within the specified mask.
+        * \param[in] mask defines the areas where features are searched in. 
+        * \param[in] nr_features IGNORED (TODO: remove this parameter).
+        * \param[in] modalityIndex the index which is stored in the extracted features.
+        * \param[out] features the destination for the extracted features.
+        */
+      void
+      extractAllFeatures (const MaskMap & mask, size_t nr_features, size_t modalityIndex,
+                          std::vector<QuantizedMultiModFeature> & features) const;
+  
+      /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        * \param cloud the const boost shared pointer to a PointCloud message
+        */
+      virtual void 
+      setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+      { 
+        input_ = cloud;
+      }
+
+      /** \brief Processes the input data (smoothing, computing gradients, quantizing, filtering, spreading). */
+      virtual void
+      processInputData ();
+
+      /** \brief Processes the input data assuming that everything up to filtering is already done/available 
+        *        (so only spreading is performed). */
+      virtual void
+      processInputDataFromFiltered ();
+
+    protected:
+
+      /** \brief Computes the Gaussian kernel used for smoothing. 
+        * \param[in] kernel_size the size of the Gaussian kernel. 
+        * \param[in] sigma the sigma.
+        * \param[out] kernel_values the destination for the values of the kernel. */
+      void
+      computeGaussianKernel (const size_t kernel_size, const float sigma, std::vector <float> & kernel_values);
+
+      /** \brief Computes the max-RGB gradients for the specified cloud.
+        * \param[in] cloud the cloud for which the gradients are computed.
+        */
+      void
+      computeMaxColorGradients (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud);
+
+      /** \brief Computes the max-RGB gradients for the specified cloud using sobel.
+        * \param[in] cloud the cloud for which the gradients are computed.
+        */
+      void
+      computeMaxColorGradientsSobel (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud);
+  
+      /** \brief Quantizes the color gradients. */
+      void
+      quantizeColorGradients ();
+  
+      /** \brief Filters the quantized gradients. */
+      void
+      filterQuantizedColorGradients ();
+
+      /** \brief Erodes a mask.
+        * \param[in] mask_in the mask which will be eroded.
+        * \param[out] mask_out the destination for the eroded mask.
+        */
+      static void
+      erode (const pcl::MaskMap & mask_in, pcl::MaskMap & mask_out);
+  
+    private:
+
+      /** \brief Determines whether variable numbers of features are extracted or not. */
+      bool variable_feature_nr_;
+
+      /** \brief Stores a smoothed verion of the input cloud. */
+        pcl::PointCloud<pcl::RGB>::Ptr smoothed_input_;
+
+      /** \brief Defines which feature selection method is used. */
+      FeatureSelectionMethod feature_selection_method_;
+
+      /** \brief The threshold applied on the gradient magnitudes (for quantization). */
+      float gradient_magnitude_threshold_;
+      /** \brief The threshold applied on the gradient magnitudes for feature extraction. */
+      float gradient_magnitude_threshold_feature_extraction_;
+
+      /** \brief The point cloud which holds the max-RGB gradients. */
+      pcl::PointCloud<pcl::GradientXY> color_gradients_;
+
+      /** \brief The spreading size. */
+      size_t spreading_size_;
+  
+      /** \brief The map which holds the quantized max-RGB gradients. */
+      pcl::QuantizedMap quantized_color_gradients_;
+      /** \brief The map which holds the filtered quantized data. */
+      pcl::QuantizedMap filtered_quantized_color_gradients_;
+      /** \brief The map which holds the spreaded quantized data. */
+      pcl::QuantizedMap spreaded_filtered_quantized_color_gradients_;
+  
+  };
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorGradientModality<PointInT>::
+ColorGradientModality ()
+  : variable_feature_nr_ (false)
+  , smoothed_input_ (new pcl::PointCloud<pcl::RGB> ())
+  , feature_selection_method_ (DISTANCE_MAGNITUDE_SCORE)
+  , gradient_magnitude_threshold_ (10.0f)
+  , gradient_magnitude_threshold_feature_extraction_ (55.0f)
+  , color_gradients_ ()
+  , spreading_size_ (8)
+  , quantized_color_gradients_ ()
+  , filtered_quantized_color_gradients_ ()
+  , spreaded_filtered_quantized_color_gradients_ ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorGradientModality<PointInT>::
+~ColorGradientModality ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT> void
+pcl::ColorGradientModality<PointInT>::
+computeGaussianKernel (const size_t kernel_size, const float sigma, std::vector <float> & kernel_values)
+{
+  // code taken from OpenCV
+  const int n = int (kernel_size);
+  const int SMALL_GAUSSIAN_SIZE = 7;
+  static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =
+  {
+      {1.f},
+      {0.25f, 0.5f, 0.25f},
+      {0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},
+      {0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f}
+  };
+
+  const float* fixed_kernel = n % 2 == 1 && n <= SMALL_GAUSSIAN_SIZE && sigma <= 0 ?
+      small_gaussian_tab[n>>1] : 0;
+
+  //CV_Assert( ktype == CV_32F || ktype == CV_64F );
+  /*Mat kernel(n, 1, ktype);*/
+  kernel_values.resize (n);
+  float* cf = &(kernel_values[0]);
+  //double* cd = (double*)kernel.data;
+
+  double sigmaX = sigma > 0 ? sigma : ((n-1)*0.5 - 1)*0.3 + 0.8;
+  double scale2X = -0.5/(sigmaX*sigmaX);
+  double sum = 0;
+
+  int i;
+  for( i = 0; i < n; i++ )
+  {
+    double x = i - (n-1)*0.5;
+    double t = fixed_kernel ? double (fixed_kernel[i]) : std::exp (scale2X*x*x);
+
+    cf[i] = float (t);
+    sum += cf[i];
+  }
+
+  sum = 1./sum;
+  for (i = 0; i < n; i++ )
+  {
+    cf[i] = float (cf[i]*sum);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+processInputData ()
+{
+  // compute gaussian kernel values
+  const size_t kernel_size = 7;
+  std::vector<float> kernel_values;
+  computeGaussianKernel (kernel_size, 0.0f, kernel_values);
+
+  // smooth input
+    pcl::filters::Convolution<pcl::RGB, pcl::RGB> convolution;
+    Eigen::ArrayXf gaussian_kernel(kernel_size);
+    //gaussian_kernel << 1.f/16, 1.f/8, 3.f/16, 2.f/8, 3.f/16, 1.f/8, 1.f/16;
+    //gaussian_kernel << 16.f/1600.f,  32.f/1600.f,  64.f/1600.f, 128.f/1600.f, 256.f/1600.f, 128.f/1600.f,  64.f/1600.f,  32.f/1600.f,  16.f/1600.f;
+  gaussian_kernel << kernel_values[0], kernel_values[1], kernel_values[2], kernel_values[3], kernel_values[4], kernel_values[5], kernel_values[6];
+
+  pcl::PointCloud<pcl::RGB>::Ptr rgb_input_ (new pcl::PointCloud<pcl::RGB>());
+  
+  const uint32_t width = input_->width;
+  const uint32_t height = input_->height;
+
+  rgb_input_->resize (width*height);
+  rgb_input_->width = width;
+  rgb_input_->height = height;
+  rgb_input_->is_dense = input_->is_dense;
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      (*rgb_input_) (col_index, row_index).r = (*input_) (col_index, row_index).r;
+      (*rgb_input_) (col_index, row_index).g = (*input_) (col_index, row_index).g;
+      (*rgb_input_) (col_index, row_index).b = (*input_) (col_index, row_index).b;
+    }
+  }
+
+    convolution.setInputCloud (rgb_input_);
+    convolution.setKernel (gaussian_kernel);
+
+  convolution.convolve (*smoothed_input_);
+
+  // extract color gradients
+  computeMaxColorGradientsSobel (smoothed_input_);
+
+  // quantize gradients
+  quantizeColorGradients ();
+
+  // filter quantized gradients to get only dominants one + thresholding
+  filterQuantizedColorGradients ();
+
+  // spread filtered quantized gradients
+  //spreadFilteredQunatizedColorGradients ();
+  pcl::QuantizedMap::spreadQuantizedMap (filtered_quantized_color_gradients_,
+                                         spreaded_filtered_quantized_color_gradients_, 
+                                         spreading_size_);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+processInputDataFromFiltered ()
+{
+  // spread filtered quantized gradients
+  //spreadFilteredQunatizedColorGradients ();
+  pcl::QuantizedMap::spreadQuantizedMap (filtered_quantized_color_gradients_,
+                                         spreaded_filtered_quantized_color_gradients_, 
+                                         spreading_size_);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void pcl::ColorGradientModality<PointInT>::
+extractFeatures (const MaskMap & mask, const size_t nr_features, const size_t modality_index,
+                 std::vector<QuantizedMultiModFeature> & features) const
+{
+  const size_t width = mask.getWidth ();
+  const size_t height = mask.getHeight ();
+  
+  std::list<Candidate> list1;
+  std::list<Candidate> list2;
+
+
+  if (feature_selection_method_ == DISTANCE_MAGNITUDE_SCORE)
+  {
+    for (size_t row_index = 0; row_index < height; ++row_index)
+    {
+      for (size_t col_index = 0; col_index < width; ++col_index)
+      {
+        if (mask (col_index, row_index) != 0)
+        {
+          const GradientXY & gradient = color_gradients_ (col_index, row_index);
+          if (gradient.magnitude > gradient_magnitude_threshold_feature_extraction_
+            && filtered_quantized_color_gradients_ (col_index, row_index) != 0)
+          {
+            Candidate candidate;
+            candidate.gradient = gradient;
+            candidate.x = static_cast<int> (col_index);
+            candidate.y = static_cast<int> (row_index);
+
+            list1.push_back (candidate);
+          }
+        }
+      }
+    }
+
+    list1.sort();
+
+    if (variable_feature_nr_)
+    {
+      list2.push_back (*(list1.begin ()));
+      //while (list2.size () != nr_features)
+      bool feature_selection_finished = false;
+      while (!feature_selection_finished)
+      {
+        float best_score = 0.0f;
+        typename std::list<Candidate>::iterator best_iter = list1.end ();
+        for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+        {
+          // find smallest distance
+          float smallest_distance = std::numeric_limits<float>::max ();
+          for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+          {
+            const float dx = static_cast<float> (iter1->x) - static_cast<float> (iter2->x);
+            const float dy = static_cast<float> (iter1->y) - static_cast<float> (iter2->y);
+
+            const float distance = dx*dx + dy*dy;
+
+            if (distance < smallest_distance)
+            {
+              smallest_distance = distance;
+            }
+          }
+
+          const float score = smallest_distance * iter1->gradient.magnitude;
+
+          if (score > best_score)
+          {
+            best_score = score;
+            best_iter = iter1;
+          }
+        }
+
+
+        float min_min_sqr_distance = std::numeric_limits<float>::max ();
+        float max_min_sqr_distance = 0;
+        for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+        {
+          float min_sqr_distance = std::numeric_limits<float>::max ();
+          for (typename std::list<Candidate>::iterator iter3 = list2.begin (); iter3 != list2.end (); ++iter3)
+          {
+            if (iter2 == iter3)
+              continue;
+
+            const float dx = static_cast<float> (iter2->x) - static_cast<float> (iter3->x);
+            const float dy = static_cast<float> (iter2->y) - static_cast<float> (iter3->y);
+
+            const float sqr_distance = dx*dx + dy*dy;
+
+            if (sqr_distance < min_sqr_distance)
+            {
+              min_sqr_distance = sqr_distance;
+            }
+
+            //std::cerr << min_sqr_distance;
+          }
+          //std::cerr << std::endl;
+
+          // check current feature
+          {
+            const float dx = static_cast<float> (iter2->x) - static_cast<float> (best_iter->x);
+            const float dy = static_cast<float> (iter2->y) - static_cast<float> (best_iter->y);
+
+            const float sqr_distance = dx*dx + dy*dy;
+
+            if (sqr_distance < min_sqr_distance)
+            {
+              min_sqr_distance = sqr_distance;
+            }
+          }
+
+          if (min_sqr_distance < min_min_sqr_distance)
+            min_min_sqr_distance = min_sqr_distance;
+          if (min_sqr_distance > max_min_sqr_distance)
+            max_min_sqr_distance = min_sqr_distance;
+
+          //std::cerr << min_sqr_distance << ", " << min_min_sqr_distance << ", " << max_min_sqr_distance << std::endl;
+        }
+
+        if (best_iter != list1.end ())
+        {
+          //std::cerr << "feature_index: " << list2.size () << std::endl;
+          //std::cerr << "min_min_sqr_distance: " << min_min_sqr_distance << std::endl;
+          //std::cerr << "max_min_sqr_distance: " << max_min_sqr_distance << std::endl;
+
+          if (min_min_sqr_distance < 50)
+          {
+            feature_selection_finished = true;
+            break;
+          }
+
+          list2.push_back (*best_iter);
+        }
+      } 
+    }
+    else
+    {
+      if (list1.size () <= nr_features)
+      {
+        for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+        {
+          QuantizedMultiModFeature feature;
+          
+          feature.x = iter1->x;
+          feature.y = iter1->y;
+          feature.modality_index = modality_index;
+          feature.quantized_value = filtered_quantized_color_gradients_ (iter1->x, iter1->y);
+
+          features.push_back (feature);
+        }
+        return;
+      }
+
+      list2.push_back (*(list1.begin ()));
+      while (list2.size () != nr_features)
+      {
+        float best_score = 0.0f;
+        typename std::list<Candidate>::iterator best_iter = list1.end ();
+        for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+        {
+          // find smallest distance
+          float smallest_distance = std::numeric_limits<float>::max ();
+          for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+          {
+            const float dx = static_cast<float> (iter1->x) - static_cast<float> (iter2->x);
+            const float dy = static_cast<float> (iter1->y) - static_cast<float> (iter2->y);
+
+            const float distance = dx*dx + dy*dy;
+
+            if (distance < smallest_distance)
+            {
+              smallest_distance = distance;
+            }
+          }
+
+          const float score = smallest_distance * iter1->gradient.magnitude;
+
+          if (score > best_score)
+          {
+            best_score = score;
+            best_iter = iter1;
+          }
+        }
+
+        if (best_iter != list1.end ())
+        {
+          list2.push_back (*best_iter);
+        }
+        else
+        {
+          break;
+        }
+      }  
+    }
+  }
+  else if (feature_selection_method_ == MASK_BORDER_HIGH_GRADIENTS || feature_selection_method_ == MASK_BORDER_EQUALLY)
+  {
+    MaskMap eroded_mask;
+    erode (mask, eroded_mask);
+
+    MaskMap diff_mask;
+    MaskMap::getDifferenceMask (mask, eroded_mask, diff_mask);
+
+    for (size_t row_index = 0; row_index < height; ++row_index)
+    {
+      for (size_t col_index = 0; col_index < width; ++col_index)
+      {
+        if (diff_mask (col_index, row_index) != 0)
+        {
+          const GradientXY & gradient = color_gradients_ (col_index, row_index);
+          if ((feature_selection_method_ == MASK_BORDER_EQUALLY || gradient.magnitude > gradient_magnitude_threshold_feature_extraction_)
+            && filtered_quantized_color_gradients_ (col_index, row_index) != 0)
+          {
+            Candidate candidate;
+            candidate.gradient = gradient;
+            candidate.x = static_cast<int> (col_index);
+            candidate.y = static_cast<int> (row_index);
+
+            list1.push_back (candidate);
+          }
+        }
+      }
+    }
+
+    list1.sort();
+
+    if (list1.size () <= nr_features)
+    {
+      for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+      {
+        QuantizedMultiModFeature feature;
+          
+        feature.x = iter1->x;
+        feature.y = iter1->y;
+        feature.modality_index = modality_index;
+        feature.quantized_value = filtered_quantized_color_gradients_ (iter1->x, iter1->y);
+
+        features.push_back (feature);
+      }
+      return;
+    }
+
+    size_t distance = list1.size () / nr_features + 1; // ??? 
+    while (list2.size () != nr_features)
+    {
+      const size_t sqr_distance = distance*distance;
+      for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+      {
+        bool candidate_accepted = true;
+
+        for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+        {
+          const int dx = iter1->x - iter2->x;
+          const int dy = iter1->y - iter2->y;
+          const unsigned int tmp_distance = dx*dx + dy*dy;
+
+          //if (tmp_distance < distance) 
+          if (tmp_distance < sqr_distance)
+          {
+            candidate_accepted = false;
+            break;
+          }
+        }
+
+        if (candidate_accepted)
+          list2.push_back (*iter1);
+
+        if (list2.size () == nr_features)
+          break;
+      }
+      --distance;
+    }
+  }
+
+  for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+  {
+    QuantizedMultiModFeature feature;
+    
+    feature.x = iter2->x;
+    feature.y = iter2->y;
+    feature.modality_index = modality_index;
+    feature.quantized_value = filtered_quantized_color_gradients_ (iter2->x, iter2->y);
+
+    features.push_back (feature);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT> void 
+pcl::ColorGradientModality<PointInT>::
+extractAllFeatures (const MaskMap & mask, const size_t, const size_t modality_index,
+                 std::vector<QuantizedMultiModFeature> & features) const
+{
+  const size_t width = mask.getWidth ();
+  const size_t height = mask.getHeight ();
+  
+  std::list<Candidate> list1;
+  std::list<Candidate> list2;
+
+
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      if (mask (col_index, row_index) != 0)
+      {
+        const GradientXY & gradient = color_gradients_ (col_index, row_index);
+        if (gradient.magnitude > gradient_magnitude_threshold_feature_extraction_
+          && filtered_quantized_color_gradients_ (col_index, row_index) != 0)
+        {
+          Candidate candidate;
+          candidate.gradient = gradient;
+          candidate.x = static_cast<int> (col_index);
+          candidate.y = static_cast<int> (row_index);
+
+          list1.push_back (candidate);
+        }
+      }
+    }
+  }
+
+  list1.sort();
+
+  for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+  {
+    QuantizedMultiModFeature feature;
+          
+    feature.x = iter1->x;
+    feature.y = iter1->y;
+    feature.modality_index = modality_index;
+    feature.quantized_value = filtered_quantized_color_gradients_ (iter1->x, iter1->y);
+
+    features.push_back (feature);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+computeMaxColorGradients (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud)
+{
+  const int width = cloud->width;
+  const int height = cloud->height;
+
+  color_gradients_.points.resize (width*height);
+  color_gradients_.width = width;
+  color_gradients_.height = height;
+
+  const float pi = tan (1.0f) * 2;
+  for (int row_index = 0; row_index < height-2; ++row_index)
+  {
+    for (int col_index = 0; col_index < width-2; ++col_index)
+    {
+      const int index0 = row_index*width+col_index;
+      const int index_c = row_index*width+col_index+2;
+      const int index_r = (row_index+2)*width+col_index;
+
+      //const int index_d = (row_index+1)*width+col_index+1;
+
+      const unsigned char r0 = cloud->points[index0].r;
+      const unsigned char g0 = cloud->points[index0].g;
+      const unsigned char b0 = cloud->points[index0].b;
+
+      const unsigned char r_c = cloud->points[index_c].r;
+      const unsigned char g_c = cloud->points[index_c].g;
+      const unsigned char b_c = cloud->points[index_c].b;
+
+      const unsigned char r_r = cloud->points[index_r].r;
+      const unsigned char g_r = cloud->points[index_r].g;
+      const unsigned char b_r = cloud->points[index_r].b;
+
+      const float r_dx = static_cast<float> (r_c) - static_cast<float> (r0);
+      const float g_dx = static_cast<float> (g_c) - static_cast<float> (g0);
+      const float b_dx = static_cast<float> (b_c) - static_cast<float> (b0);
+
+      const float r_dy = static_cast<float> (r_r) - static_cast<float> (r0);
+      const float g_dy = static_cast<float> (g_r) - static_cast<float> (g0);
+      const float b_dy = static_cast<float> (b_r) - static_cast<float> (b0);
+
+      const float sqr_mag_r = r_dx*r_dx + r_dy*r_dy;
+      const float sqr_mag_g = g_dx*g_dx + g_dy*g_dy;
+      const float sqr_mag_b = b_dx*b_dx + b_dy*b_dy;
+
+      if (sqr_mag_r > sqr_mag_g && sqr_mag_r > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrt (sqr_mag_r);
+        gradient.angle = atan2 (r_dy, r_dx) * 180.0f / pi;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index+1, row_index+1) = gradient;
+      }
+      else if (sqr_mag_g > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrt (sqr_mag_g);
+        gradient.angle = atan2 (g_dy, g_dx) * 180.0f / pi;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index+1, row_index+1) = gradient;
+      }
+      else
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrt (sqr_mag_b);
+        gradient.angle = atan2 (b_dy, b_dx) * 180.0f / pi;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index+1, row_index+1) = gradient;
+      }
+
+      assert (color_gradients_ (col_index+1, row_index+1).angle >= -180 &&
+              color_gradients_ (col_index+1, row_index+1).angle <=  180);
+    }
+  }
+
+  return;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+computeMaxColorGradientsSobel (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud)
+{
+  const int width = cloud->width;
+  const int height = cloud->height;
+
+  color_gradients_.points.resize (width*height);
+  color_gradients_.width = width;
+  color_gradients_.height = height;
+
+  const float pi = tanf (1.0f) * 2.0f;
+  for (int row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (int col_index = 1; col_index < width-1; ++col_index)
+    {
+      const int r7 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index-1)].r);
+      const int g7 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index-1)].g);
+      const int b7 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index-1)].b);
+      const int r8 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index)].r);
+      const int g8 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index)].g);
+      const int b8 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index)].b);
+      const int r9 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index+1)].r);
+      const int g9 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index+1)].g);
+      const int b9 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index+1)].b);
+      const int r4 = static_cast<int> (cloud->points[(row_index)*width + (col_index-1)].r);
+      const int g4 = static_cast<int> (cloud->points[(row_index)*width + (col_index-1)].g);
+      const int b4 = static_cast<int> (cloud->points[(row_index)*width + (col_index-1)].b);
+      const int r6 = static_cast<int> (cloud->points[(row_index)*width + (col_index+1)].r);
+      const int g6 = static_cast<int> (cloud->points[(row_index)*width + (col_index+1)].g);
+      const int b6 = static_cast<int> (cloud->points[(row_index)*width + (col_index+1)].b);
+      const int r1 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index-1)].r);
+      const int g1 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index-1)].g);
+      const int b1 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index-1)].b);
+      const int r2 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index)].r);
+      const int g2 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index)].g);
+      const int b2 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index)].b);
+      const int r3 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index+1)].r);
+      const int g3 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index+1)].g);
+      const int b3 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index+1)].b);
+
+      //const int r_tmp1 = - r7 + r3;
+      //const int r_tmp2 = - r1 + r9;
+      //const int g_tmp1 = - g7 + g3;
+      //const int g_tmp2 = - g1 + g9;
+      //const int b_tmp1 = - b7 + b3;
+      //const int b_tmp2 = - b1 + b9;
+      ////const int gx = - r7 - (r4<<2) - r1 + r3 + (r6<<2) + r9;
+      ////const int gy = - r7 - (r8<<2) - r9 + r1 + (r2<<2) + r3;
+      //const int r_dx = r_tmp1 + r_tmp2 - (r4<<2) + (r6<<2);
+      //const int r_dy = r_tmp1 - r_tmp2 - (r8<<2) + (r2<<2);
+      //const int g_dx = g_tmp1 + g_tmp2 - (g4<<2) + (g6<<2);
+      //const int g_dy = g_tmp1 - g_tmp2 - (g8<<2) + (g2<<2);
+      //const int b_dx = b_tmp1 + b_tmp2 - (b4<<2) + (b6<<2);
+      //const int b_dy = b_tmp1 - b_tmp2 - (b8<<2) + (b2<<2);
+
+      //const int r_tmp1 = - r7 + r3;
+      //const int r_tmp2 = - r1 + r9;
+      //const int g_tmp1 = - g7 + g3;
+      //const int g_tmp2 = - g1 + g9;
+      //const int b_tmp1 = - b7 + b3;
+      //const int b_tmp2 = - b1 + b9;
+      //const int gx = - r7 - (r4<<2) - r1 + r3 + (r6<<2) + r9;
+      //const int gy = - r7 - (r8<<2) - r9 + r1 + (r2<<2) + r3;
+      const int r_dx = r9 + 2*r6 + r3 - (r7 + 2*r4 + r1);
+      const int r_dy = r1 + 2*r2 + r3 - (r7 + 2*r8 + r9);
+      const int g_dx = g9 + 2*g6 + g3 - (g7 + 2*g4 + g1);
+      const int g_dy = g1 + 2*g2 + g3 - (g7 + 2*g8 + g9);
+      const int b_dx = b9 + 2*b6 + b3 - (b7 + 2*b4 + b1);
+      const int b_dy = b1 + 2*b2 + b3 - (b7 + 2*b8 + b9);
+
+      const int sqr_mag_r = r_dx*r_dx + r_dy*r_dy;
+      const int sqr_mag_g = g_dx*g_dx + g_dy*g_dy;
+      const int sqr_mag_b = b_dx*b_dx + b_dy*b_dy;
+
+      if (sqr_mag_r > sqr_mag_g && sqr_mag_r > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrtf (static_cast<float> (sqr_mag_r));
+        gradient.angle = atan2f (static_cast<float> (r_dy), static_cast<float> (r_dx)) * 180.0f / pi;
+        if (gradient.angle < -180.0f) gradient.angle += 360.0f;
+        if (gradient.angle >= 180.0f) gradient.angle -= 360.0f;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index, row_index) = gradient;
+      }
+      else if (sqr_mag_g > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrtf (static_cast<float> (sqr_mag_g));
+        gradient.angle = atan2f (static_cast<float> (g_dy), static_cast<float> (g_dx)) * 180.0f / pi;
+        if (gradient.angle < -180.0f) gradient.angle += 360.0f;
+        if (gradient.angle >= 180.0f) gradient.angle -= 360.0f;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index, row_index) = gradient;
+      }
+      else
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrtf (static_cast<float> (sqr_mag_b));
+        gradient.angle = atan2f (static_cast<float> (b_dy), static_cast<float> (b_dx)) * 180.0f / pi;
+        if (gradient.angle < -180.0f) gradient.angle += 360.0f;
+        if (gradient.angle >= 180.0f) gradient.angle -= 360.0f;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index, row_index) = gradient;
+      }
+
+      assert (color_gradients_ (col_index, row_index).angle >= -180 &&
+              color_gradients_ (col_index, row_index).angle <=  180);
+    }
+  }
+
+  return;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+quantizeColorGradients ()
+{
+  //std::cerr << "quantize this, bastard!!!" << std::endl;
+
+  //unsigned char quantization_map[16] = {0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7};
+  //unsigned char quantization_map[16] = {1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8};
+
+  //for (float angle = 0.0f; angle < 360.0f; angle += 1.0f)
+  //{
+  //  const int quantized_value = quantization_map[static_cast<int> (angle * angleScale)];
+  //  std::cerr << angle << ": " << quantized_value << std::endl;
+  //}
+
+
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  quantized_color_gradients_.resize (width, height);
+
+  const float angleScale = 16.0f/360.0f;
+
+  //float min_angle = std::numeric_limits<float>::max ();
+  //float max_angle = -std::numeric_limits<float>::max ();
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      if (color_gradients_ (col_index, row_index).magnitude < gradient_magnitude_threshold_) 
+      {
+        quantized_color_gradients_ (col_index, row_index) = 0;
+        continue;
+      }
+
+      const float angle = 11.25f + color_gradients_ (col_index, row_index).angle + 180.0f;
+      const int quantized_value = (static_cast<int> (angle * angleScale)) & 7;
+      quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> (quantized_value + 1); 
+
+      //const float angle = color_gradients_ (col_index, row_index).angle + 180.0f;
+
+      //min_angle = std::min (min_angle, angle);
+      //max_angle = std::max (max_angle, angle);
+
+      //if (angle < 0.0f || angle >= 360.0f)
+      //{
+      //  std::cerr << "angle shitty: " << angle << std::endl;
+      //}
+
+      //const int quantized_value = quantization_map[static_cast<int> (angle * angleScale)];
+      //quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> (quantized_value); 
+
+      //assert (0 <= quantized_value && quantized_value < 16);
+      //quantized_color_gradients_ (col_index, row_index) = quantization_map[quantized_value];
+      //quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> ((quantized_value & 7) + 1); // = (quantized_value % 8) + 1
+    }
+  }
+
+  //std::cerr << ">>>>> " << min_angle << ", " << max_angle << std::endl;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+filterQuantizedColorGradients ()
+{
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  filtered_quantized_color_gradients_.resize (width, height);
+
+  // filter data
+  for (size_t row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (size_t col_index = 1; col_index < width-1; ++col_index)
+    {
+      unsigned char histogram[9] = {0,0,0,0,0,0,0,0,0};
+
+      {
+        const unsigned char * data_ptr = quantized_color_gradients_.getData () + (row_index-1)*width+col_index-1;
+        assert (data_ptr[0] < 9 && data_ptr[1] < 9 && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_color_gradients_.getData () + row_index*width+col_index-1;
+        assert (data_ptr[0] < 9 && data_ptr[1] < 9 && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_color_gradients_.getData () + (row_index+1)*width+col_index-1;
+        assert (data_ptr[0] < 9 && data_ptr[1] < 9 && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+
+      unsigned char max_hist_value = 0;
+      int max_hist_index = -1;
+
+      // for (int i = 0; i < 8; ++i)
+      // {
+      //   if (max_hist_value < histogram[i+1])
+      //   {
+      //     max_hist_index = i;
+      //     max_hist_value = histogram[i+1]
+      //   }
+      // }
+      // Unrolled for performance optimization:
+      if (max_hist_value < histogram[1]) {max_hist_index = 0; max_hist_value = histogram[1];}
+      if (max_hist_value < histogram[2]) {max_hist_index = 1; max_hist_value = histogram[2];}
+      if (max_hist_value < histogram[3]) {max_hist_index = 2; max_hist_value = histogram[3];}
+      if (max_hist_value < histogram[4]) {max_hist_index = 3; max_hist_value = histogram[4];}
+      if (max_hist_value < histogram[5]) {max_hist_index = 4; max_hist_value = histogram[5];}
+      if (max_hist_value < histogram[6]) {max_hist_index = 5; max_hist_value = histogram[6];}
+      if (max_hist_value < histogram[7]) {max_hist_index = 6; max_hist_value = histogram[7];}
+      if (max_hist_value < histogram[8]) {max_hist_index = 7; max_hist_value = histogram[8];}
+
+      if (max_hist_index != -1 && max_hist_value >= 5)
+        filtered_quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> (0x1 << max_hist_index);
+      else
+        filtered_quantized_color_gradients_ (col_index, row_index) = 0;
+
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+erode (const pcl::MaskMap & mask_in, 
+       pcl::MaskMap & mask_out)
+{
+  const size_t width = mask_in.getWidth ();
+  const size_t height = mask_in.getHeight ();
+
+  mask_out.resize (width, height);
+
+  for (size_t row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (size_t col_index = 1; col_index < width-1; ++col_index)
+    {
+      if (mask_in (col_index, row_index-1) == 0 ||
+          mask_in (col_index-1, row_index) == 0 ||
+          mask_in (col_index+1, row_index) == 0 ||
+          mask_in (col_index, row_index+1) == 0)
+      {
+        mask_out (col_index, row_index) = 0;
+      }
+      else
+      {
+        mask_out (col_index, row_index) = 255;
+      }
+    }
+  }
+}
+
+#endif 
+
+###
+
+# color_modality.h
+namespace pcl
+{
+
+  // --------------------------------------------------------------------------
+
+  template <typename PointInT>
+  class ColorModality
+    : public QuantizableModality, public PCLBase<PointInT>
+  {
+    protected:
+      using PCLBase<PointInT>::input_;
+
+      struct Candidate
+      {
+        float distance;
+
+        unsigned char bin_index;
+    
+        size_t x;
+        size_t y;   
+
+        bool 
+        operator< (const Candidate & rhs)
+        {
+          return (distance > rhs.distance);
+        }
+      };
+
+    public:
+      typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+
+      ColorModality ();
+  
+      virtual ~ColorModality ();
+  
+      inline QuantizedMap &
+      getQuantizedMap () 
+      { 
+        return (filtered_quantized_colors_);
+      }
+  
+      inline QuantizedMap &
+      getSpreadedQuantizedMap () 
+      { 
+        return (spreaded_filtered_quantized_colors_);
+      }
+  
+      void
+      extractFeatures (const MaskMap & mask, size_t nr_features, size_t modalityIndex,
+                       std::vector<QuantizedMultiModFeature> & features) const;
+  
+      /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        * \param cloud the const boost shared pointer to a PointCloud message
+        */
+      virtual void 
+      setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+      { 
+        input_ = cloud;
+      }
+
+      virtual void
+      processInputData ();
+
+    protected:
+
+      void
+      quantizeColors ();
+  
+      void
+      filterQuantizedColors ();
+
+      static inline int
+      quantizeColorOnRGBExtrema (const float r,
+                                 const float g,
+                                 const float b);
+  
+      void
+      computeDistanceMap (const MaskMap & input, DistanceMap & output) const;
+
+    private:
+      float feature_distance_threshold_;
+      
+      pcl::QuantizedMap quantized_colors_;
+      pcl::QuantizedMap filtered_quantized_colors_;
+      pcl::QuantizedMap spreaded_filtered_quantized_colors_;
+  
+  };
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorModality<PointInT>::ColorModality ()
+  : feature_distance_threshold_ (1.0f), quantized_colors_ (), filtered_quantized_colors_ (), spreaded_filtered_quantized_colors_ ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorModality<PointInT>::~ColorModality ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorModality<PointInT>::processInputData ()
+{
+  // quantize gradients
+  quantizeColors ();
+
+  // filter quantized gradients to get only dominants one + thresholding
+  filterQuantizedColors ();
+
+  // spread filtered quantized gradients
+  //spreadFilteredQunatizedColorGradients ();
+  const int spreading_size = 8;
+  pcl::QuantizedMap::spreadQuantizedMap (filtered_quantized_colors_,
+                                         spreaded_filtered_quantized_colors_, spreading_size);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void pcl::ColorModality<PointInT>::extractFeatures (const MaskMap & mask, 
+                                                    const size_t nr_features, 
+                                                    const size_t modality_index,
+                                                    std::vector<QuantizedMultiModFeature> & features) const
+{
+  const size_t width = mask.getWidth ();
+  const size_t height = mask.getHeight ();
+
+  MaskMap mask_maps[8];
+  for (size_t map_index = 0; map_index < 8; ++map_index)
+    mask_maps[map_index].resize (width, height);
+
+  unsigned char map[255];
+  memset(map, 0, 255);
+
+  map[0x1<<0] = 0;
+  map[0x1<<1] = 1;
+  map[0x1<<2] = 2;
+  map[0x1<<3] = 3;
+  map[0x1<<4] = 4;
+  map[0x1<<5] = 5;
+  map[0x1<<6] = 6;
+  map[0x1<<7] = 7;
+
+  QuantizedMap distance_map_indices (width, height);
+  //memset (distance_map_indices.data, 0, sizeof (distance_map_indices.data[0])*width*height);
+
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      if (mask (col_index, row_index) != 0)
+      {
+        //const unsigned char quantized_value = quantized_surface_normals_ (row_index, col_index);
+        const unsigned char quantized_value = filtered_quantized_colors_ (col_index, row_index);
+
+        if (quantized_value == 0) 
+          continue;
+        const int dist_map_index = map[quantized_value];
+
+        distance_map_indices (col_index, row_index) = dist_map_index;
+        //distance_maps[dist_map_index].at<unsigned char>(row_index, col_index) = 255;
+        mask_maps[dist_map_index] (col_index, row_index) = 255;
+      }
+    }
+  }
+
+  DistanceMap distance_maps[8];
+  for (int map_index = 0; map_index < 8; ++map_index)
+    computeDistanceMap (mask_maps[map_index], distance_maps[map_index]);
+
+  std::list<Candidate> list1;
+  std::list<Candidate> list2;
+
+  float weights[8] = {0,0,0,0,0,0,0,0};
+
+  const size_t off = 4;
+  for (size_t row_index = off; row_index < height-off; ++row_index)
+  {
+    for (size_t col_index = off; col_index < width-off; ++col_index)
+    {
+      if (mask (col_index, row_index) != 0)
+      {
+        //const unsigned char quantized_value = quantized_surface_normals_ (row_index, col_index);
+        const unsigned char quantized_value = filtered_quantized_colors_ (col_index, row_index);
+
+        //const float nx = surface_normals_ (col_index, row_index).normal_x;
+        //const float ny = surface_normals_ (col_index, row_index).normal_y;
+        //const float nz = surface_normals_ (col_index, row_index).normal_z;
+
+        if (quantized_value != 0)
+        {
+          const int distance_map_index = map[quantized_value];
+
+          //const float distance = distance_maps[distance_map_index].at<float> (row_index, col_index);
+          const float distance = distance_maps[distance_map_index] (col_index, row_index);
+
+          if (distance >= feature_distance_threshold_)
+          {
+            Candidate candidate;
+
+            candidate.distance = distance;
+            candidate.x = col_index;
+            candidate.y = row_index;
+            candidate.bin_index = distance_map_index;
+
+            list1.push_back (candidate);
+
+            ++weights[distance_map_index];
+          }
+        }
+      }
+    }
+  }
+
+  for (typename std::list<Candidate>::iterator iter = list1.begin (); iter != list1.end (); ++iter)
+    iter->distance *= 1.0f / weights[iter->bin_index];
+
+  list1.sort ();
+
+  if (list1.size () <= nr_features)
+  {
+    features.reserve (list1.size ());
+    for (typename std::list<Candidate>::iterator iter = list1.begin (); iter != list1.end (); ++iter)
+    {
+      QuantizedMultiModFeature feature;
+
+      feature.x = static_cast<int> (iter->x);
+      feature.y = static_cast<int> (iter->y);
+      feature.modality_index = modality_index;
+      feature.quantized_value = filtered_quantized_colors_ (iter->x, iter->y);
+
+      features.push_back (feature);
+    }
+
+    return;
+  }
+
+  int distance = static_cast<int> (list1.size () / nr_features + 1); // ???  @todo:!:!:!:!:!:!
+  while (list2.size () != nr_features)
+  {
+    const int sqr_distance = distance*distance;
+    for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+    {
+      bool candidate_accepted = true;
+
+      for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+      {
+        const int dx = static_cast<int> (iter1->x) - static_cast<int> (iter2->x);
+        const int dy = static_cast<int> (iter1->y) - static_cast<int> (iter2->y);
+        const int tmp_distance = dx*dx + dy*dy;
+
+        if (tmp_distance < sqr_distance)
+        {
+          candidate_accepted = false;
+          break;
+        }
+      }
+
+      if (candidate_accepted)
+        list2.push_back (*iter1);
+
+      if (list2.size () == nr_features) break;
+    }
+    --distance;
+  }
+
+  for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+  {
+    QuantizedMultiModFeature feature;
+
+    feature.x = static_cast<int> (iter2->x);
+    feature.y = static_cast<int> (iter2->y);
+    feature.modality_index = modality_index;
+    feature.quantized_value = filtered_quantized_colors_ (iter2->x, iter2->y);
+
+    features.push_back (feature);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorModality<PointInT>::quantizeColors ()
+{
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  quantized_colors_.resize (width, height);
+
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      const float r = static_cast<float> ((*input_) (col_index, row_index).r);
+      const float g = static_cast<float> ((*input_) (col_index, row_index).g);
+      const float b = static_cast<float> ((*input_) (col_index, row_index).b);
+
+      quantized_colors_ (col_index, row_index) = quantizeColorOnRGBExtrema (r, g, b);
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorModality<PointInT>::filterQuantizedColors ()
+{
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  filtered_quantized_colors_.resize (width, height);
+
+  // filter data
+  for (size_t row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (size_t col_index = 1; col_index < width-1; ++col_index)
+    {
+      unsigned char histogram[8] = {0,0,0,0,0,0,0,0};
+
+      {
+        const unsigned char * data_ptr = quantized_colors_.getData () + (row_index-1)*width+col_index-1;
+        assert (0 <= data_ptr[0] && data_ptr[0] < 9 && 
+                0 <= data_ptr[1] && data_ptr[1] < 9 && 
+                0 <= data_ptr[2] && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_colors_.getData () + row_index*width+col_index-1;
+        assert (0 <= data_ptr[0] && data_ptr[0] < 9 && 
+                0 <= data_ptr[1] && data_ptr[1] < 9 && 
+                0 <= data_ptr[2] && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_colors_.getData () + (row_index+1)*width+col_index-1;
+        assert (0 <= data_ptr[0] && data_ptr[0] < 9 && 
+                0 <= data_ptr[1] && data_ptr[1] < 9 && 
+                0 <= data_ptr[2] && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+
+      unsigned char max_hist_value = 0;
+      int max_hist_index = -1;
+
+      // for (int i = 0; i < 8; ++i)
+      // {
+      //   if (max_hist_value < histogram[i+1])
+      //   {
+      //     max_hist_index = i;
+      //     max_hist_value = histogram[i+1]
+      //   }
+      // }
+      // Unrolled for performance optimization:
+      if (max_hist_value < histogram[0]) {max_hist_index = 0; max_hist_value = histogram[0];}
+      if (max_hist_value < histogram[1]) {max_hist_index = 1; max_hist_value = histogram[1];}
+      if (max_hist_value < histogram[2]) {max_hist_index = 2; max_hist_value = histogram[2];}
+      if (max_hist_value < histogram[3]) {max_hist_index = 3; max_hist_value = histogram[3];}
+      if (max_hist_value < histogram[4]) {max_hist_index = 4; max_hist_value = histogram[4];}
+      if (max_hist_value < histogram[5]) {max_hist_index = 5; max_hist_value = histogram[5];}
+      if (max_hist_value < histogram[6]) {max_hist_index = 6; max_hist_value = histogram[6];}
+      if (max_hist_value < histogram[7]) {max_hist_index = 7; max_hist_value = histogram[7];}
+
+      //if (max_hist_index != -1 && max_hist_value >= 5)
+        filtered_quantized_colors_ (col_index, row_index) = 0x1 << max_hist_index;
+      //else
+      //  filtered_quantized_color_gradients_ (col_index, row_index) = 0;
+
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+int
+pcl::ColorModality<PointInT>::quantizeColorOnRGBExtrema (const float r,
+                                                         const float g,
+                                                         const float b)
+{
+  const float r_inv = 255.0f-r;
+  const float g_inv = 255.0f-g;
+  const float b_inv = 255.0f-b;
+
+  const float dist_0 = (r*r + g*g + b*b)*2.0f;
+  const float dist_1 = r*r + g*g + b_inv*b_inv;
+  const float dist_2 = r*r + g_inv*g_inv+ b*b;
+  const float dist_3 = r*r + g_inv*g_inv + b_inv*b_inv;
+  const float dist_4 = r_inv*r_inv + g*g + b*b;
+  const float dist_5 = r_inv*r_inv + g*g + b_inv*b_inv;
+  const float dist_6 = r_inv*r_inv + g_inv*g_inv+ b*b;
+  const float dist_7 = (r_inv*r_inv + g_inv*g_inv + b_inv*b_inv)*1.5f;
+
+  const float min_dist = std::min (std::min (std::min (dist_0, dist_1), std::min (dist_2, dist_3)), std::min (std::min (dist_4, dist_5), std::min (dist_6, dist_7)));
+
+  if (min_dist == dist_0)
+  {
+    return 0;
+  }
+  if (min_dist == dist_1)
+  {
+    return 1;
+  }
+  if (min_dist == dist_2)
+  {
+    return 2;
+  }
+  if (min_dist == dist_3)
+  {
+    return 3;
+  }
+  if (min_dist == dist_4)
+  {
+    return 4;
+  }
+  if (min_dist == dist_5)
+  {
+    return 5;
+  }
+  if (min_dist == dist_6)
+  {
+    return 6;
+  }
+  return 7;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT> void
+pcl::ColorModality<PointInT>::computeDistanceMap (const MaskMap & input, 
+                                                  DistanceMap & output) const
+{
+  const size_t width = input.getWidth ();
+  const size_t height = input.getHeight ();
+
+  output.resize (width, height);
+
+  // compute distance map
+  //float *distance_map = new float[input_->points.size ()];
+  const unsigned char * mask_map = input.getData ();
+  float * distance_map = output.getData ();
+  for (size_t index = 0; index < width*height; ++index)
+  {
+    if (mask_map[index] == 0)
+      distance_map[index] = 0.0f;
+    else
+      distance_map[index] = static_cast<float> (width + height);
+  }
+
+  // first pass
+  float * previous_row = distance_map;
+  float * current_row = previous_row + width;
+  for (size_t ri = 1; ri < height; ++ri)
+  {
+    for (size_t ci = 1; ci < width; ++ci)
+    {
+      const float up_left  = previous_row [ci - 1] + 1.4f; //distance_map[(ri-1)*input_->width + ci-1] + 1.4f;
+      const float up       = previous_row [ci]     + 1.0f; //distance_map[(ri-1)*input_->width + ci] + 1.0f;
+      const float up_right = previous_row [ci + 1] + 1.4f; //distance_map[(ri-1)*input_->width + ci+1] + 1.4f;
+      const float left     = current_row  [ci - 1] + 1.0f; //distance_map[ri*input_->width + ci-1] + 1.0f;
+      const float center   = current_row  [ci];            //distance_map[ri*input_->width + ci];
+
+      const float min_value = std::min (std::min (up_left, up), std::min (left, up_right));
+
+      if (min_value < center)
+        current_row[ci] = min_value; //distance_map[ri * input_->width + ci] = min_value;
+    }
+    previous_row = current_row;
+    current_row += width;
+  }
+
+  // second pass
+  float * next_row = distance_map + width * (height - 1);
+  current_row = next_row - width;
+  for (int ri = static_cast<int> (height)-2; ri >= 0; --ri)
+  {
+    for (int ci = static_cast<int> (width)-2; ci >= 0; --ci)
+    {
+      const float lower_left  = next_row    [ci - 1] + 1.4f; //distance_map[(ri+1)*input_->width + ci-1] + 1.4f;
+      const float lower       = next_row    [ci]     + 1.0f; //distance_map[(ri+1)*input_->width + ci] + 1.0f;
+      const float lower_right = next_row    [ci + 1] + 1.4f; //distance_map[(ri+1)*input_->width + ci+1] + 1.4f;
+      const float right       = current_row [ci + 1] + 1.0f; //distance_map[ri*input_->width + ci+1] + 1.0f;
+      const float center      = current_row [ci];            //distance_map[ri*input_->width + ci];
+
+      const float min_value = std::min (std::min (lower_left, lower), std::min (right, lower_right));
+
+      if (min_value < center)
+        current_row[ci] = min_value; //distance_map[ri*input_->width + ci] = min_value;
+    }
+    next_row = current_row;
+    current_row -= width;
+  }
+}
+
+
+#endif 
+
+###
+
+# crh_alignment.h
+namespace pcl
+{
+
+  /** \brief CRHAlignment uses two Camera Roll Histograms (CRH) to find the
+   * roll rotation that aligns both views. See:
+   *   - CAD-Model Recognition and 6 DOF Pose Estimation
+   *     A. Aldoma, N. Blodow, D. Gossow, S. Gedikli, R.B. Rusu, M. Vincze and G. Bradski
+   *     ICCV 2011, 3D Representation and Recognition (3dRR11) workshop
+   *     Barcelona, Spain, (2011)
+   *
+   * \author Aitor Aldoma
+   * \ingroup recognition
+   */
+
+  template<typename PointT, int nbins_>
+    class PCL_EXPORTS CRHAlignment
+    {
+    private:
+
+      /** \brief Sorts peaks */
+      typedef struct
+      {
+        bool
+        operator() (std::pair<float, int> const& a, std::pair<float, int> const& b)
+        {
+          return a.first > b.first;
+        }
+      } peaks_ordering;
+
+      typedef typename pcl::PointCloud<PointT>::Ptr PointTPtr;
+
+      /** \brief View of the model to be aligned to input_view_ */
+      PointTPtr target_view_;
+      /** \brief View of the input */
+      PointTPtr input_view_;
+      /** \brief Centroid of the model_view_ */
+      Eigen::Vector3f centroid_target_;
+      /** \brief Centroid of the input_view_ */
+      Eigen::Vector3f centroid_input_;
+      /** \brief transforms from model view to input view */
+      std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > transforms_;
+      /** \brief Allowed maximum number of peaks  */
+      int max_peaks_;
+      /** \brief Quantile of peaks after sorting to be checked  */
+      float quantile_;
+      /** \brief Threshold for a peak to be accepted.
+       * If peak_i >= (max_peak * accept_threhsold_) => peak is accepted
+       */
+      float accept_threshold_;
+
+      /** \brief computes the transformation to the z-axis
+        * \param[in] centroid
+        * \param[out] trasnformation to z-axis
+        */
+      void
+      computeTransformToZAxes (Eigen::Vector3f & centroid, Eigen::Affine3f & transform)
+      {
+        Eigen::Vector3f plane_normal;
+        plane_normal[0] = -centroid[0];
+        plane_normal[1] = -centroid[1];
+        plane_normal[2] = -centroid[2];
+        Eigen::Vector3f z_vector = Eigen::Vector3f::UnitZ ();
+        plane_normal.normalize ();
+        Eigen::Vector3f axis = plane_normal.cross (z_vector);
+        double rotation = -asin (axis.norm ());
+        axis.normalize ();
+        transform = Eigen::Affine3f (Eigen::AngleAxisf (static_cast<float>(rotation), axis));
+      }
+
+      /** \brief computes the roll transformation
+        * \param[in] centroid input
+        * \param[in] centroid view
+        * \param[in] roll_angle
+        * \param[out] roll transformation
+        */
+      void
+      computeRollTransform (Eigen::Vector3f & centroidInput, Eigen::Vector3f & centroidResult, double roll_angle, Eigen::Affine3f & final_trans)
+      {
+        Eigen::Affine3f transformInputToZ;
+        computeTransformToZAxes (centroidInput, transformInputToZ);
+
+        transformInputToZ = transformInputToZ.inverse ();
+        Eigen::Affine3f transformRoll (Eigen::AngleAxisf (-static_cast<float>(roll_angle * M_PI / 180), Eigen::Vector3f::UnitZ ()));
+        Eigen::Affine3f transformDBResultToZ;
+        computeTransformToZAxes (centroidResult, transformDBResultToZ);
+
+        final_trans = transformInputToZ * transformRoll * transformDBResultToZ;
+      }
+    public:
+
+      /** \brief Constructor. */
+      CRHAlignment() {
+        max_peaks_ = 5;
+        quantile_ = 0.2f;
+        accept_threshold_ = 0.8f;
+      }
+
+      /** \brief returns the computed transformations
+       * \param[out] transforms transformations
+       */
+      void getTransforms(std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > & transforms) {
+        transforms = transforms_;
+      }
+
+      /** \brief sets model and input views
+       * \param[in] input_view
+       * \param[in] target_view
+       */
+      void
+      setInputAndTargetView (PointTPtr & input_view, PointTPtr & target_view)
+      {
+        target_view_ = target_view;
+        input_view_ = input_view;
+      }
+
+      /** \brief sets model and input centroids
+        * \param[in] c1 model view centroid
+        * \param[in] c2 input view centroid
+        */
+      void
+      setInputAndTargetCentroids (Eigen::Vector3f & c1, Eigen::Vector3f & c2)
+      {
+        centroid_target_ = c2;
+        centroid_input_ = c1;
+      }
+
+      /** \brief Computes the transformation aligning model to input
+       * \param[in] input_ftt CRH histogram of the input cloud
+       * \param[in] target_ftt CRH histogram of the target cloud
+       */
+      void
+      align (pcl::PointCloud<pcl::Histogram<nbins_> > & input_ftt, pcl::PointCloud<pcl::Histogram<nbins_> > & target_ftt)
+      {
+
+        transforms_.clear(); //clear from last round...
+
+        std::vector<float> peaks;
+        computeRollAngle (input_ftt, target_ftt, peaks);
+
+        //if the number of peaks is too big, we should try to reduce using siluette matching
+
+        for (size_t i = 0; i < peaks.size(); i++)
+        {
+          Eigen::Affine3f rollToRot;
+          computeRollTransform (centroid_input_, centroid_target_, peaks[i], rollToRot);
+
+          Eigen::Matrix4f rollHomMatrix = Eigen::Matrix4f ();
+          rollHomMatrix.setIdentity (4, 4);
+          rollHomMatrix = rollToRot.matrix ();
+
+          Eigen::Matrix4f translation2;
+          translation2.setIdentity (4, 4);
+          Eigen::Vector3f centr = rollToRot * centroid_target_;
+          translation2 (0, 3) = centroid_input_[0] - centr[0];
+          translation2 (1, 3) = centroid_input_[1] - centr[1];
+          translation2 (2, 3) = centroid_input_[2] - centr[2];
+
+          Eigen::Matrix4f resultHom (translation2 * rollHomMatrix);
+          transforms_.push_back(resultHom.inverse());
+        }
+
+      }
+
+      /** \brief Computes the roll angle that aligns input to modle.
+       * \param[in] input_ftt CRH histogram of the input cloud
+       * \param[in] target_ftt CRH histogram of the target cloud
+       * \param[out] peaks Vector containing angles where the histograms correlate
+       */
+      void
+      computeRollAngle (pcl::PointCloud<pcl::Histogram<nbins_> > & input_ftt, pcl::PointCloud<pcl::Histogram<nbins_> > & target_ftt,
+                        std::vector<float> & peaks)
+      {
+
+        pcl::PointCloud<pcl::Histogram<nbins_> > input_ftt_negate (input_ftt);
+
+        for (int i = 2; i < (nbins_); i += 2)
+          input_ftt_negate.points[0].histogram[i] = -input_ftt_negate.points[0].histogram[i];
+
+        int nr_bins_after_padding = 180;
+        int peak_distance = 5;
+        int cutoff = nbins_ - 1;
+
+        kiss_fft_cpx * multAB = new kiss_fft_cpx[nr_bins_after_padding];
+        for (int i = 0; i < nr_bins_after_padding; i++)
+          multAB[i].r = multAB[i].i = 0.f;
+
+        int k = 0;
+        multAB[k].r = input_ftt_negate.points[0].histogram[0] * target_ftt.points[0].histogram[0];
+        k++;
+
+        float a, b, c, d;
+        for (int i = 1; i < cutoff; i += 2, k++)
+        {
+          a = input_ftt_negate.points[0].histogram[i];
+          b = input_ftt_negate.points[0].histogram[i + 1];
+          c = target_ftt.points[0].histogram[i];
+          d = target_ftt.points[0].histogram[i + 1];
+          multAB[k].r = a * c - b * d;
+          multAB[k].i = b * c + a * d;
+
+          float tmp = sqrtf (multAB[k].r * multAB[k].r + multAB[k].i * multAB[k].i);
+
+          multAB[k].r /= tmp;
+          multAB[k].i /= tmp;
+        }
+
+        multAB[nbins_ - 1].r = input_ftt_negate.points[0].histogram[nbins_ - 1] * target_ftt.points[0].histogram[nbins_ - 1];
+
+        kiss_fft_cfg mycfg = kiss_fft_alloc (nr_bins_after_padding, 1, NULL, NULL);
+        kiss_fft_cpx * invAB = new kiss_fft_cpx[nr_bins_after_padding];
+        kiss_fft (mycfg, multAB, invAB);
+
+        std::vector < std::pair<float, int> > scored_peaks (nr_bins_after_padding);
+        for (int i = 0; i < nr_bins_after_padding; i++)
+          scored_peaks[i] = std::make_pair (invAB[i].r, i);
+
+        std::sort (scored_peaks.begin (), scored_peaks.end (), peaks_ordering ());
+
+        std::vector<int> peaks_indices;
+        std::vector<float> peaks_values;
+
+        // we look at the upper quantile_
+        float quantile = quantile_;
+        int max_inserted= max_peaks_;
+
+        int inserted=0;
+        bool stop=false;
+        for (int i = 0; (i < static_cast<int> (quantile * static_cast<float> (nr_bins_after_padding))) && !stop; i++)
+        {
+          if (scored_peaks[i].first >= scored_peaks[0].first * accept_threshold_)
+          {
+            bool insert = true;
+
+            for (size_t j = 0; j < peaks_indices.size (); j++)
+            { //check inserted peaks, first pick always inserted
+              if (std::abs (peaks_indices[j] - scored_peaks[i].second) <= peak_distance || std::abs (
+                                                                                             peaks_indices[j] - (scored_peaks[i].second
+                                                                                                 - nr_bins_after_padding)) <= peak_distance)
+              {
+                insert = false;
+                break;
+              }
+            }
+
+            if (insert)
+            {
+              peaks_indices.push_back (scored_peaks[i].second);
+              peaks_values.push_back (scored_peaks[i].first);
+              peaks.push_back (static_cast<float> (scored_peaks[i].second * (360 / nr_bins_after_padding)));
+              inserted++;
+              if(inserted >= max_inserted)
+                stop = true;
+            }
+          }
+        }
+      }
+    };
+}
+
+#endif /* CRH_ALIGNMENT_H_ */
+###
+
+# dense_quantized_multi_mod_template.h
+namespace pcl
+{
+
+  struct DenseQuantizedSingleModTemplate
+  {
+    std::vector<unsigned char> features;
+
+    void 
+    serialize (std::ostream & stream) const
+    {
+      const size_t num_of_features = static_cast<size_t> (features.size ());
+      write (stream, num_of_features);
+      for (size_t feature_index = 0; feature_index < num_of_features; ++feature_index)
+      {
+        write (stream, features[feature_index]);
+      }
+    }
+
+    void 
+    deserialize (std::istream & stream)
+    {
+      features.clear ();
+
+      size_t num_of_features;
+      read (stream, num_of_features);
+      features.resize (num_of_features);
+      for (size_t feature_index = 0; feature_index < num_of_features; ++feature_index)
+      {
+        read (stream, features[feature_index]);
+      }
+    }
+  };
+
+  struct DenseQuantizedMultiModTemplate
+  {
+    std::vector<DenseQuantizedSingleModTemplate> modalities;
+    float response_factor;
+
+    RegionXY region;
+
+    void 
+    serialize (std::ostream & stream) const
+    {
+      const size_t num_of_modalities = static_cast<size_t> (modalities.size ());
+      write (stream, num_of_modalities);
+      for (size_t modality_index = 0; modality_index < num_of_modalities; ++modality_index)
+      {
+        modalities[modality_index].serialize (stream);
+      }
+
+      region.serialize (stream);
+    }
+
+    void 
+    deserialize (std::istream & stream)
+    {
+      modalities.clear ();
+
+      size_t num_of_modalities;
+      read (stream, num_of_modalities);
+      modalities.resize (num_of_modalities);
+      for (size_t modality_index = 0; modality_index < num_of_modalities; ++modality_index)
+      {
+        modalities[modality_index].deserialize (stream);
+      }
+
+      region.deserialize (stream);
+    }
+  };
+
+}
+
+#endif 
+###
+
+# distance_map.h
+namespace pcl
+{
+
+  /** \brief Represents a distance map obtained from a distance transformation. 
+    * \author Stefan Holzer
+    */
+  class DistanceMap
+  {
+    public:
+      /** \brief Constructor. */
+      DistanceMap () : data_ (0), width_ (0), height_ (0) {}
+      /** \brief Destructor. */
+      virtual ~DistanceMap () {}
+
+      /** \brief Returns the width of the map. */
+      inline size_t 
+      getWidth () const
+      {
+        return (width_); 
+      }
+
+      /** \brief Returns the height of the map. */
+      inline size_t 
+      getHeight () const
+      { 
+        return (height_); 
+      }
+    
+      /** \brief Returns a pointer to the beginning of map. */
+      inline float * 
+      getData () 
+      { 
+        return (&data_[0]); 
+      }
+
+      /** \brief Resizes the map to the specified size.
+        * \param[in] width the new width of the map.
+        * \param[in] height the new height of the map.
+        */
+      void 
+      resize (const size_t width, const size_t height)
+      {
+        data_.resize (width*height);
+        width_ = width;
+        height_ = height;
+      }
+
+      /** \brief Operator to access an element of the map.
+        * \param[in] col_index the column index of the element to access.
+        * \param[in] row_index the row index of the element to access.
+        */
+      inline float & 
+      operator() (const size_t col_index, const size_t row_index)
+      {
+        return (data_[row_index*width_ + col_index]);
+      }
+
+      /** \brief Operator to access an element of the map.
+        * \param[in] col_index the column index of the element to access.
+        * \param[in] row_index the row index of the element to access.
+        */
+      inline const float & 
+      operator() (const size_t col_index, const size_t row_index) const
+      {
+        return (data_[row_index*width_ + col_index]);
+      }
+
+    protected:
+      /** \brief The storage for the distance map data. */
+      std::vector<float> data_;
+      /** \brief The width of the map. */
+      size_t width_;
+      /** \brief The height of the map. */
+      size_t height_;
+  };
+
+}
+
+
+#endif 
+
+###
+
+# dotmod.h
+namespace pcl
+{
+  class PCL_EXPORTS DOTModality
+  {
+    public:
+
+      virtual ~DOTModality () {};
+
+      //virtual QuantizedMap &
+      //getDominantQuantizedMap () = 0;
+
+      virtual QuantizedMap &
+      getDominantQuantizedMap () = 0;
+
+      virtual QuantizedMap
+      computeInvariantQuantizedMap (const MaskMap & mask,
+                                    const RegionXY & region) = 0;
+
+  };
+}
+
+#endif    // PCL_FEATURES_DOT_MODALITY
+
+###
+
+# dot_modality.h
+namespace pcl
+{
+
+  struct DOTMODDetection
+  {
+    size_t bin_x;
+    size_t bin_y;
+    size_t template_id;
+    float score;
+  };
+
+  /**
+    * \brief Template matching using the DOTMOD approach.
+    * \author Stefan Holzer, Stefan Hinterstoisser
+    */
+  class PCL_EXPORTS DOTMOD
+  {
+    public:
+      /** \brief Constructor */
+      DOTMOD (size_t template_width,
+              size_t template_height);
+
+      /** \brief Destructor */
+      virtual ~DOTMOD ();
+
+      /** \brief Creates a template from the specified data and adds it to the matching queue. 
+        * \param modalities
+        * \param masks
+        * \param template_anker_x
+        * \param template_anker_y
+        * \param region
+        */
+      size_t 
+      createAndAddTemplate (const std::vector<DOTModality*> & modalities,
+                            const std::vector<MaskMap*> & masks,
+                            size_t template_anker_x,
+                            size_t template_anker_y,
+                            const RegionXY & region);
+
+      void
+      detectTemplates (const std::vector<DOTModality*> & modalities,
+                       float template_response_threshold,
+                       std::vector<DOTMODDetection> & detections,
+                       const size_t bin_size) const;
+
+      inline const DenseQuantizedMultiModTemplate &
+      getTemplate (size_t template_id) const
+      { 
+        return (templates_[template_id]);
+      }
+
+      inline size_t
+      getNumOfTemplates ()
+      {
+        return (templates_.size ());
+      }
+
+      void
+      saveTemplates (const char * file_name) const;
+
+      void
+      loadTemplates (const char * file_name);
+
+      void 
+      serialize (std::ostream & stream) const;
+
+      void 
+      deserialize (std::istream & stream);
+
+
+    private:
+      /** template width */
+      size_t template_width_;
+      /** template height */
+      size_t template_height_;
+      /** template storage */
+      std::vector<DenseQuantizedMultiModTemplate> templates_;
+  };
+
+}
+
+#endif 
+
+###
+
+# hypothesis.h
+# ransac_based
+namespace pcl
+{
+  namespace recognition
+  {
+    class HypothesisBase
+    {
+      public:
+        HypothesisBase (const ModelLibrary::Model* obj_model)
+        : obj_model_ (obj_model)
+        {}
+
+        HypothesisBase (const ModelLibrary::Model* obj_model, const float* rigid_transform)
+        : obj_model_ (obj_model)
+        {
+          memcpy (rigid_transform_, rigid_transform, 12*sizeof (float));
+        }
+
+        virtual  ~HypothesisBase (){}
+
+        void
+        setModel (const ModelLibrary::Model* model)
+        {
+          obj_model_ = model;
+        }
+
+      public:
+        float rigid_transform_[12];
+        const ModelLibrary::Model* obj_model_;
+    };
+
+    class Hypothesis: public HypothesisBase
+    {
+      public:
+        Hypothesis (const ModelLibrary::Model* obj_model = NULL)
+         : HypothesisBase (obj_model),
+           match_confidence_ (-1.0f),
+           linear_id_ (-1)
+        {
+        }
+
+        Hypothesis (const Hypothesis& src)
+        : HypothesisBase (src.obj_model_, src.rigid_transform_),
+          match_confidence_  (src.match_confidence_),
+          explained_pixels_ (src.explained_pixels_)
+        {
+        }
+
+        virtual ~Hypothesis (){}
+
+        const Hypothesis&
+        operator =(const Hypothesis& src)
+        {
+          memcpy (this->rigid_transform_, src.rigid_transform_, 12*sizeof (float));
+          this->obj_model_  = src.obj_model_;
+          this->match_confidence_  = src.match_confidence_;
+          this->explained_pixels_ = src.explained_pixels_;
+
+          return *this;
+        }
+
+        void
+        setLinearId (int id)
+        {
+          linear_id_ = id;
+        }
+
+        int
+        getLinearId () const
+        {
+          return (linear_id_);
+        }
+
+        void
+        computeBounds (float bounds[6]) const
+        {
+          const float *b = obj_model_->getBoundsOfOctreePoints ();
+          float p[3];
+
+          // Initialize 'bounds'
+          aux::transform (rigid_transform_, b[0], b[2], b[4], p);
+          bounds[0] = bounds[1] = p[0];
+          bounds[2] = bounds[3] = p[1];
+          bounds[4] = bounds[5] = p[2];
+
+          // Expand 'bounds' to contain the other 7 points of the octree bounding box
+          aux::transform (rigid_transform_, b[0], b[2], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[0], b[3], b[4], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[0], b[3], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[2], b[4], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[2], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[3], b[4], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[3], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+        }
+
+        void
+        computeCenterOfMass (float center_of_mass[3]) const
+        {
+          aux::transform (rigid_transform_, obj_model_->getOctreeCenterOfMass (), center_of_mass);
+        }
+
+      public:
+        float match_confidence_;
+        std::set<int> explained_pixels_;
+        int linear_id_;
+    };
+  } // namespace recognition
+} // namespace pcl
+
+#endif /* PCL_RECOGNITION_HYPOTHESIS_H_ */
+###
+
+# implicit_shape_model.h
+namespace pcl
+{
+  /** \brief This struct is used for storing peak. */
+  struct ISMPeak
+  {
+    /** \brief Point were this peak is located. */
+    PCL_ADD_POINT4D;
+
+    /** \brief Density of this peak. */
+    double density;
+
+    /** \brief Determines which class this peak belongs. */
+    int class_id;
+
+    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+  } EIGEN_ALIGN16;
+
+  namespace features
+  {
+    /** \brief This class is used for storing, analyzing and manipulating votes
+      * obtained from ISM algorithm. */
+    template <typename PointT>
+    class PCL_EXPORTS ISMVoteList
+    {
+      public:
+
+        /** \brief Empty constructor with member variables initialization. */
+        ISMVoteList ();
+
+        /** \brief virtual descriptor. */
+        virtual
+        ~ISMVoteList ();
+
+        /** \brief This method simply adds another vote to the list.
+          * \param[in] in_vote vote to add
+          * \param[in] vote_origin origin of the added vote
+          * \param[in] in_class class for which this vote is cast
+          */
+        void
+        addVote (pcl::InterestPoint& in_vote, const PointT &vote_origin, int in_class);
+
+        /** \brief Returns the colored cloud that consists of votes for center (blue points) and
+          * initial point cloud (if it was passed).
+          * \param[in] cloud cloud that needs to be merged with votes for visualizing. */
+        typename pcl::PointCloud<pcl::PointXYZRGB>::Ptr
+        getColoredCloud (typename pcl::PointCloud<PointT>::Ptr cloud = 0);
+
+        /** \brief This method finds the strongest peaks (points were density has most higher values).
+          * It is based on the non maxima supression principles.
+          * \param[out] out_peaks it will contain the strongest peaks
+          * \param[in] in_class_id class of interest for which peaks are evaluated
+          * \param[in] in_non_maxima_radius non maxima supression radius. The shapes radius is recommended for this value.
+          * \param in_sigma
+          */
+        void
+        findStrongestPeaks (std::vector<ISMPeak, Eigen::aligned_allocator<ISMPeak> > &out_peaks, int in_class_id, double in_non_maxima_radius, double in_sigma);
+
+        /** \brief Returns the density at the specified point.
+          * \param[in] point point of interest
+          * \param[in] sigma_dist
+          */
+        double
+        getDensityAtPoint (const PointT &point, double sigma_dist);
+
+        /** \brief This method simply returns the number of votes. */
+        unsigned int
+        getNumberOfVotes ();
+
+      protected:
+
+        /** \brief this method is simply setting up the search tree. */
+        void
+        validateTree ();
+
+        Eigen::Vector3f
+        shiftMean (const Eigen::Vector3f& snapPt, const double in_dSigmaDist);
+
+      protected:
+
+        /** \brief Stores all votes. */
+        pcl::PointCloud<pcl::InterestPoint>::Ptr votes_;
+
+        /** \brief Signalizes if the tree is valid. */
+        bool tree_is_valid_;
+
+        /** \brief Stores the origins of the votes. */
+        typename pcl::PointCloud<PointT>::Ptr votes_origins_;
+
+        /** \brief Stores classes for which every single vote was cast. */
+        std::vector<int> votes_class_;
+
+        /** \brief Stores the search tree. */
+        pcl::KdTreeFLANN<pcl::InterestPoint>::Ptr tree_;
+
+        /** \brief Stores neighbours indices. */
+        std::vector<int> k_ind_;
+
+        /** \brief Stores square distances to the corresponding neighbours. */
+        std::vector<float> k_sqr_dist_;
+    };
+ 
+    /** \brief The assignment of this structure is to store the statistical/learned weights and other information
+      * of the trained Implict Shape Model algorithm.
+      */
+    struct PCL_EXPORTS ISMModel
+    {
+      /** \brief Simple constructor that initializes the structure. */
+      ISMModel ();
+
+      /** \brief Copy constructor for deep copy. */
+      ISMModel (ISMModel const & copy);
+
+      /** Destructor that frees memory. */
+      virtual
+      ~ISMModel ();
+
+      /** \brief This method simply saves the trained model for later usage.
+        * \param[in] file_name path to file for saving model
+        */
+      bool
+      saveModelToFile (std::string& file_name);
+
+      /** \brief This method loads the trained model from file.
+        * \param[in] file_name path to file which stores trained model
+        */
+      bool
+      loadModelFromfile (std::string& file_name);
+
+      /** \brief this method resets all variables and frees memory. */
+      void
+      reset ();
+
+      /** Operator overloading for deep copy. */
+      ISMModel & operator = (const ISMModel& other);
+
+      /** \brief Stores statistical weights. */
+      std::vector<std::vector<float> > statistical_weights_;
+
+      /** \brief Stores learned weights. */
+      std::vector<float> learned_weights_;
+
+      /** \brief Stores the class label for every direction. */
+      std::vector<unsigned int> classes_;
+
+      /** \brief Stores the sigma value for each class. This values were used to compute the learned weights. */
+      std::vector<float> sigmas_;
+
+      /** \brief Stores the directions to objects center for each visual word. */
+      Eigen::MatrixXf directions_to_center_;
+
+      /** \brief Stores the centers of the clusters that were obtained during the visual words clusterization. */
+      Eigen::MatrixXf clusters_centers_;
+
+      /** \brief This is an array of clusters. Each cluster stores the indices of the visual words that it contains. */
+      std::vector<std::vector<unsigned int> > clusters_;
+
+      /** \brief Stores the number of classes. */
+      unsigned int number_of_classes_;
+
+      /** \brief Stores the number of visual words. */
+      unsigned int number_of_visual_words_;
+
+      /** \brief Stores the number of clusters. */
+      unsigned int number_of_clusters_;
+
+      /** \brief Stores descriptors dimension. */
+      unsigned int descriptors_dimension_;
+
+      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+    };
+  }
+
+  namespace ism
+  {
+    /** \brief This class implements Implicit Shape Model algorithm described in
+      * "Hough Transforms and 3D SURF for robust three dimensional classication"
+      * by Jan Knopp1, Mukta Prasad, Geert Willems1, Radu Timofte, and Luc Van Gool.
+      * It has two main member functions. One for training, using the data for which we know
+      * which class it belongs to. And second for investigating a cloud for the presence
+      * of the class of interest.
+      * Implementation of the ISM algorithm described in "Hough Transforms and 3D SURF for robust three dimensional classication"
+      * by Jan Knopp, Mukta Prasad, Geert Willems, Radu Timofte, and Luc Van Gool
+      *
+      * Authors: Roman Shapovalov, Alexander Velizhev, Sergey Ushakov
+      */
+    template <int FeatureSize, typename PointT, typename NormalT = pcl::Normal>
+    class PCL_EXPORTS ImplicitShapeModelEstimation
+    {
+      public:
+
+        typedef boost::shared_ptr<pcl::features::ISMModel> ISMModelPtr;
+
+      protected:
+
+        /** \brief This structure stores the information about the keypoint. */
+        struct PCL_EXPORTS LocationInfo
+        {
+          /** \brief Location info constructor.
+            * \param[in] model_num number of training model.
+            * \param[in] dir_to_center expected direction to center
+            * \param[in] origin initial point
+            * \param[in] normal normal of the initial point
+            */
+          LocationInfo (unsigned int model_num, const PointT& dir_to_center, const PointT& origin, const NormalT& normal) :
+            model_num_ (model_num),
+            dir_to_center_ (dir_to_center),
+            point_ (origin),
+            normal_ (normal) {};
+
+          /** \brief Tells from which training model this keypoint was extracted. */
+          unsigned int model_num_;
+
+          /** \brief Expected direction to center for this keypoint. */
+          PointT dir_to_center_;
+
+          /** \brief Stores the initial point. */
+          PointT point_;
+
+          /** \brief Stores the normal of the initial point. */
+          NormalT normal_;
+        };
+
+        /** \brief This structure is used for determining the end of the
+          * k-means clustering process. */
+        typedef struct PCL_EXPORTS TC
+        {
+          enum
+          {
+            COUNT = 1,
+            EPS = 2
+          };
+
+          /** \brief Termination criteria constructor.
+            * \param[in] type defines the condition of termination(max iter., desired accuracy)
+            * \param[in] max_count defines the max number of iterations
+            * \param[in] epsilon defines the desired accuracy
+            */
+          TC(int type, int max_count, float epsilon) :
+            type_ (type),
+            max_count_ (max_count),
+            epsilon_ (epsilon) {};
+
+          /** \brief Flag that determines when the k-means clustering must be stopped.
+            * If type_ equals COUNT then it must be stopped when the max number of iterations will be
+            * reached. If type_ eaquals EPS then it must be stopped when the desired accuracy will be reached.
+            * These flags can be used together, in that case the clustering will be finished when one of these
+            * conditions will be reached.
+            */
+          int type_;
+
+          /** \brief Defines maximum number of iterations for k-means clustering. */
+          int max_count_;
+
+          /** \brief Defines the accuracy for k-means clustering. */
+          float epsilon_;
+        } TermCriteria;
+
+        /** \brief Structure for storing the visual word. */
+        struct PCL_EXPORTS VisualWordStat
+        {
+          /** \brief Empty constructor with member variables initialization. */
+          VisualWordStat () :
+            class_ (-1),
+            learned_weight_ (0.0f),
+            dir_to_center_ (0.0f, 0.0f, 0.0f) {};
+
+          /** \brief Which class this vote belongs. */
+          int class_;
+
+          /** \brief Weight of the vote. */
+          float learned_weight_;
+
+          /** \brief Expected direction to center. */
+          pcl::PointXYZ dir_to_center_;
+        };
+
+      public:
+
+        /** \brief Simple constructor that initializes everything. */
+        ImplicitShapeModelEstimation ();
+
+        /** \brief Simple destructor. */
+        virtual
+        ~ImplicitShapeModelEstimation ();
+
+        /** \brief This method simply returns the clouds that were set as the training clouds. */
+        std::vector<typename pcl::PointCloud<PointT>::Ptr>
+        getTrainingClouds ();
+
+        /** \brief Allows to set clouds for training the ISM model.
+          * \param[in] training_clouds array of point clouds for training
+          */
+        void
+        setTrainingClouds (const std::vector< typename pcl::PointCloud<PointT>::Ptr >& training_clouds);
+
+        /** \brief Returns the array of classes that indicates which class the corresponding training cloud belongs. */
+        std::vector<unsigned int>
+        getTrainingClasses ();
+
+        /** \brief Allows to set the class labels for the corresponding training clouds.
+          * \param[in] training_classes array of class labels
+          */
+        void
+        setTrainingClasses (const std::vector<unsigned int>& training_classes);
+
+        /** \brief This method returns the coresponding cloud of normals for every training point cloud. */
+        std::vector<typename pcl::PointCloud<NormalT>::Ptr>
+        getTrainingNormals ();
+
+        /** \brief Allows to set normals for the training clouds that were passed through setTrainingClouds method.
+          * \param[in] training_normals array of clouds, each cloud is the cloud of normals
+          */
+        void
+        setTrainingNormals (const std::vector< typename pcl::PointCloud<NormalT>::Ptr >& training_normals);
+
+        /** \brief Returns the sampling size used for cloud simplification. */
+        float
+        getSamplingSize ();
+
+        /** \brief Changes the sampling size used for cloud simplification.
+          * \param[in] sampling_size desired size of grid bin
+          */
+        void
+        setSamplingSize (float sampling_size);
+
+        /** \brief Returns the current feature estimator used for extraction of the descriptors. */
+        boost::shared_ptr<pcl::Feature<PointT, pcl::Histogram<FeatureSize> > >
+        getFeatureEstimator ();
+
+        /** \brief Changes the feature estimator.
+          * \param[in] feature feature estimator that will be used to extract the descriptors.
+          * Note that it must be fully initialized and configured.
+          */
+        void
+        setFeatureEstimator (boost::shared_ptr<pcl::Feature<PointT, pcl::Histogram<FeatureSize> > > feature);
+
+        /** \brief Returns the number of clusters used for descriptor clustering. */
+        unsigned int
+        getNumberOfClusters ();
+
+        /** \brief Changes the number of clusters.
+          * \param num_of_clusters desired number of clusters
+          */
+        void
+        setNumberOfClusters (unsigned int num_of_clusters);
+
+        /** \brief Returns the array of sigma values. */
+        std::vector<float>
+        getSigmaDists ();
+
+        /** \brief This method allows to set the value of sigma used for calculating the learned weights for every single class.
+          * \param[in] training_sigmas new sigmas for every class. If you want these values to be computed automatically,
+          * just pass the empty array. The automatic regime calculates the maximum distance between the objects points and takes 10% of
+          * this value as recomended in the article. If there are several objects of the same class,
+          * then it computes the average maximum distance and takes 10%. Note that each class has its own sigma value.
+          */
+        void
+        setSigmaDists (const std::vector<float>& training_sigmas);
+
+        /** \brief Returns the state of Nvot coeff from [Knopp et al., 2010, (4)],
+          * if set to false then coeff is taken as 1.0. It is just a kind of heuristic.
+          * The default behavior is as in the article. So you can ignore this if you want.
+          */
+        bool
+        getNVotState ();
+
+        /** \brief Changes the state of the Nvot coeff from [Knopp et al., 2010, (4)].
+          * \param[in] state desired state, if false then Nvot is taken as 1.0
+          */
+        void
+        setNVotState (bool state);
+
+        /** \brief This method performs training and forms a visual vocabulary. It returns a trained model that
+          * can be saved to file for later usage.
+          * \param[out] trained_model trained model
+          */
+        bool
+        trainISM (ISMModelPtr& trained_model);
+
+        /** \brief This function is searching for the class of interest in a given cloud
+          * and returns the list of votes.
+          * \param[in] model trained model which will be used for searching the objects
+          * \param[in] in_cloud input cloud that need to be investigated
+          * \param[in] in_normals cloud of normals coresponding to the input cloud
+          * \param[in] in_class_of_interest class which we are looking for
+          */
+        boost::shared_ptr<pcl::features::ISMVoteList<PointT> >
+        findObjects (ISMModelPtr model, typename pcl::PointCloud<PointT>::Ptr in_cloud, typename pcl::PointCloud<Normal>::Ptr in_normals, int in_class_of_interest);
+
+      protected:
+
+        /** \brief Extracts the descriptors from the input clouds.
+          * \param[out] histograms it will store the descriptors for each key point
+          * \param[out] locations it will contain the comprehensive information (such as direction, initial keypoint)
+          * for the corresponding descriptors
+          */
+        bool
+        extractDescriptors (std::vector<pcl::Histogram<FeatureSize> >& histograms,
+                            std::vector<LocationInfo, Eigen::aligned_allocator<LocationInfo> >& locations);
+
+        /** \brief This method performs descriptor clustering.
+          * \param[in] histograms descriptors to cluster
+          * \param[out] labels it contains labels for each descriptor
+          * \param[out] clusters_centers stores the centers of clusters
+          */
+        bool
+        clusterDescriptors (std::vector< pcl::Histogram<FeatureSize> >& histograms, Eigen::MatrixXi& labels, Eigen::MatrixXf& clusters_centers);
+
+        /** \brief This method calculates the value of sigma used for calculating the learned weights for every single class.
+          * \param[out] sigmas computed sigmas.
+          */
+        void
+        calculateSigmas (std::vector<float>& sigmas);
+
+        /** \brief This function forms a visual vocabulary and evaluates weights
+          * described in [Knopp et al., 2010, (5)].
+          * \param[in] locations array containing description of each keypoint: its position, which cloud belongs
+          * and expected direction to center
+          * \param[in] labels labels that were obtained during k-means clustering
+          * \param[in] sigmas array of sigmas for each class
+          * \param[in] clusters clusters that were obtained during k-means clustering
+          * \param[out] statistical_weights stores the computed statistical weights
+          * \param[out] learned_weights stores the computed learned weights
+          */
+        void
+        calculateWeights (const std::vector< LocationInfo, Eigen::aligned_allocator<LocationInfo> >& locations,
+                          const Eigen::MatrixXi &labels,
+                          std::vector<float>& sigmas,
+                          std::vector<std::vector<unsigned int> >& clusters,
+                          std::vector<std::vector<float> >& statistical_weights,
+                          std::vector<float>& learned_weights);
+
+        /** \brief Simplifies the cloud using voxel grid principles.
+          * \param[in] in_point_cloud cloud that need to be simplified
+          * \param[in] in_normal_cloud normals of the cloud that need to be simplified
+          * \param[out] out_sampled_point_cloud simplified cloud
+          * \param[out] out_sampled_normal_cloud and the corresponding normals
+          */
+        void
+        simplifyCloud (typename pcl::PointCloud<PointT>::ConstPtr in_point_cloud,
+                       typename pcl::PointCloud<NormalT>::ConstPtr in_normal_cloud,
+                       typename pcl::PointCloud<PointT>::Ptr out_sampled_point_cloud,
+                       typename pcl::PointCloud<NormalT>::Ptr out_sampled_normal_cloud);
+
+        /** \brief This method simply shifts the clouds points relative to the passed point.
+          * \param[in] in_cloud cloud to shift
+          * \param[in] shift_point point relative to which the cloud will be shifted
+          */
+        void
+        shiftCloud (typename pcl::PointCloud<PointT>::Ptr in_cloud, Eigen::Vector3f shift_point);
+
+        /** \brief This method simply computes the rotation matrix, so that the given normal
+          * would match the Y axis after the transformation. This is done because the algorithm needs to be invariant
+          * to the affine transformations.
+          * \param[in] in_normal normal for which the rotation matrix need to be computed
+          */
+        Eigen::Matrix3f
+        alignYCoordWithNormal (const NormalT& in_normal);
+
+        /** \brief This method applies transform set in in_transform to vector io_vector.
+          * \param[in] io_vec vector that need to be transformed
+          * \param[in] in_transform matrix that contains the transformation
+          */
+        void
+        applyTransform (Eigen::Vector3f& io_vec, const Eigen::Matrix3f& in_transform);
+
+        /** \brief This method estimates features for the given point cloud.
+          * \param[in] sampled_point_cloud sampled point cloud for which the features must be computed
+          * \param[in] normal_cloud normals for the original point cloud
+          * \param[out] feature_cloud it will store the computed histograms (features) for the given cloud
+          */
+        void
+        estimateFeatures (typename pcl::PointCloud<PointT>::Ptr sampled_point_cloud,
+                          typename pcl::PointCloud<NormalT>::Ptr normal_cloud,
+                          typename pcl::PointCloud<pcl::Histogram<FeatureSize> >::Ptr feature_cloud);
+
+        /** \brief Performs K-means clustering.
+          * \param[in] points_to_cluster points to cluster
+          * \param[in] number_of_clusters desired number of clusters
+          * \param[out] io_labels output parameter, which stores the label for each point
+          * \param[in] criteria defines when the computational process need to be finished. For example if the
+          * desired accuracy is achieved or the iteration number exceeds given value
+          * \param[in] attempts number of attempts to compute clustering
+          * \param[in] flags if set to USE_INITIAL_LABELS then initial approximation of labels is taken from io_labels
+          * \param[out] cluster_centers it will store the cluster centers
+          */
+        double
+        computeKMeansClustering (const Eigen::MatrixXf& points_to_cluster,
+                                 int number_of_clusters,
+                                 Eigen::MatrixXi& io_labels,
+                                 TermCriteria criteria,
+                                 int attempts,
+                                 int flags,
+                                 Eigen::MatrixXf& cluster_centers);
+
+        /** \brief Generates centers for clusters as described in 
+          * Arthur, David and Sergei Vassilvitski (2007) k-means++: The Advantages of Careful Seeding.
+          * \param[in] data points to cluster
+          * \param[out] out_centers it will contain generated centers
+          * \param[in] number_of_clusters defines the number of desired cluster centers
+          * \param[in] trials number of trials to generate a center
+          */
+        void
+        generateCentersPP (const Eigen::MatrixXf& data,
+                           Eigen::MatrixXf& out_centers,
+                           int number_of_clusters,
+                           int trials);
+
+        /** \brief Generates random center for cluster.
+          * \param[in] boxes contains min and max values for each dimension
+          * \param[out] center it will the contain generated center
+          */
+        void
+        generateRandomCenter (const std::vector<Eigen::Vector2f>& boxes, Eigen::VectorXf& center);
+
+        /** \brief Computes the square distance beetween two vectors.
+          * \param[in] vec_1 first vector
+          * \param[in] vec_2 second vector
+          */
+        float
+        computeDistance (Eigen::VectorXf& vec_1, Eigen::VectorXf& vec_2);
+
+        /** \brief Forbids the assignment operator. */
+        ImplicitShapeModelEstimation&
+        operator= (const ImplicitShapeModelEstimation&);
+
+      protected:
+
+        /** \brief Stores the clouds used for training. */
+        std::vector<typename pcl::PointCloud<PointT>::Ptr> training_clouds_;
+
+        /** \brief Stores the class number for each cloud from training_clouds_. */
+        std::vector<unsigned int> training_classes_;
+
+        /** \brief Stores the normals for each training cloud. */
+        std::vector<typename pcl::PointCloud<NormalT>::Ptr> training_normals_;
+
+        /** \brief This array stores the sigma values for each training class. If this array has a size equals 0, then
+          * sigma values will be calculated automatically.
+          */
+        std::vector<float> training_sigmas_;
+
+        /** \brief This value is used for the simplification. It sets the size of grid bin. */
+        float sampling_size_;
+
+        /** \brief Stores the feature estimator. */
+        boost::shared_ptr<pcl::Feature<PointT, pcl::Histogram<FeatureSize> > > feature_estimator_;
+
+        /** \brief Number of clusters, is used for clustering descriptors during the training. */
+        unsigned int number_of_clusters_;
+
+        /** \brief If set to false then Nvot coeff from [Knopp et al., 2010, (4)] is equal 1.0. */
+        bool n_vot_ON_;
+
+        /** \brief This const value is used for indicating that for k-means clustering centers must
+          * be generated as described in
+          * Arthur, David and Sergei Vassilvitski (2007) k-means++: The Advantages of Careful Seeding. */
+        static const int PP_CENTERS = 2;
+
+        /** \brief This const value is used for indicating that input labels must be taken as the
+          * initial approximation for k-means clustering. */
+        static const int USE_INITIAL_LABELS = 1;
+    };
+  }
+}
+
+POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::ISMPeak,
+  (float, x, x)
+  (float, y, y)
+  (float, z, z)
+  (float, density, ism_density)
+  (float, class_id, ism_class_id)
+)
+
+#endif  //#ifndef PCL_IMPLICIT_SHAPE_MODEL_H_
+###
+
+# linemod.h
+namespace pcl
+{
+
+  /** \brief Stores a set of energy maps.
+    * \author Stefan Holzer
+    */
+  class PCL_EXPORTS EnergyMaps
+  {
+    public:
+      /** \brief Constructor. */
+      EnergyMaps () : width_ (0), height_ (0), nr_bins_ (0), maps_ () 
+      {
+      }
+
+      /** \brief Destructor. */
+      virtual ~EnergyMaps () 
+      {
+      }
+
+      /** \brief Returns the width of the energy maps. */
+      inline size_t 
+      getWidth () const 
+      { 
+        return (width_); 
+      }
+      
+      /** \brief Returns the height of the energy maps. */
+      inline size_t 
+      getHeight () const 
+      { 
+        return (height_); 
+      }
+      
+      /** \brief Returns the number of bins used for quantization (which is equal to the number of energy maps). */
+      inline size_t 
+      getNumOfBins () const
+      { 
+        return (nr_bins_);
+      }
+
+      /** \brief Initializes the set of energy maps.
+        * \param[in] width the width of the energy maps.
+        * \param[in] height the height of the energy maps.
+        * \param[in] nr_bins the number of bins used for quantization.
+        */
+      void 
+      initialize (const size_t width, const size_t height, const size_t nr_bins)
+      {
+        maps_.resize(nr_bins, NULL);
+        width_ = width;
+        height_ = height;
+        nr_bins_ = nr_bins;
+
+        const size_t mapsSize = width*height;
+
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+        {
+          //maps_[map_index] = new unsigned char[mapsSize];
+          maps_[map_index] = reinterpret_cast<unsigned char*> (aligned_malloc (mapsSize));
+          memset (maps_[map_index], 0, mapsSize);
+        }
+      }
+
+      /** \brief Releases the internal data. */
+      void 
+      releaseAll ()
+      {
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+          //if (maps_[map_index] != NULL) delete[] maps_[map_index];
+          if (maps_[map_index] != NULL) aligned_free (maps_[map_index]);
+
+        maps_.clear ();
+        width_ = 0;
+        height_ = 0;
+        nr_bins_ = 0;
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] col_index the column index within the specified energy map.
+        * \param[in] row_index the row index within the specified energy map.
+        */
+      inline unsigned char & 
+      operator() (const size_t bin_index, const size_t col_index, const size_t row_index)
+      {
+        return (maps_[bin_index][row_index*width_ + col_index]);
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] index the element index within the specified energy map.
+        */
+      inline unsigned char & 
+      operator() (const size_t bin_index, const size_t index)
+      {
+        return (maps_[bin_index][index]);
+      }
+
+      /** \brief Returns a pointer to the data of the specified energy map.
+        * \param[in] bin_index the index of the energy map to return (== the quantization bin).
+        */
+      inline unsigned char * 
+      operator() (const size_t bin_index)
+      {
+        return (maps_[bin_index]);
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] col_index the column index within the specified energy map.
+        * \param[in] row_index the row index within the specified energy map.
+        */
+      inline const unsigned char & 
+      operator() (const size_t bin_index, const size_t col_index, const size_t row_index) const
+      {
+        return (maps_[bin_index][row_index*width_ + col_index]);
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] index the element index within the specified energy map.
+        */
+      inline const unsigned char & 
+      operator() (const size_t bin_index, const size_t index) const
+      {
+        return (maps_[bin_index][index]);
+      }
+
+      /** \brief Returns a pointer to the data of the specified energy map.
+        * \param[in] bin_index the index of the energy map to return (== the quantization bin).
+        */
+      inline const unsigned char * 
+      operator() (const size_t bin_index) const
+      {
+        return (maps_[bin_index]);
+      }
+
+    private:
+      /** \brief The width of the energy maps. */
+      size_t width_;
+      /** \brief The height of the energy maps. */
+      size_t height_;
+      /** \brief The number of quantization bins (== the number of internally stored energy maps). */
+      size_t nr_bins_;
+      /** \brief Storage for the energy maps. */
+      std::vector<unsigned char*> maps_;
+  };
+
+  /** \brief Stores a set of linearized maps.
+    * \author Stefan Holzer
+    */
+  class PCL_EXPORTS LinearizedMaps
+  {
+    public:
+      /** \brief Constructor. */
+      LinearizedMaps () : width_ (0), height_ (0), mem_width_ (0), mem_height_ (0), step_size_ (0), maps_ ()
+      {
+      }
+      
+      /** \brief Destructor. */
+      virtual ~LinearizedMaps () 
+      {
+      }
+
+      /** \brief Returns the width of the linearized map. */
+      inline size_t 
+      getWidth () const { return (width_); }
+      
+      /** \brief Returns the height of the linearized map. */
+      inline size_t 
+      getHeight () const { return (height_); }
+      
+      /** \brief Returns the step-size used to construct the linearized map. */
+      inline size_t 
+      getStepSize () const { return (step_size_); }
+      
+      /** \brief Returns the size of the memory map. */
+      inline size_t 
+      getMapMemorySize () const { return (mem_width_ * mem_height_); }
+
+      /** \brief Initializes the linearized map.
+        * \param[in] width the width of the source map.
+        * \param[in] height the height of the source map.
+        * \param[in] step_size the step-size used to sample the source map.
+        */
+      void 
+      initialize (const size_t width, const size_t height, const size_t step_size)
+      {
+        maps_.resize(step_size*step_size, NULL);
+        width_ = width;
+        height_ = height;
+        mem_width_ = width / step_size;
+        mem_height_ = height / step_size;
+        step_size_ = step_size;
+
+        const size_t mapsSize = mem_width_ * mem_height_;
+
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+        {
+          //maps_[map_index] = new unsigned char[2*mapsSize];
+          maps_[map_index] = reinterpret_cast<unsigned char*> (aligned_malloc (2*mapsSize));
+          memset (maps_[map_index], 0, 2*mapsSize);
+        }
+      }
+
+      /** \brief Releases the internal memory. */
+      void 
+      releaseAll ()
+      {
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+          //if (maps_[map_index] != NULL) delete[] maps_[map_index];
+          if (maps_[map_index] != NULL) aligned_free (maps_[map_index]);
+
+        maps_.clear ();
+        width_ = 0;
+        height_ = 0;
+        mem_width_ = 0;
+        mem_height_ = 0;
+        step_size_ = 0;
+      }
+
+      /** \brief Operator to access elements of the linearized map by column and row index.
+        * \param[in] col_index the column index.
+        * \param[in] row_index the row index.
+        */
+      inline unsigned char * 
+      operator() (const size_t col_index, const size_t row_index)
+      {
+        return (maps_[row_index*step_size_ + col_index]);
+      }
+
+      /** \brief Returns a linearized map starting at the specified position.
+        * \param[in] col_index the column index at which the returned map starts.
+        * \param[in] row_index the row index at which the returned map starts.
+        */
+      inline unsigned char * 
+      getOffsetMap (const size_t col_index, const size_t row_index)
+      {
+        const size_t map_col = col_index % step_size_;
+        const size_t map_row = row_index % step_size_;
+
+        const size_t map_mem_col_index = col_index / step_size_;
+        const size_t map_mem_row_index = row_index / step_size_;
+
+        return (maps_[map_row*step_size_ + map_col] + map_mem_row_index*mem_width_ + map_mem_col_index);
+      }
+
+    private:
+      /** \brief the original width of the data represented by the map. */
+      size_t width_;
+      /** \brief the original height of the data represented by the map. */
+      size_t height_;
+      /** \brief the actual width of the linearized map. */
+      size_t mem_width_;
+      /** \brief the actual height of the linearized map. */
+      size_t mem_height_;
+      /** \brief the step-size used for sampling the original data. */
+      size_t step_size_;
+      /** \brief a vector containing all the linearized maps. */
+      std::vector<unsigned char*> maps_;
+  };
+
+  /** \brief Represents a detection of a template using the LINEMOD approach.
+    * \author Stefan Holzer
+    */
+  struct PCL_EXPORTS LINEMODDetection
+  {
+    /** \brief Constructor. */
+    LINEMODDetection () : x (0), y (0), template_id (0), score (0.0f), scale (1.0f) {}
+
+    /** \brief x-position of the detection. */
+    int x;
+    /** \brief y-position of the detection. */
+    int y;
+    /** \brief ID of the detected template. */
+    int template_id;
+    /** \brief score of the detection. */
+    float score;
+    /** \brief scale at which the template was detected. */
+    float scale;
+  };
+
+  /**
+    * \brief Template matching using the LINEMOD approach.
+    * \author Stefan Holzer, Stefan Hinterstoisser
+    */
+  class PCL_EXPORTS LINEMOD
+  {
+    public:
+      /** \brief Constructor */
+      LINEMOD ();
+
+      /** \brief Destructor */
+      virtual ~LINEMOD ();
+
+      /** \brief Creates a template from the specified data and adds it to the matching queue. 
+        * \param[in] modalities the modalities used to create the template.
+        * \param[in] masks the masks that determine which parts of the modalities are used for creating the template.
+        * \param[in] region the region which will be associated with the template (can be larger than the actual modality-maps).
+        */
+      int 
+      createAndAddTemplate (const std::vector<QuantizableModality*> & modalities,
+                            const std::vector<MaskMap*> & masks,
+                            const RegionXY & region);
+
+      /** \brief Adds the specified template to the matching queue.
+        * \param[in] linemod_template the template to add.
+        */
+      int
+      addTemplate (const SparseQuantizedMultiModTemplate & linemod_template);
+
+      /** \brief Detects the stored templates in the supplied modality data.
+        * \param[in] modalities the modalities that will be used for detection.
+        * \param[out] detections the destination for the detections.
+        */
+      void
+      detectTemplates (const std::vector<QuantizableModality*> & modalities,
+                       std::vector<LINEMODDetection> & detections) const;
+
+      /** \brief Detects the stored templates in a semi scale invariant manner 
+        *        by applying the detection to multiple scaled versions of the input data.
+        * \param[in] modalities the modalities that will be used for detection.
+        * \param[out] detections the destination for the detections.
+        * \param[in] min_scale the minimum scale.
+        * \param[in] max_scale the maximum scale.
+        * \param[in] scale_multiplier the multiplier for getting from one scale to the next.
+        */
+      void
+      detectTemplatesSemiScaleInvariant (const std::vector<QuantizableModality*> & modalities,
+                                         std::vector<LINEMODDetection> & detections,
+                                         float min_scale = 0.6944444f,
+                                         float max_scale = 1.44f,
+                                         float scale_multiplier = 1.2f) const;
+
+      /** \brief Matches the stored templates to the supplied modality data.
+        * \param[in] modalities the modalities that will be used for matching.
+        * \param[out] matches the found matches.
+        */
+      void
+      matchTemplates (const std::vector<QuantizableModality*> & modalities,
+                      std::vector<LINEMODDetection> & matches) const;
+
+      /** \brief Sets the detection threshold. 
+        * \param[in] threshold the detection threshold.
+        */
+      inline void
+      setDetectionThreshold (float threshold)
+      {
+        template_threshold_ = threshold;
+      }
+
+      /** \brief Enables/disables non-maximum suppression.
+        * \param[in] use_non_max_suppression determines whether to use non-maximum suppression or not.
+        */
+      inline void
+      setNonMaxSuppression (bool use_non_max_suppression)
+      {
+        use_non_max_suppression_ = use_non_max_suppression;
+      }
+
+      /** \brief Enables/disables averaging of close detections.
+        * \param[in] average_detections determines whether to average close detections or not.
+        */
+      inline void
+      setDetectionAveraging (bool average_detections)
+      {
+        average_detections_ = average_detections;
+      }
+
+      /** \brief Returns the template with the specified ID.
+        * \param[in] template_id the ID of the template to return.
+        */
+      inline const SparseQuantizedMultiModTemplate &
+      getTemplate (int template_id) const
+      { 
+        return (templates_[template_id]);
+      }
+
+      /** \brief Returns the number of stored/trained templates. */
+      inline size_t
+      getNumOfTemplates () const
+      {
+        return (templates_.size ());
+      }
+
+      /** \brief Saves the stored templates to the specified file.
+        * \param[in] file_name the name of the file to save the templates to.
+        */
+      void
+      saveTemplates (const char * file_name) const;
+
+      /** \brief Loads templates from the specified file.
+        * \param[in] file_name the name of the file to load the template from.
+        */
+      void
+      loadTemplates (const char * file_name);
+
+      /** \brief Loads templates from the specified files.
+        * \param[in] file_names vector of files to load the templates from.
+        */
+
+      void
+      loadTemplates (std::vector<std::string> & file_names);
+
+      /** \brief Serializes the stored templates to the specified stream.
+        * \param[in] stream the stream the templates will be written to.
+        */
+      void 
+      serialize (std::ostream & stream) const;
+
+      /** \brief Deserializes templates from the specified stream.
+        * \param[in] stream the stream the templates will be read from.
+        */
+      void 
+      deserialize (std::istream & stream);
+
+
+    private:
+      /** template response threshold */
+      float template_threshold_;
+      /** states whether non-max-suppression on detections is enabled or not */
+      bool use_non_max_suppression_;
+      /** states whether to return an averaged detection */
+      bool average_detections_;
+      /** template storage */
+      std::vector<SparseQuantizedMultiModTemplate> templates_;
+  };
+
+}
+
+#endif 
+
+###
+
+# line_rgbd.h
+# namespace pcl
+# struct BoundingBoxXYZ
+    # /** \brief Constructor. */
+    # BoundingBoxXYZ () : x (0.0f), y (0.0f), z (0.0f), width (0.0f), height (0.0f), depth (0.0f) {}
+	# 
+    # /** \brief X-coordinate of the upper left front point */
+    # float x;
+    # /** \brief Y-coordinate of the upper left front point */
+    # float y;
+    # /** \brief Z-coordinate of the upper left front point */
+    # float z;
+	# 
+    # /** \brief Width of the bounding box */
+    # float width;
+    # /** \brief Height of the bounding box */
+    # float height;
+    # /** \brief Depth of the bounding box */
+    # float depth;
+	
+	# /** \brief High-level class for template matching using the LINEMOD approach based on RGB and Depth data.
+    # * \author Stefan Holzer
+    # */
+  	# template <typename PointXYZT, typename PointRGBT=PointXYZT>
+  	# class PCL_EXPORTS LineRGBD
+  	# {
+    	# public:
+		# 
+      	# /** \brief A LineRGBD detection. */
+      	# struct Detection
+      		# /** \brief Constructor. */
+        	# Detection () : template_id (0), object_id (0), detection_id (0), response (0.0f), bounding_box () {}
+			# 
+        	# /** \brief The ID of the template. */
+        	# size_t template_id;
+        	# /** \brief The ID of the object corresponding to the template. */
+        	# size_t object_id;
+        	# /** \brief The ID of this detection. This is only valid for the last call of the method detect (...). */
+        	# size_t detection_id;
+        	# /** \brief The response of this detection. Responses are between 0 and 1, where 1 is best. */
+        	# float response;
+        	# /** \brief The 3D bounding box of the detection. */
+        	# BoundingBoxXYZ bounding_box;
+        	# /** \brief The 2D template region of the detection. */
+        	# RegionXY region;
+		
+		
+      	# /** \brief Constructor */
+      	# LineRGBD ()
+        # : intersection_volume_threshold_ (1.0f)
+        # , linemod_ ()
+        # , color_gradient_mod_ ()
+        # , surface_normal_mod_ ()
+        # , cloud_xyz_ ()
+        # , cloud_rgb_ ()
+        # , template_point_clouds_ ()
+        # , bounding_boxes_ ()
+        # , object_ids_ ()
+        # , detections_ ()
+		# /** \brief Destructor */
+      	# virtual ~LineRGBD ()
+      	# /** \brief Loads templates from a LMT (LineMod Template) file. Overrides old templates.
+        # 	* LineMod Template files are TAR files that store pairs of PCD datasets
+        # 	* together with their LINEMOD signatures in \ref
+        # 	* SparseQuantizedMultiModTemplate format.
+        # 	* \param[in] file_name The name of the file that stores the templates.
+        # 	* \param object_id
+        # 	* \return true, if the operation was successful, false otherwise.
+        # */
+      	# bool loadTemplates (const std::string &file_name, size_t object_id = 0);
+		# 
+      	# bool addTemplate (const SparseQuantizedMultiModTemplate & sqmmt, pcl::PointCloud<pcl::PointXYZRGBA> & cloud, size_t object_id = 0);
+		# 
+      	# /** \brief Sets the threshold for the detection responses. Responses are between 0 and 1, where 1 is a best. 
+        #  * \param[in] threshold The threshold used to decide where a template is detected.
+        # */
+      	# inline void setDetectionThreshold (float threshold)
+		# 
+      	# /** \brief Sets the threshold on the magnitude of color gradients. Color gradients with a magnitude below 
+        #  *        this threshold are not considered in the detection process.
+        #  * \param[in] threshold The threshold on the magnitude of color gradients.
+        # */
+      	# inline void setGradientMagnitudeThreshold (const float threshold)
+		# 
+      	# /** \brief Sets the threshold for the decision whether two detections of the same template are merged or not. 
+        #  *        If ratio between the intersection of the bounding boxes of two detections and the original bounding 
+        #  *        boxes is larger than the specified threshold then they are merged. If detection A overlaps with 
+        #  *        detection B and B with C than A, B, and C are merged. Threshold has to be between 0 and 1.
+        #  * \param[in] threshold The threshold on the ratio between the intersection bounding box and the original 
+        #  *                      bounding box.
+        # */
+      	# inline void setIntersectionVolumeThreshold (const float threshold = 1.0f)
+		# 
+      	# /** \brief Sets the input cloud with xyz point coordinates. The cloud has to be organized. 
+        #  * \param[in] cloud The input cloud with xyz point coordinates.
+        # */
+      	# inline void setInputCloud (const typename pcl::PointCloud<PointXYZT>::ConstPtr & cloud)
+      	# 
+      	# /** \brief Sets the input cloud with rgb values. The cloud has to be organized. 
+        #  * \param[in] cloud The input cloud with rgb values.
+        # */
+      	# inline void setInputColors (const typename pcl::PointCloud<PointRGBT>::ConstPtr & cloud)
+		# 
+      	# /** \brief Creates a template from the specified data and adds it to the matching queue. 
+        #  * \param cloud
+        #  * \param object_id
+        #  * \param[in] mask_xyz the mask that determine which parts of the xyz-modality are used for creating the template.
+        #  * \param[in] mask_rgb the mask that determine which parts of the rgb-modality are used for creating the template.
+        #  * \param[in] region the region which will be associated with the template (can be larger than the actual modality-maps).
+        #  */
+      	# int createAndAddTemplate (
+        # 	pcl::PointCloud<pcl::PointXYZRGBA> & cloud,
+        # 	const size_t object_id,
+        # 	const MaskMap & mask_xyz,
+        # 	const MaskMap & mask_rgb,
+        # 	const RegionXY & region);
+		# 
+      	# /** \brief Applies the detection process and fills the supplied vector with the detection instances. 
+        #  * \param[out] detections The storage for the detection instances.
+        #  */
+      	# void detect (std::vector<typename pcl::LineRGBD<PointXYZT, PointRGBT>::Detection> & detections);
+		# 
+      	# /** \brief Applies the detection process in a semi-scale-invariant manner. This is done by acutally
+        #  *        scaling the template to different sizes.
+        #  */
+      	# void detectSemiScaleInvariant (std::vector<typename pcl::LineRGBD<PointXYZT, PointRGBT>::Detection> & detections,
+        #                         		float min_scale = 0.6944444f,
+        #                         		float max_scale = 1.44f,
+        #                         		float scale_multiplier = 1.2f);
+		# 
+      	# /** \brief Computes and returns the point cloud of the specified detection. This is the template point 
+        #  *        cloud transformed to the detection coordinates. The detection ID refers to the last call of 
+        #  *        the method detect (...).
+        #  * \param[in] detection_id The ID of the detection (according to the last call of the method detect (...)).
+        #  * \param[out] cloud The storage for the transformed points.
+        #  */
+      	# void computeTransformedTemplatePoints (const size_t detection_id,
+        #                                 pcl::PointCloud<pcl::PointXYZRGBA> & cloud);
+		# 
+      	# /** \brief Finds the indices of the points in the input cloud which correspond to the specified detection. 
+        #  *        The detection ID refers to the last call of the method detect (...).
+        #  * \param[in] detection_id The ID of the detection (according to the last call of the method detect (...)).
+        #  */
+      	# inline std::vector<size_t> findObjectPointIndices (const size_t detection_id)
+
+###
+
+# mask_map.h
+# namespace pcl
+	# class PCL_EXPORTS MaskMap
+  	# public:
+    	# MaskMap ();
+      	# MaskMap (size_t width, size_t height);
+      	# virtual ~MaskMap ();
+		# 
+      	# void resize (size_t width, size_t height);
+		# 
+      	# inline size_t getWidth () const { return (width_); }
+      	# inline size_t getHeight () const { return (height_); }
+        # inline unsigned char* getData () { return (&data_[0]); }
+		# inline const unsigned char* getData () const { return (&data_[0]); }
+      	# static void getDifferenceMask (const MaskMap & mask0,
+        #             					const MaskMap & mask1,
+        #                  				MaskMap & diff_mask);
+		# 
+      	# inline void set (const size_t x, const size_t y)
+      	# inline void unset (const size_t x, const size_t y)
+	    # inline bool isSet (const size_t x, const size_t y) const
+      	# inline void reset ()
+      	# inline unsigned char & operator() (const size_t x, const size_t y) 
+      	# inline const unsigned char &operator() (const size_t x, const size_t y) const
+      	# void erode (MaskMap & eroded_mask) const;
+
+
+###
+
+# model_library.h
+# #include <pcl/recognition/ransac_based/model_library.h>
+# namespace pcl
+# namespace recognition
+    # class PCL_EXPORTS ModelLibrary
+    	# public:
+        # typedef pcl::PointCloud<pcl::PointXYZ> PointCloudIn;
+        # typedef pcl::PointCloud<pcl::Normal> PointCloudN;
+		# 
+        # /** \brief Stores some information about the model. */
+        # class Model
+        	# public:
+            # Model (const PointCloudIn& points, const PointCloudN& normals, float voxel_size, const std::string& object_name,
+            #        float frac_of_points_for_registration, void* user_data = NULL)
+            # : obj_name_(object_name),
+            #   user_data_ (user_data)
+            virtual ~Model ()
+            inline const std::string& getObjectName () const
+            inline const ORROctree& getOctree () const
+            inline void* getUserData () const
+            inline const float* getOctreeCenterOfMass () const
+            inline const float* getBoundsOfOctreePoints () const
+            inline const PointCloudIn& getPointsForRegistration () const
+          	
+		# typedef std::list<std::pair<const ORROctree::Node::Data*, const ORROctree::Node::Data*> > node_data_pair_list;
+        # typedef std::map<const Model*, node_data_pair_list> HashTableCell;
+        # typedef VoxelStructure<HashTableCell, float> HashTable;
+		
+      	# public:
+        # /** \brief This class is used by 'ObjRecRANSAC' to maintain the object models to be recognized. Normally, you do not need to use
+        #   * this class directly. */
+        # ModelLibrary (float pair_width, float voxel_size, float max_coplanarity_angle = 3.0f*AUX_DEG_TO_RADIANS/*3 degrees*/);
+        # virtual ~ModelLibrary ()
+        # 
+        # /** \brief Removes all models from the library and clears the hash table. */
+        # void removeAllModels ();
+		# 
+        # /** \brief This is a threshold. The larger the value the more point pairs will be considered as co-planar and will
+        #   * be ignored in the off-line model pre-processing and in the online recognition phases. This makes sense only if
+        #   * "ignore co-planar points" is on. Call this method before calling addModel. */
+        # inline void setMaxCoplanarityAngleDegrees (float max_coplanarity_angle_degrees)
+		# 
+        # /** \brief Call this method in order NOT to add co-planar point pairs to the hash table. The default behavior
+        #   * is ignoring co-planar points on. */
+        # inline void ignoreCoplanarPointPairsOn ()
+		# 
+        # /** \brief Call this method in order to add all point pairs (co-planar as well) to the hash table. The default
+        #   * behavior is ignoring co-planar points on. */
+        # inline void ignoreCoplanarPointPairsOff ()
+		# 
+        # /** \brief Adds a model to the hash table.
+        #   *
+        #   * \param[in] points represents the model to be added.
+        #   * \param[in] normals are the normals at the model points.
+        #   * \param[in] object_name is the unique name of the object to be added.
+        #   * \param[in] frac_of_points_for_registration is the number of points used for fast ICP registration prior to hypothesis testing
+        #   * \param[in] user_data is a pointer to some data (can be NULL)
+        #   *
+        #   * Returns true if model successfully added and false otherwise (e.g., if object_name is not unique). */
+        # bool addModel (
+        # 		const PointCloudIn& points, const PointCloudN& normals, const std::string& object_name,
+        #         float frac_of_points_for_registration, void* user_data = NULL);
+		# 
+        # /** \brief Returns the hash table built by this instance. */
+        # inline const HashTable& getHashTable () const
+		# inline const Model* getModel (const std::string& name) const
+        # inline const std::map<std::string,Model*>& getModels () const
+
+
+###
+
+# obj_rec_ransac.h
+# #include <pcl/recognition/ransac_based/obj_rec_ransac.h>
+# #error "Using pcl/recognition/obj_rec_ransac.h is deprecated, please use pcl/recognition/ransac_based/obj_rec_ransac.h instead."
+# namespace pcl
+# namespace recognition
+    # /** \brief This is a RANSAC-based 3D object recognition method. Do the following to use it: (i) call addModel() k times with k different models
+    #   * representing the objects to be recognized and (ii) call recognize() with the 3D scene in which the objects should be recognized. Recognition means both
+    #   * object identification and pose (position + orientation) estimation. Check the method descriptions for more details.
+    #   *
+    #   * \note If you use this code in any academic work, please cite:
+    #   *
+    #   *   - Chavdar Papazov, Sami Haddadin, Sven Parusel, Kai Krieger and Darius Burschka.
+    #   *     Rigid 3D geometry matching for grasping of known objects in cluttered scenes.
+    #   *     The International Journal of Robotics Research 2012. DOI: 10.1177/0278364911436019
+    #   *
+    #   *   - Chavdar Papazov and Darius Burschka.
+    #   *     An Efficient RANSAC for 3D Object Recognition in Noisy and Occluded Scenes.
+    #   *     In Proceedings of the 10th Asian Conference on Computer Vision (ACCV'10),
+    #   *     November 2010.
+    #   *
+    #   *
+    #   * \author Chavdar Papazov
+    #   * \ingroup recognition
+    #   */
+    # class PCL_EXPORTS ObjRecRANSAC
+    	# public:
+        # typedef ModelLibrary::PointCloudIn PointCloudIn;
+        # typedef ModelLibrary::PointCloudN PointCloudN;
+		# 
+        # typedef BVH<Hypothesis*> BVHH;
+		# 
+        # /** \brief This is an output item of the ObjRecRANSAC::recognize() method. It contains the recognized model, its name (the ones passed to
+        #   * ObjRecRANSAC::addModel()), the rigid transform which aligns the model with the input scene and the match confidence which is a number
+        #   * in the interval (0, 1] which gives the fraction of the model surface area matched to the scene. E.g., a match confidence of 0.3 means
+        #   * that 30% of the object surface area was matched to the scene points. If the scene is represented by a single range image, the match
+        #   * confidence can not be greater than 0.5 since the range scanner sees only one side of each object.
+        #   */
+        # class Output
+        	# public:
+            # Output (const std::string& object_name, const float rigid_transform[12], float match_confidence, void* user_data) :
+            #   object_name_ (object_name),
+            #   match_confidence_ (match_confidence),
+            #   user_data_ (user_data)
+            # virtual ~Output (){}
+			# 
+          	# public:
+            # std::string object_name_;
+            # float rigid_transform_[12];
+            # float match_confidence_;
+            # void* user_data_;
+
+        # class OrientedPointPair
+        	# public:
+            # OrientedPointPair (const float *p1, const float *n1, const float *p2, const float *n2)
+            #   : p1_ (p1), n1_ (n1), p2_ (p2), n2_ (n2)
+            # 
+            # virtual ~OrientedPointPair (){}
+			# 
+            # public:
+            #   const float *p1_, *n1_, *p2_, *n2_;
+
+        # class HypothesisCreator
+        	# public:
+            # HypothesisCreator (){}
+            # virtual ~HypothesisCreator (){}
+			# 
+            # Hypothesis* create (const SimpleOctree<Hypothesis, HypothesisCreator, float>::Node* ) const { return new Hypothesis ();}
+        # typedef SimpleOctree<Hypothesis, HypothesisCreator, float> HypothesisOctree;
+		# 
+		# 
+      	# public:
+        # /** \brief Constructor with some important parameters which can not be changed once an instance of that class is created.
+        #   *
+        #   * \param[in] pair_width should be roughly half the extent of the visible object part. This means, for each object point p there should be (at least)
+        #   * one point q (from the same object) such that ||p - q|| <= pair_width. Tradeoff: smaller values allow for detection in more occluded scenes but lead
+        #   * to more imprecise alignment. Bigger values lead to better alignment but require large visible object parts (i.e., less occlusion).
+        #   *
+        #   * \param[in] voxel_size is the size of the leafs of the octree, i.e., the "size" of the discretization. Tradeoff: High values lead to less
+        #   * computation time but ignore object details. Small values allow to better distinguish between objects, but will introduce more holes in the resulting
+        #   * "voxel-surface" (especially for a sparsely sampled scene). */
+        # ObjRecRANSAC (float pair_width, float voxel_size);
+        # virtual ~ObjRecRANSAC ()
+        # 
+        # /** \brief Removes all models from the model library and releases some memory dynamically allocated by this instance. */
+        # void inline clear()
+        # 
+        # /** \brief This is a threshold. The larger the value the more point pairs will be considered as co-planar and will
+        #   * be ignored in the off-line model pre-processing and in the online recognition phases. This makes sense only if
+        #   * "ignore co-planar points" is on. Call this method before calling addModel. This method calls the corresponding
+        #   * method of the model library. */
+        # inline void setMaxCoplanarityAngleDegrees (float max_coplanarity_angle_degrees)
+        # inline void setSceneBoundsEnlargementFactor (float value)
+		# 
+        # /** \brief Default is on. This method calls the corresponding method of the model library. */
+        # inline void ignoreCoplanarPointPairsOn ()
+        # 
+        # /** \brief Default is on. This method calls the corresponding method of the model library. */
+        # inline void ignoreCoplanarPointPairsOff ()
+        # 
+        # inline void icpHypothesesRefinementOn ()
+        # inline void icpHypothesesRefinementOff ()
+		# 
+        # /** \brief Add an object model to be recognized.
+        #   *
+        #   * \param[in] points are the object points.
+        #   * \param[in] normals at each point.
+        #   * \param[in] object_name is an identifier for the object. If that object is detected in the scene 'object_name'
+        #   * is returned by the recognition method and you know which object has been detected. Note that 'object_name' has
+        #   * to be unique!
+        #   * \param[in] user_data is a pointer to some data (can be NULL)
+        #   *
+        #   * The method returns true if the model was successfully added to the model library and false otherwise (e.g., if 'object_name' is already in use).
+        #   */
+        # inline bool addModel (const PointCloudIn& points, const PointCloudN& normals, const std::string& object_name, void* user_data = NULL)
+        # 
+        # /** \brief This method performs the recognition of the models loaded to the model library with the method addModel().
+        #   *
+        #   * \param[in]  scene is the 3d scene in which the object should be recognized.
+        #   * \param[in]  normals are the scene normals.
+        #   * \param[out] recognized_objects is the list of output items each one containing the recognized model instance, its name, the aligning rigid transform
+        #   * and the match confidence (see ObjRecRANSAC::Output for further explanations).
+        #   * \param[in]  success_probability is the user-defined probability of detecting all objects in the scene.
+        #   */
+        # void recognize (const PointCloudIn& scene, const PointCloudN& normals, std::list<ObjRecRANSAC::Output>& recognized_objects, double success_probability = 0.99);
+		# 
+        # inline void enterTestModeSampleOPP ()
+        # inline void enterTestModeTestHypotheses ()
+        # inline void leaveTestMode ()
+		# 
+        # /** \brief This function is useful for testing purposes. It returns the oriented point pairs which were sampled from the
+        #   * scene during the recognition process. Makes sense only if some of the testing modes are active. */
+        # inline const std::list<ObjRecRANSAC::OrientedPointPair>& getSampledOrientedPointPairs () const
+		# 
+        # /** \brief This function is useful for testing purposes. It returns the accepted hypotheses generated during the
+        #   * recognition process. Makes sense only if some of the testing modes are active. */
+        # inline const std::vector<Hypothesis>& getAcceptedHypotheses () const
+		# 
+        # /** \brief This function is useful for testing purposes. It returns the accepted hypotheses generated during the
+        #   * recognition process. Makes sense only if some of the testing modes are active. */
+        # inline void getAcceptedHypotheses (std::vector<Hypothesis>& out) const
+		# 
+        # /** \brief Returns the hash table in the model library. */
+        # inline const pcl::recognition::ModelLibrary::HashTable& getHashTable () const
+		# 
+        # inline const ModelLibrary& getModelLibrary () const
+        # inline const ModelLibrary::Model* getModel (const std::string& name) const
+        # inline const ORROctree& getSceneOctree () const
+        # inline RigidTransformSpace& getRigidTransformSpace ()
+        # inline float getPairWidth () const
+		# 
+      	# protected:
+        # enum Recognition_Mode {SAMPLE_OPP, TEST_HYPOTHESES, /*BUILD_CONFLICT_GRAPH,*/ FULL_RECOGNITION};
+        # friend class ModelLibrary;
+		# 
+        # inline int computeNumberOfIterations (double success_probability) const
+        # inline void clearTestData ()
+        # void sampleOrientedPointPairs (int num_iterations, const std::vector<ORROctree::Node*>& full_scene_leaves, std::list<OrientedPointPair>& output) const;
+        # int generateHypotheses (const std::list<OrientedPointPair>& pairs, std::list<HypothesisBase>& out) const;
+		# 
+        # /** \brief Groups close hypotheses in 'hypotheses'. Saves a representative for each group in 'out'. Returns the
+        #   * number of hypotheses after grouping. */
+        # int groupHypotheses(std::list<HypothesisBase>& hypotheses, int num_hypotheses, RigidTransformSpace& transform_space, HypothesisOctree& grouped_hypotheses) const;
+        # inline void testHypothesis (Hypothesis* hypothesis, int& match, int& penalty) const;
+        # inline void testHypothesisNormalBased (Hypothesis* hypothesis, float& match) const;
+        # void buildGraphOfCloseHypotheses (HypothesisOctree& hypotheses, ORRGraph<Hypothesis>& graph) const;
+        # void filterGraphOfCloseHypotheses (ORRGraph<Hypothesis>& graph, std::vector<Hypothesis>& out) const;
+        # void buildGraphOfConflictingHypotheses (const BVHH& bvh, ORRGraph<Hypothesis*>& graph) const;
+        # void filterGraphOfConflictingHypotheses (ORRGraph<Hypothesis*>& graph, std::list<ObjRecRANSAC::Output>& recognized_objects) const;
+		# 
+        # /** \brief Computes the rigid transform that maps the line (a1, b1) to (a2, b2).
+        #  * The computation is based on the corresponding points 'a1' <-> 'a2' and 'b1' <-> 'b2'
+        #  * and the normals 'a1_n', 'b1_n', 'a2_n', and 'b2_n'. The result is saved in
+        #  * 'rigid_transform' which is an array of length 12. The first 9 elements are the
+        #  * rotational part (row major order) and the last 3 are the translation. */
+        # inline void computeRigidTransform(
+        #   const float *a1, const float *a1_n, const float *b1, const float* b1_n,
+        #   const float *a2, const float *a2_n, const float *b2, const float* b2_n,
+        #   float* rigid_transform) const
+		# 
+        # /** \brief Computes the signature of the oriented point pair ((p1, n1), (p2, n2)) consisting of the angles between
+        #   * \param p1
+        #   * \param n1
+        #   * \param p2
+        #   * \param n2
+        #   * \param[out] signature is an array of three doubles saving the three angles in the order shown above. */
+        # static inline void compute_oriented_point_pair_signature (const float *p1, const float *n1, const float *p2, const float *n2, float signature[3])
+
+
+###
+
+# orr_graph.h
+# #include <pcl/recognition/ransac_based/orr_graph.h>
+# #error "Using pcl/recognition/orr_graph.h is deprecated, please use pcl/recognition/ransac_based/orr_graph.h instead."
+# namespace pcl
+# namespace recognition
+# template<class NodeData>
+# class ORRGraph
+		# public:
+        # class Node
+        	# public:
+            # enum State {ON, OFF, UNDEF};
+			# 
+            # Node (int id)
+            # : id_ (id),
+            #   state_(UNDEF)
+            # virtual ~Node (){}
+			# inline const std::set<Node*>& getNeighbors () const
+            # inline const NodeData& getData () const
+            # inline void setData (const NodeData& data)
+            # inline int getId () const
+            # inline void setId (int id)
+            # inline void setFitness (int fitness)
+            # static inline bool compare (const Node* a, const Node* b)
+            # friend class ORRGraph;
+		# public:
+        # ORRGraph (){}
+        # virtual ~ORRGraph (){ this->clear ();}
+		# inline void clear ()
+		# 
+        # /** \brief Drops all existing graph nodes and creates 'n' new ones. */
+        # inline void resize (int n)
+        # inline void computeMaximalOnOffPartition (std::list<Node*>& on_nodes, std::list<Node*>& off_nodes)
+        # inline void insertUndirectedEdge (int id1, int id2)
+        # inline void insertDirectedEdge (int id1, int id2)
+        # inline void deleteUndirectedEdge (int id1, int id2)
+        # inline void deleteDirectedEdge (int id1, int id2)
+        # inline typename std::vector<Node*>& getNodes (){ return nodes_;}
+		# 
+      	# public:
+        # typename std::vector<Node*> nodes_;
+
+
+###
+
+# orr_octree.h
+# #include <pcl/recognition/ransac_based/orr_octree.h>
+# #error "Using pcl/recognition/orr_octree.h is deprecated, please use pcl/recognition/ransac_based/orr_octree.h instead."
+# namespace pcl
+# namespace recognition
+    # /** \brief That's a very specialized and simple octree class. That's the way it is intended to
+    #   * be, that's why no templates and stuff like this.
+    #   *
+    #   * \author Chavdar Papazov
+    #   * \ingroup recognition
+    #   */
+    # class PCL_EXPORTS ORROctree
+    	# public:
+        # typedef pcl::PointCloud<pcl::PointXYZ> PointCloudIn;
+        # typedef pcl::PointCloud<pcl::PointXYZ> PointCloudOut;
+        # typedef pcl::PointCloud<pcl::Normal> PointCloudN;
+		# 
+        # class Node
+        	# public:
+            # class Data
+            	# public:
+                # Data (int id_x, int id_y, int id_z, int lin_id, void* user_data = NULL) 
+                # : id_x_ (id_x), id_y_ (id_y), id_z_ (id_z), lin_id_ (lin_id), num_points_ (0), user_data_ (user_data)
+                # virtual~ Data (){}
+				# 
+                # inline void addToPoint (float x, float y, float z)
+                # inline void computeAveragePoint ()
+                # inline void addToNormal (float x, float y, float z) { n_[0] += x; n_[1] += y; n_[2] += z;}
+                # inline const float* getPoint () const { return p_;}
+                # inline float* getPoint (){ return p_;}
+                # inline const float* getNormal () const { return n_;}
+                # inline float* getNormal (){ return n_;}
+                # inline void get3dId (int id[3]) const
+                # inline int get3dIdX () const {return id_x_;}
+                # inline int get3dIdY () const {return id_y_;}
+                # inline int get3dIdZ () const {return id_z_;}
+                # inline int getLinearId () const { return lin_id_;}
+                # inline void setUserData (void* user_data){ user_data_ = user_data;}
+                # inline void* getUserData () const { return user_data_;}
+                # inline void insertNeighbor (Node* node){ neighbors_.insert (node);}
+                # inline const std::set<Node*>& getNeighbors () const { return (neighbors_);}
+
+            # Node ()
+            # : data_ (NULL),
+            #   parent_ (NULL),
+            #   children_(NULL)
+            # virtual~ Node ()
+            # 
+            # inline void setCenter(const float *c) { center_[0] = c[0]; center_[1] = c[1]; center_[2] = c[2];}
+			# 
+            # inline void setBounds(const float *b) { bounds_[0] = b[0]; bounds_[1] = b[1]; bounds_[2] = b[2]; bounds_[3] = b[3]; bounds_[4] = b[4]; bounds_[5] = b[5];}
+            # inline void setParent(Node* parent) { parent_ = parent;}
+            # inline void setData(Node::Data* data) { data_ = data;}
+            # /** \brief Computes the "radius" of the node which is half the diagonal length. */
+            # inline void computeRadius()
+            # inline const float* getCenter() const { return center_;}
+            # inline const float* getBounds() const { return bounds_;}
+            # inline void getBounds(float b[6]) const
+            # inline Node* getChild (int id) { return &children_[id];}
+            # inline Node* getChildren () { return children_;}
+            # inline Node::Data* getData (){ return data_;}
+            # inline const Node::Data* getData () const { return data_;}
+            # inline void setUserData (void* user_data){ data_->setUserData (user_data);}
+            # inline Node* getParent (){ return parent_;}
+            # inline bool hasData (){ return static_cast<bool> (data_);}
+            # inline bool hasChildren (){ return static_cast<bool> (children_);}
+            # /** \brief Computes the "radius" of the node which is half the diagonal length. */
+            # inline float getRadius (){ return radius_;}
+            # bool createChildren ();
+			# inline void deleteChildren ()
+			# inline void deleteData ()
+            # 
+            # /** \brief Make this and 'node' neighbors by inserting each node in the others node neighbor set. Nothing happens
+            #   * of either of the nodes has no data. */
+            # inline void makeNeighbors (Node* node)
+		
+		
+        # ORROctree ();
+        # virtual ~ORROctree (){ this->clear ();}
+		# void clear ();
+		# 
+        # /** \brief Creates an octree which encloses 'points' and with leaf size equal to 'voxel_size'.
+        #   * 'enlarge_bounds' makes sure that no points from the input will lie on the octree boundary
+        #   * by enlarging the bounds by that factor. For example, enlarge_bounds = 1 means that the
+        #   * bounds will be enlarged by 100%. The default value is fine. */
+        # void build (const PointCloudIn& points, float voxel_size, const PointCloudN* normals = NULL, float enlarge_bounds = 0.00001f);
+		# 
+        # /** \brief Creates an empty octree with bounds at least as large as the ones provided as input and with leaf
+        #   * size equal to 'voxel_size'. */
+        # void build (const float* bounds, float voxel_size);
+		# 
+        # /** \brief Creates the leaf containing p = (x, y, z) and returns a pointer to it, however, only if p lies within
+        #   * the octree bounds! A more general version which allows p to be out of bounds is not implemented yet. The method
+        #   * returns NULL if p is not within the root bounds. If the leaf containing p already exists nothing happens and
+        #   * method just returns a pointer to the leaf. */
+        # inline ORROctree::Node* createLeaf (float x, float y, float z)
+		# 
+        # /** \brief This method returns a super set of the full leavess which are intersected by the sphere
+        #   * with radius 'radius' and centered at 'p'. Pointers to the intersected full leaves are saved in
+        #   * 'out'. The method computes a super set in the sense that in general not all leaves saved in 'out'
+        #   * are really intersected by the sphere. The intersection test is based on the leaf radius (since
+        #   * its faster than checking all leaf corners and sides), so we report more leaves than we should,
+        #   * but still, this is a fair approximation. */
+        # void getFullLeavesIntersectedBySphere (const float* p, float radius, std::list<ORROctree::Node*>& out) const;
+		# 
+        # /** \brief Randomly chooses and returns a full leaf that is intersected by the sphere with center 'p'
+        #   * and 'radius'. Returns NULL if no leaf is intersected by that sphere. */
+        # ORROctree::Node* getRandomFullLeafOnSphere (const float* p, float radius) const;
+		# 
+        # /** \brief Since the leaves are aligned in a rectilinear grid, each leaf has a unique id. The method returns the leaf
+        #   * with id [i, j, k] or NULL is no such leaf exists. */
+        # ORROctree::Node* getLeaf (int i, int j, int k)
+		# 
+        # /** \brief Returns a pointer to the leaf containing p = (x, y, z) or NULL if no such leaf exists. */
+        # inline ORROctree::Node* getLeaf (float x, float y, float z)
+        # 
+        # /** \brief Deletes the branch 'node' is part of. */
+        # void deleteBranch (Node* node);
+		# 
+        # /** \brief Returns a vector with all octree leaves which contain at least one point. */
+        # inline std::vector<ORROctree::Node*>& getFullLeaves () { return full_leaves_;}
+        # inline const std::vector<ORROctree::Node*>& getFullLeaves () const { return full_leaves_;}
+        # void getFullLeavesPoints (PointCloudOut& out) const;
+        # void getNormalsOfFullLeaves (PointCloudN& out) const;
+        # inline ORROctree::Node* getRoot (){ return root_;}
+        # inline const float* getBounds () const
+        # inline void getBounds (float b[6]) const
+        # inline float getVoxelSize () const { return voxel_size_;}
+        # inline void insertNeighbors (Node* node)
+
+
+###
+
+# orr_octree_zprojection.h
+# #include <pcl/recognition/ransac_based/orr_octree_zprojection.h>
+# #error "Using pcl/recognition/orr_octree_zprojection.h is deprecated, please use pcl/recognition/ransac_based/orr_octree_zprojection.h instead."
+# namespace pcl
+# namespace recognition
+	# class ORROctree;
+    # class PCL_EXPORTS ORROctreeZProjection
+    	# public:
+        # class Pixel
+        	# public:
+            # Pixel (int id): id_ (id) {}
+            # inline void set_z1 (float z1) { z1_ = z1;}
+            # inline void set_z2 (float z2) { z2_ = z2;}
+            # float z1 () const { return z1_;}
+            # float z2 () const { return z2_;}
+            # int getId () const { return id_;}
+
+          	# protected:
+            # float z1_, z2_;
+            # int id_;
+
+    	# public:
+        # class Set
+        	# public:
+            # Set (int x, int y) : nodes_ (compare_nodes_z), x_ (x), y_ (y)
+			# 
+            # static inline bool compare_nodes_z (ORROctree::Node* node1, ORROctree::Node* node2)
+			# inline void insert (ORROctree::Node* leaf) { nodes_.insert(leaf);}
+			# inline std::set<ORROctree::Node*, bool(*)(ORROctree::Node*,ORROctree::Node*)>& get_nodes (){ return nodes_;}
+			# inline int get_x () const { return x_;}
+			# inline int get_y () const { return y_;}
+
+      	# public:
+        # ORROctreeZProjection () : pixels_(NULL), sets_(NULL)
+        # virtual ~ORROctreeZProjection (){ this->clear();}
+		# void build (const ORROctree& input, float eps_front, float eps_back);
+		# void clear ();
+        # inline void getPixelCoordinates (const float* p, int& x, int& y) const
+		# inline const Pixel* getPixel (const float* p) const
+		# inline Pixel* getPixel (const float* p)
+		# inline const std::set<ORROctree::Node*, bool(*)(ORROctree::Node*,ORROctree::Node*)>* getOctreeNodes (const float* p) const
+		# 
+        # inline std::list<Pixel*>& getFullPixels (){ return full_pixels_;}
+        # inline const Pixel* getPixel (int i, int j) const
+        # inline float getPixelSize () const
+        # inline const float* getBounds () const
+        # /** \brief Get the width ('num_x') and height ('num_y') of the image. */
+        # inline void getNumberOfPixels (int& num_x, int& num_y) const
+
+
+###
+
+# point_types.h
+# namespace pcl
+# /** \brief A point structure representing Euclidean xyz coordinates, and the intensity value.
+# * \ingroup common
+# */
+# struct EIGEN_ALIGN16 GradientXY
+    # union
+    # {
+    	# struct
+      	# {
+	    #     float x;
+        # 	float y;
+        # 	float angle;
+        # 	float magnitude;
+      	# };
+      	# float data[4];
+    # };
+    # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+	# 
+    # inline bool operator< (const GradientXY & rhs)
+	# 
+	# inline std::ostream & operator << (std::ostream & os, const GradientXY & p)
+
+###
+
+# quantized_map.h
+# namespace pcl
+	# class PCL_EXPORTS QuantizedMap
+  	# {
+    	# public:
+      	# QuantizedMap ();
+      	# QuantizedMap (size_t width, size_t height);
+      	# QuantizedMap (const QuantizedMap & copy_me);
+      	# virtual ~QuantizedMap ();
+		# 
+      	# inline size_t getWidth () const { return (width_); }
+      	# inline size_t getHeight () const { return (height_); }
+      	# inline unsigned char* getData () { return (&data_[0]); }
+		# inline const unsigned char* getData () const { return (&data_[0]); }
+		# inline QuantizedMap getSubMap (
+		# 		size_t x,
+        #         size_t y,
+        #         size_t width,
+        #         size_t height)
+		# 
+      	# void resize (size_t width, size_t height);
+		# 
+      	# inline unsigned char & operator() (const size_t x, const size_t y) 
+	    # inline const unsigned char &operator() (const size_t x, const size_t y) const
+		# 
+      	# static void spreadQuantizedMap (const QuantizedMap & input_map, QuantizedMap & output_map, size_t spreading_size);
+		# 
+      	# void serialize (std::ostream & stream) const
+		# 
+      	# void deserialize (std::istream & stream)
+    	# //private:
+      	# std::vector<unsigned char> data_;
+      	# size_t width_;
+      	# size_t height_;  
+
+###
+
+# region_xy.h
+# namespace pcl
+    # /** \brief Function for reading data from a stream. */
+    # template <class Type> void read (std::istream & stream, Type & value)
+	# 
+  	# /** \brief Function for reading data arrays from a stream. */
+  	# template <class Type> void read (std::istream & stream, Type * value, int nr_values)
+  	# 
+  	# /** \brief Function for writing data to a stream. */
+  	# template <class Type> void write (std::ostream & stream, Type value)
+	# 
+  	# /** \brief Function for writing data arrays to a stream. */
+  	# template <class Type> void write (std::ostream & stream, Type * value, int nr_values)
+	# 
+  	# /** \brief Defines a region in XY-space.
+    #  * \author Stefan Holzer
+    #  */
+  	# struct PCL_EXPORTS RegionXY
+    # 	/** \brief Constructor. */
+    # 	RegionXY () : x (0), y (0), width (0), height (0) {}
+	# 	
+    # 	/** \brief x-position of the region. */
+    # 	int x;
+    # 	/** \brief y-position of the region. */
+    # 	int y;
+    # 	/** \brief width of the region. */
+    # 	int width;
+    # 	/** \brief height of the region. */
+    # 	int height;
+	# 	/** \brief Serializes the object to the specified stream.
+    #    * \param[out] stream the stream the object will be serialized to. */
+    # 	void serialize (std::ostream & stream) const
+	# 	
+    # 	/** \brief Deserializes the object from the specified stream.
+    #    * \param[in] stream the stream the object will be deserialized from. */
+    # 	void deserialize (::std::istream & stream)
+
+###
+
+# rigid_transform_space.h
+# namespace pcl
+# namespace recognition
+# class RotationSpaceCell
+		# public:
+        # class Entry
+        # {
+        # 	public:
+        #     Entry () : num_transforms_ (0)
+        #     Entry (const Entry& src) : num_transforms_ (src.num_transforms_)
+        #     const Entry& operator = (const Entry& src)
+        #     inline const Entry& addRigidTransform (const float axis_angle[3], const float translation[3])
+        #     inline void computeAverageRigidTransform (float *rigid_transform = NULL)
+        #     inline const float* getAxisAngle () const
+        #     inline const float* getTranslation () const
+        #     inline int getNumberOfTransforms () const
+        # };// class Entry
+		# 
+		# 
+      	# public:
+        # RotationSpaceCell (){}
+        # virtual ~RotationSpaceCell ()
+        # 
+        # inline std::map<const ModelLibrary::Model*,Entry>& getEntries ()
+		# 
+        # inline const RotationSpaceCell::Entry* getEntry (const ModelLibrary::Model* model) const
+		# 
+        # inline const RotationSpaceCell::Entry& addRigidTransform (const ModelLibrary::Model* model, const float axis_angle[3], const float translation[3])
+    # }; // class RotationSpaceCell
+	# 
+    # class RotationSpaceCellCreator
+    # {
+    #   public:
+    #     RotationSpaceCellCreator (){}
+    #     virtual ~RotationSpaceCellCreator (){}
+	# 
+    #     RotationSpaceCell* create (const SimpleOctree<RotationSpaceCell, RotationSpaceCellCreator, float>::Node* )
+    #     {
+    #       return (new RotationSpaceCell ());
+    #     }
+    # };
+	# 
+    # typedef SimpleOctree<RotationSpaceCell, RotationSpaceCellCreator, float> CellOctree;
+	# 
+	# 
+    # /** \brief This is a class for a discrete representation of the rotation space based on the axis-angle representation.
+    #   * This class is not supposed to be very general. That's why it is dependent on the class ModelLibrary.
+    #   * \author Chavdar Papazov
+    #   * \ingroup recognition
+    #   */
+    # class PCL_EXPORTS RotationSpace
+    # {
+    	# public:
+        # /** \brief We use the axis-angle representation for rotations. The axis is encoded in the vector
+        #   * and the angle is its magnitude. This is represented in an octree with bounds [-pi, pi]^3. */
+        # RotationSpace (float discretization)
+        # 
+        # inline void setCenter (const float* c)
+        # inline const float* getCenter () const { return center_;}
+        # inline bool getTransformWithMostVotes (const ModelLibrary::Model* model, float rigid_transform[12]) const
+        # inline bool addRigidTransform (const ModelLibrary::Model* model, const float axis_angle[3], const float translation[3])
+    # };// class RotationSpace
+	
+    # class RotationSpaceCreator
+    	# public:
+        # RotationSpaceCreator() : counter_ (0)
+        # virtual ~RotationSpaceCreator(){}
+        # RotationSpace* create(const SimpleOctree<RotationSpace, RotationSpaceCreator, float>::Node* leaf)
+        # void setDiscretization (float value){ discretization_ = value;}
+        # int getNumberOfRotationSpaces () const { return (counter_);}
+        # const std::list<RotationSpace*>& getRotationSpaces () const { return (rotation_spaces_);}
+		# 
+        # std::list<RotationSpace*>& getRotationSpaces (){ return (rotation_spaces_);}
+		# 
+        # void reset ()
+	# 
+    # typedef SimpleOctree<RotationSpace, RotationSpaceCreator, float> RotationSpaceOctree;
+
+    # class PCL_EXPORTS RigidTransformSpace
+    	# public:
+        # RigidTransformSpace (){}
+        # virtual ~RigidTransformSpace (){ this->clear ();}
+        inline void build (const float* pos_bounds, float translation_cell_size, float rotation_cell_size)
+        inline void clear ()
+        inline std::list<RotationSpace*>& getRotationSpaces ()
+        inline const std::list<RotationSpace*>& getRotationSpaces () const
+        inline int getNumberOfOccupiedRotationSpaces ()
+        inline bool addRigidTransform (const ModelLibrary::Model* model, const float position[3], const float rigid_transform[12])
+
+###
+
+# simple_octree.h
+# namespace pcl
+# namespace recognition
+# template<typename NodeData, typename NodeDataCreator, typename Scalar = float>
+# class PCL_EXPORTS SimpleOctree
+	# public:
+    #     class Node
+    #     	public:
+    #         Node ();
+	# 		virtual~ Node ();
+    #         inline void setCenter (const Scalar *c);
+    #         inline void setBounds (const Scalar *b);
+    #         inline const Scalar* getCenter () const { return center_;}
+    #         inline const Scalar* getBounds () const { return bounds_;}
+    #         inline void getBounds (Scalar b[6]) const { memcpy (b, bounds_, 6*sizeof (Scalar));}
+    #         inline Node* getChild (int id) { return &children_[id];}
+    #         inline Node* getChildren () { return children_;}
+    #         inline void setData (const NodeData& src){ *data_ = src;}
+    #         inline NodeData& getData (){ return *data_;}
+    #         inline const NodeData& getData () const { return *data_;}
+    #         inline Node* getParent (){ return parent_;}
+    #         inline float getRadius () const { return radius_;}
+    #         inline bool hasData (){ return static_cast<bool> (data_);}
+    #         inline bool hasChildren (){ return static_cast<bool> (children_);}
+    #         inline const std::set<Node*>& getNeighbors () const { return (full_leaf_neighbors_);}
+    #         inline void deleteChildren ();
+    #         inline void deleteData ();
+    #         friend class SimpleOctree;
+    #     };
+    # 
+    # 
+    	# SimpleOctree ();
+    	# virtual ~SimpleOctree ();
+        # void clear ();
+		# 
+        # /** \brief Creates an empty octree with bounds at least as large as the ones provided as input and with leaf
+        #   * size equal to 'voxel_size'. */
+        # void build (const Scalar* bounds, Scalar voxel_size, NodeDataCreator* node_data_creator);
+		# 
+        # /** \brief Creates the leaf containing p = (x, y, z) and returns a pointer to it, however, only if p lies within
+        #   * the octree bounds! A more general version which allows p to be out of bounds is not implemented yet. The method
+        #   * returns NULL if p is not within the root bounds. If the leaf containing p already exists nothing happens and
+        #   * method just returns a pointer to the leaf. Note that for a new created leaf, the method also creates its data
+        #   * object. */
+        # inline Node* createLeaf (Scalar x, Scalar y, Scalar z);
+		# 
+        # /** \brief Since the leaves are aligned in a rectilinear grid, each leaf has a unique id. The method returns the full
+        #   * leaf, i.e., the one having a data object, with id [i, j, k] or NULL is no such leaf exists. */
+        # inline Node* getFullLeaf (int i, int j, int k);
+		# 
+        # /** \brief Returns a pointer to the full leaf, i.e., one having a data pbject, containing p = (x, y, z) or NULL if no such leaf exists. */
+        # inline Node* getFullLeaf (Scalar x, Scalar y, Scalar z);
+		# 
+        # inline std::vector<Node*>& getFullLeaves () { return full_leaves_;}
+		# 
+        # inline const std::vector<Node*>& getFullLeaves () const { return full_leaves_;}
+		# 
+        # inline Node* getRoot (){ return root_;}
+		# 
+        # inline const Scalar* getBounds () const { return (bounds_);}
+		# 
+        # inline void getBounds (Scalar b[6]) const { memcpy (b, bounds_, 6*sizeof (Scalar));}
+		# 
+        # inline Scalar getVoxelSize () const { return voxel_size_;}
+		
+###
+
+# sparse_quantized_multi_mod_template.h
+# namespace pcl
+# 
+# /** \brief Feature that defines a position and quantized value in a specific modality. 
+# * \author Stefan Holzer
+# */
+# struct QuantizedMultiModFeature
+    # /** \brief Constructor. */
+    # QuantizedMultiModFeature () : x (0), y (0), modality_index (0), quantized_value (0) {}
+	# 
+    # /** \brief x-position. */
+    # int x;
+    # /** \brief y-position. */
+    # int y;
+    # /** \brief the index of the corresponding modality. */
+    # size_t modality_index;
+    # /** \brief the quantized value attached to the feature. */
+    # unsigned char quantized_value;
+	# 
+    # /** \brief Compares whether two features are the same. 
+    #   * \param[in] base the feature to compare to.
+    #   */
+    # bool compareForEquality (const QuantizedMultiModFeature & base)
+    # 
+    # /** \brief Serializes the object to the specified stream.
+    #   * \param[out] stream the stream the object will be serialized to. */
+    # void serialize (std::ostream & stream) const
+    # 
+    # /** \brief Deserializes the object from the specified stream.
+    #   * \param[in] stream the stream the object will be deserialized from. */
+    # void deserialize (std::istream & stream)
+    # 
+  	# /** \brief A multi-modality template constructed from a set of quantized multi-modality features.
+    #  * \author Stefan Holzer 
+    #  */
+  	# struct SparseQuantizedMultiModTemplate
+  		# /** \brief Constructor. */
+    	# SparseQuantizedMultiModTemplate () : features (), region () {}
+		# 
+    	# /** \brief The storage for the multi-modality features. */
+    	# std::vector<QuantizedMultiModFeature> features;
+		# 
+    	# /** \brief The region assigned to the template. */
+    	# RegionXY region;
+		# 
+    	# /** \brief Serializes the object to the specified stream.
+      	#  * \param[out] stream the stream the object will be serialized to. */
+    	# void serialize (std::ostream & stream) const
+    	# 
+    	# /** \brief Deserializes the object from the specified stream.
+      	#  * \param[in] stream the stream the object will be deserialized from. */
+    	# void deserialize (std::istream & stream)
+
+
+###
+
+# surface_normal_modality.h
+# namespace pcl
+# /** \brief Map that stores orientations.
+#  * \author Stefan Holzer
+#  */
+# struct PCL_EXPORTS LINEMOD_OrientationMap
+    	# public:
+      	# /** \brief Constructor. */
+      	# inline LINEMOD_OrientationMap () : width_ (0), height_ (0), map_ () {}
+      	# /** \brief Destructor. */
+      	# inline ~LINEMOD_OrientationMap () {}
+		# 
+      	# /** \brief Returns the width of the modality data map. */
+      	# inline size_t getWidth () const
+		# 
+      	# /** \brief Returns the height of the modality data map. */
+      	# inline size_t getHeight () const
+		# 
+      	# /** \brief Resizes the map to the specific width and height and initializes 
+        # 	*        all new elements with the specified value.
+        # 	* \param[in] width the width of the resized map.
+        # 	* \param[in] height the height of the resized map.
+        # 	* \param[in] value the value all new elements will be initialized with.
+        # */
+      	# inline void resize (const size_t width, const size_t height, const float value)
+		# 
+      	# /** \brief Operator to access elements of the map. 
+        # 	* \param[in] col_index the column index of the element to access.
+        # 	* \param[in] row_index the row index of the element to access.
+        # */
+      	# inline float & operator() (const size_t col_index, const size_t row_index)
+		# 
+      	# /** \brief Operator to access elements of the map. 
+        # 	* \param[in] col_index the column index of the element to access.
+        # 	* \param[in] row_index the row index of the element to access.
+        # */
+      	# inline const float &operator() (const size_t col_index, const size_t row_index) const
+		# 
+		# /** \brief Look-up-table for fast surface normal quantization.
+		# * \author Stefan Holzer
+		# */
+		# struct QuantizedNormalLookUpTable
+		# {
+		#     /** \brief The range of the LUT in x-direction. */
+		#     int range_x;
+		#     /** \brief The range of the LUT in y-direction. */
+		#     int range_y;
+		#     /** \brief The range of the LUT in z-direction. */
+		#     int range_z;
+		# 
+		#     /** \brief The offset in x-direction. */
+		#     int offset_x;
+		#     /** \brief The offset in y-direction. */
+		#     int offset_y;
+		#     /** \brief The offset in z-direction. */
+		#     int offset_z;
+		# 
+		#     /** \brief The size of the LUT in x-direction. */
+		#     int size_x;
+		#     /** \brief The size of the LUT in y-direction. */
+		#     int size_y;
+		#     /** \brief The size of the LUT in z-direction. */
+		#     int size_z;
+		# 
+		#     /** \brief The LUT data. */
+		#     unsigned char * lut;
+		# 
+		#     /** \brief Constructor. */
+		#     QuantizedNormalLookUpTable () : 
+		#       range_x (-1), range_y (-1), range_z (-1), 
+		#       offset_x (-1), offset_y (-1), offset_z (-1), 
+		#       size_x (-1), size_y (-1), size_z (-1), lut (NULL) 
+		#     {}
+		# 
+		#     /** \brief Destructor. */
+		#     ~QuantizedNormalLookUpTable () 
+		#     { 
+		#       if (lut != NULL) 
+		#         delete[] lut; 
+		#     }
+		# 
+    	# /** \brief Initializes the LUT.
+      	# * \param[in] range_x_arg the range of the LUT in x-direction.
+      	# * \param[in] range_y_arg the range of the LUT in y-direction.
+      	# * \param[in] range_z_arg the range of the LUT in z-direction.
+      	# */
+    	# void initializeLUT (const int range_x_arg, const int range_y_arg, const int range_z_arg)
+		# 
+    	# /** \brief Operator to access an element in the LUT.
+      	# * \param[in] x the x-component of the normal.
+      	# * \param[in] y the y-component of the normal.
+      	# * \param[in] z the z-component of the normal. 
+      	# */
+    	# inline unsigned char operator() (const float x, const float y, const float z) const
+		# 
+    	# /** \brief Operator to access an element in the LUT.
+      	# * \param[in] index the index of the element. 
+      	# */
+    	# inline unsigned char operator() (const int index) const
+
+
+# /** \brief Modality based on surface normals.
+# * \author Stefan Holzer
+# */
+# template <typename PointInT>
+# class SurfaceNormalModality : public QuantizableModality, public PCLBase<PointInT>
+        # protected:
+        # using PCLBase<PointInT>::input_;
+        # 
+        # /** \brief Candidate for a feature (used in feature extraction methods). */
+        # struct Candidate
+        #     /** \brief Constructor. */
+        #   Candidate () : normal (), distance (0.0f), bin_index (0), x (0), y (0) {}
+        #   
+        #   /** \brief Normal. */
+        #   Normal normal;
+        #   /** \brief Distance to the next different quantized value. */
+        #   float distance;
+        #   
+        #   /** \brief Quantized value. */
+        #   unsigned char bin_index;
+        #     
+        #   /** \brief x-position of the feature. */
+        #   size_t x;
+        #   /** \brief y-position of the feature. */
+        #   size_t y;   
+        #   /** \brief Compares two candidates based on their distance to the next different quantized value. 
+        #       * \param[in] rhs the candidate to compare with. 
+        #       */
+        #   bool operator< (const Candidate & rhs) const
+        # 
+        # public:
+        #   typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # 
+        # /** \brief Constructor. */
+        # SurfaceNormalModality ();
+        # /** \brief Destructor. */
+        # virtual ~SurfaceNormalModality ();
+        # 
+        # /** \brief Sets the spreading size.
+        #  * \param[in] spreading_size the spreading size.
+        #  */
+        # inline void setSpreadingSize (const size_t spreading_size)
+        # 
+        # /** \brief Enables/disables the use of extracting a variable number of features.
+        #  * \param[in] enabled specifies whether extraction of a variable number of features will be enabled/disabled.
+        #  */
+        # inline void setVariableFeatureNr (const bool enabled)
+        # 
+        # /** \brief Returns the surface normals. */
+        # inline pcl::PointCloud<pcl::Normal> &getSurfaceNormals ()
+        # 
+        # /** \brief Returns the surface normals. */
+        # inline const pcl::PointCloud<pcl::Normal> &getSurfaceNormals () const
+        # 
+        # /** \brief Returns a reference to the internal quantized map. */
+        # inline QuantizedMap &getQuantizedMap () 
+        # 
+        # /** \brief Returns a reference to the internal spreaded quantized map. */
+        # inline QuantizedMap &getSpreadedQuantizedMap () 
+        # 
+        # /** \brief Returns a reference to the orientation map. */
+        # inline LINEMOD_OrientationMap &getOrientationMap ()
+        # 
+        # /** \brief Extracts features from this modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features defines the number of features to be extracted 
+        #   *            (might be less if not sufficient information is present in the modality).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # void extractFeatures (
+        #           const MaskMap & mask, size_t nr_features, size_t modality_index,
+        #             std::vector<QuantizedMultiModFeature> & features) const;
+        # 
+        # /** \brief Extracts all possible features from the modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features IGNORED (TODO: remove this parameter).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # void extractAllFeatures (
+        #           const MaskMap & mask, size_t nr_features, size_t modality_index,
+        #             std::vector<QuantizedMultiModFeature> & features) const;
+        # 
+        # /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        #  * \param[in] cloud the const boost shared pointer to a PointCloud message
+        #  */
+        # virtual void setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+        # 
+        # /** \brief Processes the input data (smoothing, computing gradients, quantizing, filtering, spreading). */
+        # virtual void processInputData ();
+        # 
+        # /** \brief Processes the input data assuming that everything up to filtering is already done/available 
+        #  *        (so only spreading is performed). */
+        # virtual void processInputDataFromFiltered ();
+
+
+# template <typename PointInT> pcl::SurfaceNormalModality<PointInT>::SurfaceNormalModality ()
+
+# template <typename PointInT> pcl::SurfaceNormalModality<PointInT>::~SurfaceNormalModality ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::processInputData ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::processInputDataFromFiltered ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::computeSurfaceNormals ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::computeAndQuantizeSurfaceNormals ()
+
+# static void accumBilateral(long delta, long i, long j, long * A, long * b, int threshold)
+
+# /**
+#  * \brief Compute quantized normal image from depth image.
+#  * Implements section 2.6 "Extension to Dense Depth Sensors."
+#  * \todo Should also need camera model, or at least focal lengths? Replace distance_threshold with mask?
+#  */
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::computeAndQuantizeSurfaceNormals2 ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::extractFeatures (const MaskMap & mask,
+#                                                        const size_t nr_features,
+#                                                        const size_t modality_index,
+#                                                        std::vector<QuantizedMultiModFeature> & features) const
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::extractAllFeatures (
+#     	const MaskMap & mask, const size_t, const size_t modality_index, std::vector<QuantizedMultiModFeature> & features) const
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::quantizeSurfaceNormals ()
+
+# pcl::SurfaceNormalModality<PointInT>::filterQuantizedSurfaceNormals ()
+
+# template <typename PointInT> void
+# pcl::SurfaceNormalModality<PointInT>::computeDistanceMap (const MaskMap & input, DistanceMap & output) const
+
+
+# trimmed_icp.h
+# namespace pcl
+# namespace recognition
+# template<typename PointT, typename Scalar>
+# class PCL_EXPORTS TrimmedICP : public pcl::registration::TransformationEstimationSVD<PointT, PointT, Scalar>
+# {
+cdef extern from "pcl/Recognition/trimmed_icp.h" namespace "pcl::registration":
+    cdef cppclass TrimmedICP[PointT, Scalar](pcl::registration::TransformationEstimationSVD[PointT, PointT, Scalar])
+        TrimmedICP ()
+      	# public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename Eigen::Matrix<Scalar, 4, 4> Matrix4;
+      	# public:
+        # TrimmedICP () : new_to_old_energy_ratio_ (0.99f)
+		# 
+        # /** \brief Call this method before calling align().
+        #   * \param[in] target is target point cloud. The method builds a kd-tree based on 'target' for performing fast closest point search.
+        #   *            The source point cloud will be registered to 'target' (see align() method).
+        #   * */
+        # inline void init (const PointCloudConstPtr& target)
+		# 
+        # /** \brief The method performs trimmed ICP, i.e., it rigidly registers the source to the target (passed to the init() method).
+        #   * \param[in] source_points is the point cloud to be registered to the target.
+        #   * \param[in] num_source_points_to_use gives the number of closest source points taken into account for registration. By closest
+        #   * source points we mean the source points closest to the target. These points are computed anew at each iteration.
+        #   * \param[in,out] guess_and_result is the estimated rigid transform. IMPORTANT: this matrix is also taken as the initial guess
+        #   * for the alignment. If there is no guess, set the matrix to identity!
+        #   * */
+        # inline void align (const PointCloud& source_points, int num_source_points_to_use, Matrix4& guess_and_result) const
+		# 
+        # inline void setNewToOldEnergyRatio (float ratio)
+
+#endif /* TRIMMED_ICP_H_ */
+###
+
+# voxel_structure.h
+# namespace pcl
+# namespace recognition
+# 
+# /** \brief This class is a box in R3 built of voxels ordered in a regular rectangular grid. Each voxel is of type T. */
+# template<class T, typename REAL = float>
+# class VoxelStructure
+cdef extern from "pcl/Recognition/voxel_structure.h" namespace "pcl::recognition":
+    cdef cppclass VoxelStructure[T, float]
+        VoxelStructure ()
+        # public:
+        # inline VoxelStructure (): voxels_(NULL){}
+        # inline virtual ~VoxelStructure (){ this->clear();}
+        # 
+        # /** \brief Call this method before using an instance of this class. Parameter meaning is obvious. */
+        # inline void build (const REAL bounds[6], int num_of_voxels[3]);
+        # 
+        # /** \brief Release the memory allocated for the voxels. */
+        # inline void clear (){ if ( voxels_ ){ delete[] voxels_; voxels_ = NULL;}}
+        # 
+        # /** \brief Returns a pointer to the voxel which contains p or NULL if p is not inside the structure. */
+        # inline T* getVoxel (const REAL p[3]);
+        # 
+        # /** \brief Returns a pointer to the voxel with integer id (x,y,z) or NULL if (x,y,z) is out of bounds. */
+        # inline T* getVoxel (int x, int y, int z) const;
+        # 
+        # /** \brief Returns the linear voxel array. */
+        # const inline T* getVoxels () const
+        # 
+        # /** \brief Returns the linear voxel array. */
+        # inline T* getVoxels ()
+        # 
+        # /** \brief Converts a linear id to a 3D id, i.e., computes the integer 3D coordinates of a voxel from its position in the voxel array.
+        #     *
+        #     * \param[in]  linear_id the position of the voxel in the internal voxel array.
+        #     * \param[out] id3d an array of 3 integers for the integer coordinates of the voxel. */
+        # inline void compute3dId (int linear_id, int id3d[3]) const
+        # 
+        # /** \brief Returns the number of voxels in x, y and z direction. */
+        # inline const int* getNumberOfVoxelsXYZ() const
+		# 
+        # /** \brief Computes the center of the voxel with given integer coordinates.
+        #     *
+        #     * \param[in]  id3 the integer coordinates along the x, y and z axis.
+        #     * \param[out] center */
+        # inline void computeVoxelCenter (const int id3[3], REAL center[3]) const
+		# 
+        # /** \brief Returns the total number of voxels. */
+        # inline int getNumberOfVoxels() const
+		# 
+        # /** \brief Returns the bounds of the voxel structure, which is pointer to the internal array of 6 doubles: (min_x, max_x, min_y, max_y, min_z, max_z). */
+        # inline const float* getBounds() const
+		# 
+        # /** \brief Copies the bounds of the voxel structure to 'b'. */
+        # inline void getBounds(REAL b[6]) const
+		# 
+        # /** \brief Returns the voxel spacing in x, y and z direction. That's the same as the voxel size along each axis. */
+        # const REAL* getVoxelSpacing() const
+		# 
+        # /** \brief Saves pointers to the voxels which are neighbors of the voxels which contains 'p'. The containing voxel is returned too.
+        #     * 'neighs' has to be an array of pointers with space for at least 27 pointers (27 = 3^3 which is the max number of neighbors). The */
+        # inline int getNeighbors (const REAL* p, T **neighs) const;
+
+###
diff --git a/pcl/pcl_Recognition_180.pxd b/pcl/pcl_Recognition_180.pxd
new file mode 100644
index 0000000..a205b9a
--- /dev/null
+++ b/pcl/pcl_Recognition_180.pxd
@@ -0,0 +1,5192 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# quantizable_modality.h
+# namespace pcl
+# {
+# /** \brief Interface for a quantizable modality. 
+#  * \author Stefan Holzer
+#  */
+# class PCL_EXPORTS QuantizableModality
+cdef extern from "pcl/Recognition/quantizable_modality.h" namespace "pcl":
+    cdef cppclass Feature[In, Out](cpp.PCLBase[In]):
+        QuantizableModality ()
+        # /** \brief Destructor. */
+        # virtual ~QuantizableModality ();
+        
+        # /** \brief Returns a reference to the internally computed quantized map. */
+        # virtual QuantizedMap & getQuantizedMap () = 0;
+        
+        # /** \brief Returns a reference to the internally computed spreaded quantized map. */
+        # virtual QuantizedMap & getSpreadedQuantizedMap () = 0;
+        
+        # /** \brief Extracts features from this modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features defines the number of features to be extracted 
+        #   *            (might be less if not sufficient information is present in the modality).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # virtual void extractFeatures (
+        #       const MaskMap & mask, size_t nr_features, size_t modality_index, 
+        #         std::vector<QuantizedMultiModFeature> & features) const = 0;
+        # 
+        # /** \brief Extracts all possible features from the modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features IGNORED (TODO: remove this parameter).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # virtual void  extractAllFeatures (const MaskMap & mask, size_t nr_features, size_t modality_index, 
+        #                                       std::vector<QuantizedMultiModFeature> & features) const = 0;
+
+###
+
+### Inheritance class ###
+
+# auxiliary.h
+# #include <pcl/recognition/ransac_based/auxiliary.h>
+###
+
+# boost.h
+# #include <boost/unordered_map.hpp>
+# #include <boost/graph/graph_traits.hpp>
+###
+
+# bvh.h
+# #include <pcl/recognition/ransac_based/bvh.h>
+###
+
+# color_gradient_dot_modality.h
+# namespace pcl
+# {
+# 
+#   /** \brief A point structure for representing RGB color
+#     * \ingroup common
+#     */
+#   struct EIGEN_ALIGN16 PointRGB
+#   {
+#     union
+#     {
+#       union
+#       {
+#         struct
+#         {
+#           uint8_t b;
+#           uint8_t g;
+#           uint8_t r;
+#           uint8_t _unused;
+#         };
+#         float rgb;
+#       };
+#       uint32_t rgba;
+#     };
+# 
+#     inline PointRGB ()
+#     {}
+# 
+#     inline PointRGB (const uint8_t b, const uint8_t g, const uint8_t r)
+#       : b (b), g (g), r (r), _unused (0)
+#     {}
+# 
+#     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+# 
+#   /** \brief A point structure representing Euclidean xyz coordinates, and the intensity value.
+#     * \ingroup common
+#     */
+#   struct EIGEN_ALIGN16 GradientXY
+#   {
+#     union
+#     {
+#       struct
+#       {
+#         float x;
+#         float y;
+#         float angle;
+#         float magnitude;
+#       };
+#       float data[4];
+#     };
+#     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+# 
+#     inline bool operator< (const GradientXY & rhs)
+#     {
+#       return (magnitude > rhs.magnitude);
+#     }
+#   };
+#   inline std::ostream & operator << (std::ostream & os, const GradientXY & p)
+#   {
+#     os << "(" << p.x << "," << p.y << " - " << p.magnitude << ")";
+#    return (os);
+#   }
+# 
+#   // --------------------------------------------------------------------------
+
+
+#   template <typename PointInT>
+#   class ColorGradientDOTModality : public DOTModality, public PCLBase<PointInT>
+#   {
+#     protected:
+#       using PCLBase<PointInT>::input_;
+# 
+#     struct Candidate
+#     {
+#       GradientXY gradient;
+#     
+#       int x;
+#       int y;  
+#     
+#       bool operator< (const Candidate & rhs)
+#       {
+#         return (gradient.magnitude > rhs.gradient.magnitude);
+#       }
+#     };
+# 
+#     public:
+#       typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+# 
+#       ColorGradientDOTModality (size_t bin_size);
+#   
+#       virtual ~ColorGradientDOTModality ();
+#   
+#       inline void
+#       setGradientMagnitudeThreshold (const float threshold)
+#       {
+#         gradient_magnitude_threshold_ = threshold;
+#       }
+#   
+#       //inline QuantizedMap &
+#       //getDominantQuantizedMap () 
+#       //{ 
+#       //  return (dominant_quantized_color_gradients_);
+#       //}
+#   
+#       inline QuantizedMap &
+#       getDominantQuantizedMap () 
+#       { 
+#         return (dominant_quantized_color_gradients_);
+#       }
+# 
+#       QuantizedMap
+#       computeInvariantQuantizedMap (const MaskMap & mask,
+#                                    const RegionXY & region);
+#   
+#       /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+#         * \param cloud the const boost shared pointer to a PointCloud message
+#         */
+#       virtual void 
+#       setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+#       { 
+#         input_ = cloud;
+#         //processInputData ();
+#       }
+# 
+#       virtual void
+#       processInputData ();
+# 
+#     protected:
+# 
+#       void
+#       computeMaxColorGradients ();
+#   
+#       void
+#       computeDominantQuantizedGradients ();
+#   
+#       //void
+#       //computeInvariantQuantizedGradients ();
+#   
+#     private:
+#       size_t bin_size_;
+# 
+#       float gradient_magnitude_threshold_;
+#       pcl::PointCloud<pcl::GradientXY> color_gradients_;
+#   
+#       pcl::QuantizedMap dominant_quantized_color_gradients_;
+#       //pcl::QuantizedMap invariant_quantized_color_gradients_;
+#   
+#   };
+# 
+# }
+
+# template <typename PointInT>
+# pcl::ColorGradientDOTModality<PointInT>::ColorGradientDOTModality (const size_t bin_size)
+#   : bin_size_ (bin_size), gradient_magnitude_threshold_ (80.0f), color_gradients_ (), dominant_quantized_color_gradients_ ()
+# {
+# }
+# 
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# pcl::ColorGradientDOTModality<PointInT>::
+# ~ColorGradientDOTModality ()
+# {
+# }
+# 
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# void
+# pcl::ColorGradientDOTModality<PointInT>::
+# processInputData ()
+# {
+#   // extract color gradients
+#   computeMaxColorGradients ();
+# 
+#   // compute dominant quantized gradient map
+#   computeDominantQuantizedGradients ();
+# 
+#   // compute invariant quantized gradient map
+#   //computeInvariantQuantizedGradients ();
+# }
+# 
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# void
+# pcl::ColorGradientDOTModality<PointInT>::
+# computeMaxColorGradients ()
+# {
+#   const int width = input_->width;
+#   const int height = input_->height;
+# 
+#   color_gradients_.points.resize (width*height);
+#   color_gradients_.width = width;
+#   color_gradients_.height = height;
+# 
+#   const float pi = tan(1.0f)*4;
+#   for (int row_index = 0; row_index < height-2; ++row_index)
+#   {
+#     for (int col_index = 0; col_index < width-2; ++col_index)
+#     {
+#       const int index0 = row_index*width+col_index;
+#       const int index_c = row_index*width+col_index+2;
+#       const int index_r = (row_index+2)*width+col_index;
+# 
+#       //const int index_d = (row_index+1)*width+col_index+1;
+# 
+#       const unsigned char r0 = input_->points[index0].r;
+#       const unsigned char g0 = input_->points[index0].g;
+#       const unsigned char b0 = input_->points[index0].b;
+# 
+#       const unsigned char r_c = input_->points[index_c].r;
+#       const unsigned char g_c = input_->points[index_c].g;
+#       const unsigned char b_c = input_->points[index_c].b;
+# 
+#       const unsigned char r_r = input_->points[index_r].r;
+#       const unsigned char g_r = input_->points[index_r].g;
+#       const unsigned char b_r = input_->points[index_r].b;
+# 
+#       const float r_dx = static_cast<float> (r_c) - static_cast<float> (r0);
+#       const float g_dx = static_cast<float> (g_c) - static_cast<float> (g0);
+#       const float b_dx = static_cast<float> (b_c) - static_cast<float> (b0);
+# 
+#       const float r_dy = static_cast<float> (r_r) - static_cast<float> (r0);
+#       const float g_dy = static_cast<float> (g_r) - static_cast<float> (g0);
+#       const float b_dy = static_cast<float> (b_r) - static_cast<float> (b0);
+# 
+#       const float sqr_mag_r = r_dx*r_dx + r_dy*r_dy;
+#       const float sqr_mag_g = g_dx*g_dx + g_dy*g_dy;
+#       const float sqr_mag_b = b_dx*b_dx + b_dy*b_dy;
+# 
+#       GradientXY gradient;
+#       gradient.x = col_index;
+#       gradient.y = row_index;
+#       if (sqr_mag_r > sqr_mag_g && sqr_mag_r > sqr_mag_b)
+#       {
+#         gradient.magnitude = sqrt (sqr_mag_r);
+#         gradient.angle = atan2 (r_dy, r_dx) * 180.0f / pi;
+#       }
+#       else if (sqr_mag_g > sqr_mag_b)
+#       {
+#         //GradientXY gradient;
+#         gradient.magnitude = sqrt (sqr_mag_g);
+#         gradient.angle = atan2 (g_dy, g_dx) * 180.0f / pi;
+#         //gradient.x = col_index;
+#         //gradient.y = row_index;
+# 
+#         //color_gradients_ (col_index+1, row_index+1) = gradient;
+#       }
+#       else
+#       {
+#         //GradientXY gradient;
+#         gradient.magnitude = sqrt (sqr_mag_b);
+#         gradient.angle = atan2 (b_dy, b_dx) * 180.0f / pi;
+#         //gradient.x = col_index;
+#         //gradient.y = row_index;
+# 
+#         //color_gradients_ (col_index+1, row_index+1) = gradient;
+#       }
+# 
+#       assert (color_gradients_ (col_index+1, row_index+1).angle >= -180 &&
+#               color_gradients_ (col_index+1, row_index+1).angle <=  180);
+# 
+#       color_gradients_ (col_index+1, row_index+1) = gradient;
+#     }
+#   }
+# 
+#   return;
+# }
+
+
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# void
+# pcl::ColorGradientDOTModality<PointInT>::
+# computeDominantQuantizedGradients ()
+# {
+#   const size_t input_width = input_->width;
+#   const size_t input_height = input_->height;
+# 
+#   const size_t output_width = input_width / bin_size_;
+#   const size_t output_height = input_height / bin_size_;
+# 
+#   dominant_quantized_color_gradients_.resize (output_width, output_height);
+# 
+#   //size_t offset_x = 0;
+#   //size_t offset_y = 0;
+#   
+#   const size_t num_gradient_bins = 7;
+#   const size_t max_num_of_gradients = 1;
+#   
+#   const float divisor = 180.0f / (num_gradient_bins - 1.0f);
+#   
+#   float global_max_gradient = 0.0f;
+#   float local_max_gradient = 0.0f;
+#   
+#   unsigned char * peak_pointer = dominant_quantized_color_gradients_.getData ();
+#   memset (peak_pointer, 0, output_width*output_height);
+#   
+#   //int tmpCounter = 0;
+#   for (size_t row_bin_index = 0; row_bin_index < output_height; ++row_bin_index)
+#   {
+#     for (size_t col_bin_index = 0; col_bin_index < output_width; ++col_bin_index)
+#     {
+#       const size_t x_position = col_bin_index * bin_size_;
+#       const size_t y_position = row_bin_index * bin_size_;
+# 
+#       //std::vector<int> x_coordinates;
+#       //std::vector<int> y_coordinates;
+#       //std::vector<float> values;
+#       
+#       // iteratively search for the largest gradients, set it to -1, search the next largest ... etc.
+#       //while (counter < max_num_of_gradients)
+#       {
+#         float max_gradient;
+#         size_t max_gradient_pos_x;
+#         size_t max_gradient_pos_y;
+#             
+#         // find next location and value of maximum gradient magnitude in current region
+#         {
+#           max_gradient = 0.0f;
+#           for (size_t row_sub_index = 0; row_sub_index < bin_size_; ++row_sub_index)
+#           {
+#             for (size_t col_sub_index = 0; col_sub_index < bin_size_; ++col_sub_index)
+#             {
+#               const float magnitude = color_gradients_ (col_sub_index + x_position, row_sub_index + y_position).magnitude;
+# 
+#               if (magnitude > max_gradient)
+#               {
+#                 max_gradient = magnitude;
+#                 max_gradient_pos_x = col_sub_index;
+#                 max_gradient_pos_y = row_sub_index;
+#               }
+#             }
+#           }
+#         }
+#             
+#         if (max_gradient >= gradient_magnitude_threshold_)
+#         {
+#           const size_t angle = static_cast<size_t> (180 + color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).angle + 0.5f);
+#           const size_t bin_index = static_cast<size_t> ((angle >= 180 ? angle-180 : angle)/divisor);
+#             
+#           *peak_pointer |= 1 << bin_index;
+#         }
+#             
+#         //++counter;
+#             
+#         //x_coordinates.push_back (max_gradient_pos_x + x_position);
+#         //y_coordinates.push_back (max_gradient_pos_y + y_position);
+#         //values.push_back (max_gradient);
+#             
+#         //color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).magnitude = -1.0f;
+#       }
+# 
+#       //// reset values which have been set to -1
+#       //for (size_t value_index = 0; value_index < values.size (); ++value_index)
+#       //{
+#       //  color_gradients_ (x_coordinates[value_index], y_coordinates[value_index]).magnitude = values[value_index];
+#       //}
+# 
+# 
+#       if (*peak_pointer == 0)
+#       {
+#         *peak_pointer |= 1 << 7;
+#       }
+# 
+#       //if (*peakPointer != 0)
+#       //{
+#       //  ++tmpCounter;
+#       //}
+#       
+#       //++stringPointer;
+#       ++peak_pointer;
+#       
+#       //offset_x += bin_size;
+#     }
+#     
+#     //offset_y += bin_size;
+#     //offset_x = bin_size/2+1;
+#   }
+# }
+
+
+# //////////////////////////////////////////////////////////////////////////////////////////////
+# template <typename PointInT>
+# pcl::QuantizedMap
+# pcl::ColorGradientDOTModality<PointInT>::
+# computeInvariantQuantizedMap (const MaskMap & mask,
+#                               const RegionXY & region)
+# {
+#   const size_t input_width = input_->width;
+#   const size_t input_height = input_->height;
+# 
+#   const size_t output_width = input_width / bin_size_;
+#   const size_t output_height = input_height / bin_size_;
+# 
+#   const size_t sub_start_x = region.x / bin_size_;
+#   const size_t sub_start_y = region.y / bin_size_;
+#   const size_t sub_width = region.width / bin_size_;
+#   const size_t sub_height = region.height / bin_size_;
+# 
+#   QuantizedMap map;
+#   map.resize (sub_width, sub_height);
+# 
+#   //size_t offset_x = 0;
+#   //size_t offset_y = 0;
+#   
+#   const size_t num_gradient_bins = 7;
+#   const size_t max_num_of_gradients = 7;
+#   
+#   const float divisor = 180.0f / (num_gradient_bins - 1.0f);
+#   
+#   float global_max_gradient = 0.0f;
+#   float local_max_gradient = 0.0f;
+#   
+#   unsigned char * peak_pointer = map.getData ();
+#   
+#   //int tmpCounter = 0;
+#   for (size_t row_bin_index = 0; row_bin_index < sub_height; ++row_bin_index)
+#   {
+#     for (size_t col_bin_index = 0; col_bin_index < sub_width; ++col_bin_index)
+#     {
+#       std::vector<size_t> x_coordinates;
+#       std::vector<size_t> y_coordinates;
+#       std::vector<float> values;
+#       
+#       for (int row_pixel_index = -static_cast<int> (bin_size_)/2; 
+#            row_pixel_index <= static_cast<int> (bin_size_)/2; 
+#            row_pixel_index += static_cast<int> (bin_size_)/2)
+#       {
+#         const size_t y_position = /*offset_y +*/ row_pixel_index + (sub_start_y + row_bin_index)*bin_size_;
+# 
+#         if (y_position < 0 || y_position >= input_height) 
+#           continue;
+# 
+#         for (int col_pixel_index = -static_cast<int> (bin_size_)/2; 
+#              col_pixel_index <= static_cast<int> (bin_size_)/2; 
+#              col_pixel_index += static_cast<int> (bin_size_)/2)
+#         {
+#           const size_t x_position = /*offset_x +*/ col_pixel_index + (sub_start_x + col_bin_index)*bin_size_;
+#           size_t counter = 0;
+#           
+#           if (x_position < 0 || x_position >= input_width) 
+#             continue;
+# 
+#           // find maximum gradient magnitude in current bin
+#           {
+#             local_max_gradient = 0.0f;
+#             for (size_t row_sub_index = 0; row_sub_index < bin_size_; ++row_sub_index)
+#             {
+#               for (size_t col_sub_index = 0; col_sub_index < bin_size_; ++col_sub_index)
+#               {
+#                 const float magnitude = color_gradients_ (col_sub_index + x_position, row_sub_index + y_position).magnitude;
+# 
+#                 if (magnitude > local_max_gradient)
+#                   local_max_gradient = magnitude;
+#               }
+#             }
+#           }
+#           
+#           //*stringPointer += localMaxGradient;
+#           
+#           if (local_max_gradient > global_max_gradient)
+#           {
+#             global_max_gradient = local_max_gradient;
+#           }
+#           
+#           // iteratively search for the largest gradients, set it to -1, search the next largest ... etc.
+#           while (true)
+#           {
+#             float max_gradient;
+#             size_t max_gradient_pos_x;
+#             size_t max_gradient_pos_y;
+#             
+#             // find next location and value of maximum gradient magnitude in current region
+#             {
+#               max_gradient = 0.0f;
+#               for (size_t row_sub_index = 0; row_sub_index < bin_size_; ++row_sub_index)
+#               {
+#                 for (size_t col_sub_index = 0; col_sub_index < bin_size_; ++col_sub_index)
+#                 {
+#                   const float magnitude = color_gradients_ (col_sub_index + x_position, row_sub_index + y_position).magnitude;
+# 
+#                   if (magnitude > max_gradient)
+#                   {
+#                     max_gradient = magnitude;
+#                     max_gradient_pos_x = col_sub_index;
+#                     max_gradient_pos_y = row_sub_index;
+#                   }
+#                 }
+#               }
+#             }
+#             
+#             // TODO: really localMaxGradient and not maxGradient???
+#             if (local_max_gradient < gradient_magnitude_threshold_)
+#             {
+#               //*peakPointer |= 1 << (numOfGradientBins-1);
+#               break;
+#             }
+#             
+#             // TODO: replace gradient_magnitude_threshold_ here by a fixed ratio?
+#             if (/*max_gradient < (local_max_gradient * gradient_magnitude_threshold_) ||*/
+#                 counter >= max_num_of_gradients)
+#             {
+#               break;
+#             }
+#             
+#             ++counter;
+#             
+#             const size_t angle = static_cast<size_t> (180 + color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).angle + 0.5f);
+#             const size_t bin_index = static_cast<size_t> ((angle >= 180 ? angle-180 : angle)/divisor);
+#             
+#             *peak_pointer |= 1 << bin_index;
+#             
+#             x_coordinates.push_back (max_gradient_pos_x + x_position);
+#             y_coordinates.push_back (max_gradient_pos_y + y_position);
+#             values.push_back (max_gradient);
+#             
+#             color_gradients_ (max_gradient_pos_x + x_position, max_gradient_pos_y + y_position).magnitude = -1.0f;
+#           }
+#           
+#           // reset values which have been set to -1
+#           for (size_t value_index = 0; value_index < values.size (); ++value_index)
+#           {
+#             color_gradients_ (x_coordinates[value_index], y_coordinates[value_index]).magnitude = values[value_index];
+#           }
+#           
+#           x_coordinates.clear ();
+#           y_coordinates.clear ();
+#           values.clear ();
+#         }
+#       }
+# 
+#       if (*peak_pointer == 0)
+#       {
+#         *peak_pointer |= 1 << 7;
+#       }
+# 
+#       //if (*peakPointer != 0)
+#       //{
+#       //  ++tmpCounter;
+#       //}
+#       
+#       //++stringPointer;
+#       ++peak_pointer;
+#       
+#       //offset_x += bin_size;
+#     }
+#     
+#     //offset_y += bin_size;
+#     //offset_x = bin_size/2+1;
+#   }
+# 
+#   return map;
+# }
+# 
+# #endif
+
+# color_gradient_modality.h
+# namespace pcl
+# 
+# /** \brief Modality based on max-RGB gradients.
+#   * \author Stefan Holzer
+#   */
+# template <typename PointInT>
+# class ColorGradientModality : public QuantizableModality, public PCLBase<PointInT>
+  {
+    protected:
+      using PCLBase<PointInT>::input_;
+
+      /** \brief Candidate for a feature (used in feature extraction methods). */
+      struct Candidate
+      {
+        /** \brief The gradient. */
+        GradientXY gradient;
+    
+        /** \brief The x-position. */
+        int x;
+        /** \brief The y-position. */
+        int y;  
+    
+        /** \brief Operator for comparing to candidates (by magnitude of the gradient).
+          * \param[in] rhs the candidate to compare with.
+          */
+        bool operator< (const Candidate & rhs) const
+        {
+          return (gradient.magnitude > rhs.gradient.magnitude);
+        }
+      };
+
+    public:
+      typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+
+      /** \brief Different methods for feature selection/extraction. */
+      enum FeatureSelectionMethod
+      {
+        MASK_BORDER_HIGH_GRADIENTS,
+        MASK_BORDER_EQUALLY, // this gives templates most equally to the OpenCV implementation
+        DISTANCE_MAGNITUDE_SCORE
+      };
+
+      /** \brief Constructor. */
+      ColorGradientModality ();
+      /** \brief Destructor. */
+      virtual ~ColorGradientModality ();
+  
+      /** \brief Sets the threshold for the gradient magnitude which is used when quantizing the data.
+        *        Gradients with a smaller magnitude are ignored. 
+        * \param[in] threshold the new gradient magnitude threshold.
+        */
+      inline void
+      setGradientMagnitudeThreshold (const float threshold)
+      {
+        gradient_magnitude_threshold_ = threshold;
+      }
+
+      /** \brief Sets the threshold for the gradient magnitude which is used for feature extraction.
+        *        Gradients with a smaller magnitude are ignored. 
+        * \param[in] threshold the new gradient magnitude threshold.
+        */
+      inline void
+      setGradientMagnitudeThresholdForFeatureExtraction (const float threshold)
+      {
+        gradient_magnitude_threshold_feature_extraction_ = threshold;
+      }
+
+      /** \brief Sets the feature selection method.
+        * \param[in] method the feature selection method.
+        */
+      inline void
+      setFeatureSelectionMethod (const FeatureSelectionMethod method)
+      {
+        feature_selection_method_ = method;
+      }
+  
+      /** \brief Sets the spreading size for spreading the quantized data. */
+      inline void
+      setSpreadingSize (const size_t spreading_size)
+      {
+        spreading_size_ = spreading_size;
+      }
+
+      /** \brief Sets whether variable feature numbers for feature extraction is enabled.
+        * \param[in] enabled enables/disables variable feature numbers for feature extraction.
+        */
+      inline void
+      setVariableFeatureNr (const bool enabled)
+      {
+        variable_feature_nr_ = enabled;
+      }
+
+      /** \brief Returns a reference to the internally computed quantized map. */
+      inline QuantizedMap &
+      getQuantizedMap () 
+      { 
+        return (filtered_quantized_color_gradients_);
+      }
+  
+      /** \brief Returns a reference to the internally computed spreaded quantized map. */
+      inline QuantizedMap &
+      getSpreadedQuantizedMap () 
+      { 
+        return (spreaded_filtered_quantized_color_gradients_);
+      }
+
+      /** \brief Returns a point cloud containing the max-RGB gradients. */
+      inline pcl::PointCloud<pcl::GradientXY> &
+      getMaxColorGradients ()
+      {
+        return (color_gradients_);
+      }
+  
+      /** \brief Extracts features from this modality within the specified mask.
+        * \param[in] mask defines the areas where features are searched in. 
+        * \param[in] nr_features defines the number of features to be extracted 
+        *            (might be less if not sufficient information is present in the modality).
+        * \param[in] modalityIndex the index which is stored in the extracted features.
+        * \param[out] features the destination for the extracted features.
+        */
+      void
+      extractFeatures (const MaskMap & mask, size_t nr_features, size_t modalityIndex,
+                       std::vector<QuantizedMultiModFeature> & features) const;
+  
+      /** \brief Extracts all possible features from the modality within the specified mask.
+        * \param[in] mask defines the areas where features are searched in. 
+        * \param[in] nr_features IGNORED (TODO: remove this parameter).
+        * \param[in] modalityIndex the index which is stored in the extracted features.
+        * \param[out] features the destination for the extracted features.
+        */
+      void
+      extractAllFeatures (const MaskMap & mask, size_t nr_features, size_t modalityIndex,
+                          std::vector<QuantizedMultiModFeature> & features) const;
+  
+      /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        * \param cloud the const boost shared pointer to a PointCloud message
+        */
+      virtual void 
+      setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+      { 
+        input_ = cloud;
+      }
+
+      /** \brief Processes the input data (smoothing, computing gradients, quantizing, filtering, spreading). */
+      virtual void
+      processInputData ();
+
+      /** \brief Processes the input data assuming that everything up to filtering is already done/available 
+        *        (so only spreading is performed). */
+      virtual void
+      processInputDataFromFiltered ();
+
+    protected:
+
+      /** \brief Computes the Gaussian kernel used for smoothing. 
+        * \param[in] kernel_size the size of the Gaussian kernel. 
+        * \param[in] sigma the sigma.
+        * \param[out] kernel_values the destination for the values of the kernel. */
+      void
+      computeGaussianKernel (const size_t kernel_size, const float sigma, std::vector <float> & kernel_values);
+
+      /** \brief Computes the max-RGB gradients for the specified cloud.
+        * \param[in] cloud the cloud for which the gradients are computed.
+        */
+      void
+      computeMaxColorGradients (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud);
+
+      /** \brief Computes the max-RGB gradients for the specified cloud using sobel.
+        * \param[in] cloud the cloud for which the gradients are computed.
+        */
+      void
+      computeMaxColorGradientsSobel (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud);
+  
+      /** \brief Quantizes the color gradients. */
+      void
+      quantizeColorGradients ();
+  
+      /** \brief Filters the quantized gradients. */
+      void
+      filterQuantizedColorGradients ();
+
+      /** \brief Erodes a mask.
+        * \param[in] mask_in the mask which will be eroded.
+        * \param[out] mask_out the destination for the eroded mask.
+        */
+      static void
+      erode (const pcl::MaskMap & mask_in, pcl::MaskMap & mask_out);
+  
+    private:
+
+      /** \brief Determines whether variable numbers of features are extracted or not. */
+      bool variable_feature_nr_;
+
+      /** \brief Stores a smoothed verion of the input cloud. */
+        pcl::PointCloud<pcl::RGB>::Ptr smoothed_input_;
+
+      /** \brief Defines which feature selection method is used. */
+      FeatureSelectionMethod feature_selection_method_;
+
+      /** \brief The threshold applied on the gradient magnitudes (for quantization). */
+      float gradient_magnitude_threshold_;
+      /** \brief The threshold applied on the gradient magnitudes for feature extraction. */
+      float gradient_magnitude_threshold_feature_extraction_;
+
+      /** \brief The point cloud which holds the max-RGB gradients. */
+      pcl::PointCloud<pcl::GradientXY> color_gradients_;
+
+      /** \brief The spreading size. */
+      size_t spreading_size_;
+  
+      /** \brief The map which holds the quantized max-RGB gradients. */
+      pcl::QuantizedMap quantized_color_gradients_;
+      /** \brief The map which holds the filtered quantized data. */
+      pcl::QuantizedMap filtered_quantized_color_gradients_;
+      /** \brief The map which holds the spreaded quantized data. */
+      pcl::QuantizedMap spreaded_filtered_quantized_color_gradients_;
+  
+  };
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorGradientModality<PointInT>::
+ColorGradientModality ()
+  : variable_feature_nr_ (false)
+  , smoothed_input_ (new pcl::PointCloud<pcl::RGB> ())
+  , feature_selection_method_ (DISTANCE_MAGNITUDE_SCORE)
+  , gradient_magnitude_threshold_ (10.0f)
+  , gradient_magnitude_threshold_feature_extraction_ (55.0f)
+  , color_gradients_ ()
+  , spreading_size_ (8)
+  , quantized_color_gradients_ ()
+  , filtered_quantized_color_gradients_ ()
+  , spreaded_filtered_quantized_color_gradients_ ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorGradientModality<PointInT>::
+~ColorGradientModality ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT> void
+pcl::ColorGradientModality<PointInT>::
+computeGaussianKernel (const size_t kernel_size, const float sigma, std::vector <float> & kernel_values)
+{
+  // code taken from OpenCV
+  const int n = int (kernel_size);
+  const int SMALL_GAUSSIAN_SIZE = 7;
+  static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =
+  {
+      {1.f},
+      {0.25f, 0.5f, 0.25f},
+      {0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},
+      {0.03125f, 0.109375f, 0.21875f, 0.28125f, 0.21875f, 0.109375f, 0.03125f}
+  };
+
+  const float* fixed_kernel = n % 2 == 1 && n <= SMALL_GAUSSIAN_SIZE && sigma <= 0 ?
+      small_gaussian_tab[n>>1] : 0;
+
+  //CV_Assert( ktype == CV_32F || ktype == CV_64F );
+  /*Mat kernel(n, 1, ktype);*/
+  kernel_values.resize (n);
+  float* cf = &(kernel_values[0]);
+  //double* cd = (double*)kernel.data;
+
+  double sigmaX = sigma > 0 ? sigma : ((n-1)*0.5 - 1)*0.3 + 0.8;
+  double scale2X = -0.5/(sigmaX*sigmaX);
+  double sum = 0;
+
+  int i;
+  for( i = 0; i < n; i++ )
+  {
+    double x = i - (n-1)*0.5;
+    double t = fixed_kernel ? double (fixed_kernel[i]) : std::exp (scale2X*x*x);
+
+    cf[i] = float (t);
+    sum += cf[i];
+  }
+
+  sum = 1./sum;
+  for (i = 0; i < n; i++ )
+  {
+    cf[i] = float (cf[i]*sum);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+processInputData ()
+{
+  // compute gaussian kernel values
+  const size_t kernel_size = 7;
+  std::vector<float> kernel_values;
+  computeGaussianKernel (kernel_size, 0.0f, kernel_values);
+
+  // smooth input
+    pcl::filters::Convolution<pcl::RGB, pcl::RGB> convolution;
+    Eigen::ArrayXf gaussian_kernel(kernel_size);
+    //gaussian_kernel << 1.f/16, 1.f/8, 3.f/16, 2.f/8, 3.f/16, 1.f/8, 1.f/16;
+    //gaussian_kernel << 16.f/1600.f,  32.f/1600.f,  64.f/1600.f, 128.f/1600.f, 256.f/1600.f, 128.f/1600.f,  64.f/1600.f,  32.f/1600.f,  16.f/1600.f;
+  gaussian_kernel << kernel_values[0], kernel_values[1], kernel_values[2], kernel_values[3], kernel_values[4], kernel_values[5], kernel_values[6];
+
+  pcl::PointCloud<pcl::RGB>::Ptr rgb_input_ (new pcl::PointCloud<pcl::RGB>());
+  
+  const uint32_t width = input_->width;
+  const uint32_t height = input_->height;
+
+  rgb_input_->resize (width*height);
+  rgb_input_->width = width;
+  rgb_input_->height = height;
+  rgb_input_->is_dense = input_->is_dense;
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      (*rgb_input_) (col_index, row_index).r = (*input_) (col_index, row_index).r;
+      (*rgb_input_) (col_index, row_index).g = (*input_) (col_index, row_index).g;
+      (*rgb_input_) (col_index, row_index).b = (*input_) (col_index, row_index).b;
+    }
+  }
+
+    convolution.setInputCloud (rgb_input_);
+    convolution.setKernel (gaussian_kernel);
+
+  convolution.convolve (*smoothed_input_);
+
+  // extract color gradients
+  computeMaxColorGradientsSobel (smoothed_input_);
+
+  // quantize gradients
+  quantizeColorGradients ();
+
+  // filter quantized gradients to get only dominants one + thresholding
+  filterQuantizedColorGradients ();
+
+  // spread filtered quantized gradients
+  //spreadFilteredQunatizedColorGradients ();
+  pcl::QuantizedMap::spreadQuantizedMap (filtered_quantized_color_gradients_,
+                                         spreaded_filtered_quantized_color_gradients_, 
+                                         spreading_size_);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+processInputDataFromFiltered ()
+{
+  // spread filtered quantized gradients
+  //spreadFilteredQunatizedColorGradients ();
+  pcl::QuantizedMap::spreadQuantizedMap (filtered_quantized_color_gradients_,
+                                         spreaded_filtered_quantized_color_gradients_, 
+                                         spreading_size_);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void pcl::ColorGradientModality<PointInT>::
+extractFeatures (const MaskMap & mask, const size_t nr_features, const size_t modality_index,
+                 std::vector<QuantizedMultiModFeature> & features) const
+{
+  const size_t width = mask.getWidth ();
+  const size_t height = mask.getHeight ();
+  
+  std::list<Candidate> list1;
+  std::list<Candidate> list2;
+
+
+  if (feature_selection_method_ == DISTANCE_MAGNITUDE_SCORE)
+  {
+    for (size_t row_index = 0; row_index < height; ++row_index)
+    {
+      for (size_t col_index = 0; col_index < width; ++col_index)
+      {
+        if (mask (col_index, row_index) != 0)
+        {
+          const GradientXY & gradient = color_gradients_ (col_index, row_index);
+          if (gradient.magnitude > gradient_magnitude_threshold_feature_extraction_
+            && filtered_quantized_color_gradients_ (col_index, row_index) != 0)
+          {
+            Candidate candidate;
+            candidate.gradient = gradient;
+            candidate.x = static_cast<int> (col_index);
+            candidate.y = static_cast<int> (row_index);
+
+            list1.push_back (candidate);
+          }
+        }
+      }
+    }
+
+    list1.sort();
+
+    if (variable_feature_nr_)
+    {
+      list2.push_back (*(list1.begin ()));
+      //while (list2.size () != nr_features)
+      bool feature_selection_finished = false;
+      while (!feature_selection_finished)
+      {
+        float best_score = 0.0f;
+        typename std::list<Candidate>::iterator best_iter = list1.end ();
+        for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+        {
+          // find smallest distance
+          float smallest_distance = std::numeric_limits<float>::max ();
+          for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+          {
+            const float dx = static_cast<float> (iter1->x) - static_cast<float> (iter2->x);
+            const float dy = static_cast<float> (iter1->y) - static_cast<float> (iter2->y);
+
+            const float distance = dx*dx + dy*dy;
+
+            if (distance < smallest_distance)
+            {
+              smallest_distance = distance;
+            }
+          }
+
+          const float score = smallest_distance * iter1->gradient.magnitude;
+
+          if (score > best_score)
+          {
+            best_score = score;
+            best_iter = iter1;
+          }
+        }
+
+
+        float min_min_sqr_distance = std::numeric_limits<float>::max ();
+        float max_min_sqr_distance = 0;
+        for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+        {
+          float min_sqr_distance = std::numeric_limits<float>::max ();
+          for (typename std::list<Candidate>::iterator iter3 = list2.begin (); iter3 != list2.end (); ++iter3)
+          {
+            if (iter2 == iter3)
+              continue;
+
+            const float dx = static_cast<float> (iter2->x) - static_cast<float> (iter3->x);
+            const float dy = static_cast<float> (iter2->y) - static_cast<float> (iter3->y);
+
+            const float sqr_distance = dx*dx + dy*dy;
+
+            if (sqr_distance < min_sqr_distance)
+            {
+              min_sqr_distance = sqr_distance;
+            }
+
+            //std::cerr << min_sqr_distance;
+          }
+          //std::cerr << std::endl;
+
+          // check current feature
+          {
+            const float dx = static_cast<float> (iter2->x) - static_cast<float> (best_iter->x);
+            const float dy = static_cast<float> (iter2->y) - static_cast<float> (best_iter->y);
+
+            const float sqr_distance = dx*dx + dy*dy;
+
+            if (sqr_distance < min_sqr_distance)
+            {
+              min_sqr_distance = sqr_distance;
+            }
+          }
+
+          if (min_sqr_distance < min_min_sqr_distance)
+            min_min_sqr_distance = min_sqr_distance;
+          if (min_sqr_distance > max_min_sqr_distance)
+            max_min_sqr_distance = min_sqr_distance;
+
+          //std::cerr << min_sqr_distance << ", " << min_min_sqr_distance << ", " << max_min_sqr_distance << std::endl;
+        }
+
+        if (best_iter != list1.end ())
+        {
+          //std::cerr << "feature_index: " << list2.size () << std::endl;
+          //std::cerr << "min_min_sqr_distance: " << min_min_sqr_distance << std::endl;
+          //std::cerr << "max_min_sqr_distance: " << max_min_sqr_distance << std::endl;
+
+          if (min_min_sqr_distance < 50)
+          {
+            feature_selection_finished = true;
+            break;
+          }
+
+          list2.push_back (*best_iter);
+        }
+      } 
+    }
+    else
+    {
+      if (list1.size () <= nr_features)
+      {
+        for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+        {
+          QuantizedMultiModFeature feature;
+          
+          feature.x = iter1->x;
+          feature.y = iter1->y;
+          feature.modality_index = modality_index;
+          feature.quantized_value = filtered_quantized_color_gradients_ (iter1->x, iter1->y);
+
+          features.push_back (feature);
+        }
+        return;
+      }
+
+      list2.push_back (*(list1.begin ()));
+      while (list2.size () != nr_features)
+      {
+        float best_score = 0.0f;
+        typename std::list<Candidate>::iterator best_iter = list1.end ();
+        for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+        {
+          // find smallest distance
+          float smallest_distance = std::numeric_limits<float>::max ();
+          for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+          {
+            const float dx = static_cast<float> (iter1->x) - static_cast<float> (iter2->x);
+            const float dy = static_cast<float> (iter1->y) - static_cast<float> (iter2->y);
+
+            const float distance = dx*dx + dy*dy;
+
+            if (distance < smallest_distance)
+            {
+              smallest_distance = distance;
+            }
+          }
+
+          const float score = smallest_distance * iter1->gradient.magnitude;
+
+          if (score > best_score)
+          {
+            best_score = score;
+            best_iter = iter1;
+          }
+        }
+
+        if (best_iter != list1.end ())
+        {
+          list2.push_back (*best_iter);
+        }
+        else
+        {
+          break;
+        }
+      }  
+    }
+  }
+  else if (feature_selection_method_ == MASK_BORDER_HIGH_GRADIENTS || feature_selection_method_ == MASK_BORDER_EQUALLY)
+  {
+    MaskMap eroded_mask;
+    erode (mask, eroded_mask);
+
+    MaskMap diff_mask;
+    MaskMap::getDifferenceMask (mask, eroded_mask, diff_mask);
+
+    for (size_t row_index = 0; row_index < height; ++row_index)
+    {
+      for (size_t col_index = 0; col_index < width; ++col_index)
+      {
+        if (diff_mask (col_index, row_index) != 0)
+        {
+          const GradientXY & gradient = color_gradients_ (col_index, row_index);
+          if ((feature_selection_method_ == MASK_BORDER_EQUALLY || gradient.magnitude > gradient_magnitude_threshold_feature_extraction_)
+            && filtered_quantized_color_gradients_ (col_index, row_index) != 0)
+          {
+            Candidate candidate;
+            candidate.gradient = gradient;
+            candidate.x = static_cast<int> (col_index);
+            candidate.y = static_cast<int> (row_index);
+
+            list1.push_back (candidate);
+          }
+        }
+      }
+    }
+
+    list1.sort();
+
+    if (list1.size () <= nr_features)
+    {
+      for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+      {
+        QuantizedMultiModFeature feature;
+          
+        feature.x = iter1->x;
+        feature.y = iter1->y;
+        feature.modality_index = modality_index;
+        feature.quantized_value = filtered_quantized_color_gradients_ (iter1->x, iter1->y);
+
+        features.push_back (feature);
+      }
+      return;
+    }
+
+    size_t distance = list1.size () / nr_features + 1; // ??? 
+    while (list2.size () != nr_features)
+    {
+      const size_t sqr_distance = distance*distance;
+      for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+      {
+        bool candidate_accepted = true;
+
+        for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+        {
+          const int dx = iter1->x - iter2->x;
+          const int dy = iter1->y - iter2->y;
+          const unsigned int tmp_distance = dx*dx + dy*dy;
+
+          //if (tmp_distance < distance) 
+          if (tmp_distance < sqr_distance)
+          {
+            candidate_accepted = false;
+            break;
+          }
+        }
+
+        if (candidate_accepted)
+          list2.push_back (*iter1);
+
+        if (list2.size () == nr_features)
+          break;
+      }
+      --distance;
+    }
+  }
+
+  for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+  {
+    QuantizedMultiModFeature feature;
+    
+    feature.x = iter2->x;
+    feature.y = iter2->y;
+    feature.modality_index = modality_index;
+    feature.quantized_value = filtered_quantized_color_gradients_ (iter2->x, iter2->y);
+
+    features.push_back (feature);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT> void 
+pcl::ColorGradientModality<PointInT>::
+extractAllFeatures (const MaskMap & mask, const size_t, const size_t modality_index,
+                 std::vector<QuantizedMultiModFeature> & features) const
+{
+  const size_t width = mask.getWidth ();
+  const size_t height = mask.getHeight ();
+  
+  std::list<Candidate> list1;
+  std::list<Candidate> list2;
+
+
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      if (mask (col_index, row_index) != 0)
+      {
+        const GradientXY & gradient = color_gradients_ (col_index, row_index);
+        if (gradient.magnitude > gradient_magnitude_threshold_feature_extraction_
+          && filtered_quantized_color_gradients_ (col_index, row_index) != 0)
+        {
+          Candidate candidate;
+          candidate.gradient = gradient;
+          candidate.x = static_cast<int> (col_index);
+          candidate.y = static_cast<int> (row_index);
+
+          list1.push_back (candidate);
+        }
+      }
+    }
+  }
+
+  list1.sort();
+
+  for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+  {
+    QuantizedMultiModFeature feature;
+          
+    feature.x = iter1->x;
+    feature.y = iter1->y;
+    feature.modality_index = modality_index;
+    feature.quantized_value = filtered_quantized_color_gradients_ (iter1->x, iter1->y);
+
+    features.push_back (feature);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+computeMaxColorGradients (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud)
+{
+  const int width = cloud->width;
+  const int height = cloud->height;
+
+  color_gradients_.points.resize (width*height);
+  color_gradients_.width = width;
+  color_gradients_.height = height;
+
+  const float pi = tan (1.0f) * 2;
+  for (int row_index = 0; row_index < height-2; ++row_index)
+  {
+    for (int col_index = 0; col_index < width-2; ++col_index)
+    {
+      const int index0 = row_index*width+col_index;
+      const int index_c = row_index*width+col_index+2;
+      const int index_r = (row_index+2)*width+col_index;
+
+      //const int index_d = (row_index+1)*width+col_index+1;
+
+      const unsigned char r0 = cloud->points[index0].r;
+      const unsigned char g0 = cloud->points[index0].g;
+      const unsigned char b0 = cloud->points[index0].b;
+
+      const unsigned char r_c = cloud->points[index_c].r;
+      const unsigned char g_c = cloud->points[index_c].g;
+      const unsigned char b_c = cloud->points[index_c].b;
+
+      const unsigned char r_r = cloud->points[index_r].r;
+      const unsigned char g_r = cloud->points[index_r].g;
+      const unsigned char b_r = cloud->points[index_r].b;
+
+      const float r_dx = static_cast<float> (r_c) - static_cast<float> (r0);
+      const float g_dx = static_cast<float> (g_c) - static_cast<float> (g0);
+      const float b_dx = static_cast<float> (b_c) - static_cast<float> (b0);
+
+      const float r_dy = static_cast<float> (r_r) - static_cast<float> (r0);
+      const float g_dy = static_cast<float> (g_r) - static_cast<float> (g0);
+      const float b_dy = static_cast<float> (b_r) - static_cast<float> (b0);
+
+      const float sqr_mag_r = r_dx*r_dx + r_dy*r_dy;
+      const float sqr_mag_g = g_dx*g_dx + g_dy*g_dy;
+      const float sqr_mag_b = b_dx*b_dx + b_dy*b_dy;
+
+      if (sqr_mag_r > sqr_mag_g && sqr_mag_r > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrt (sqr_mag_r);
+        gradient.angle = atan2 (r_dy, r_dx) * 180.0f / pi;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index+1, row_index+1) = gradient;
+      }
+      else if (sqr_mag_g > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrt (sqr_mag_g);
+        gradient.angle = atan2 (g_dy, g_dx) * 180.0f / pi;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index+1, row_index+1) = gradient;
+      }
+      else
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrt (sqr_mag_b);
+        gradient.angle = atan2 (b_dy, b_dx) * 180.0f / pi;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index+1, row_index+1) = gradient;
+      }
+
+      assert (color_gradients_ (col_index+1, row_index+1).angle >= -180 &&
+              color_gradients_ (col_index+1, row_index+1).angle <=  180);
+    }
+  }
+
+  return;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+computeMaxColorGradientsSobel (const typename pcl::PointCloud<pcl::RGB>::ConstPtr & cloud)
+{
+  const int width = cloud->width;
+  const int height = cloud->height;
+
+  color_gradients_.points.resize (width*height);
+  color_gradients_.width = width;
+  color_gradients_.height = height;
+
+  const float pi = tanf (1.0f) * 2.0f;
+  for (int row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (int col_index = 1; col_index < width-1; ++col_index)
+    {
+      const int r7 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index-1)].r);
+      const int g7 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index-1)].g);
+      const int b7 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index-1)].b);
+      const int r8 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index)].r);
+      const int g8 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index)].g);
+      const int b8 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index)].b);
+      const int r9 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index+1)].r);
+      const int g9 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index+1)].g);
+      const int b9 = static_cast<int> (cloud->points[(row_index-1)*width + (col_index+1)].b);
+      const int r4 = static_cast<int> (cloud->points[(row_index)*width + (col_index-1)].r);
+      const int g4 = static_cast<int> (cloud->points[(row_index)*width + (col_index-1)].g);
+      const int b4 = static_cast<int> (cloud->points[(row_index)*width + (col_index-1)].b);
+      const int r6 = static_cast<int> (cloud->points[(row_index)*width + (col_index+1)].r);
+      const int g6 = static_cast<int> (cloud->points[(row_index)*width + (col_index+1)].g);
+      const int b6 = static_cast<int> (cloud->points[(row_index)*width + (col_index+1)].b);
+      const int r1 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index-1)].r);
+      const int g1 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index-1)].g);
+      const int b1 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index-1)].b);
+      const int r2 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index)].r);
+      const int g2 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index)].g);
+      const int b2 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index)].b);
+      const int r3 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index+1)].r);
+      const int g3 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index+1)].g);
+      const int b3 = static_cast<int> (cloud->points[(row_index+1)*width + (col_index+1)].b);
+
+      //const int r_tmp1 = - r7 + r3;
+      //const int r_tmp2 = - r1 + r9;
+      //const int g_tmp1 = - g7 + g3;
+      //const int g_tmp2 = - g1 + g9;
+      //const int b_tmp1 = - b7 + b3;
+      //const int b_tmp2 = - b1 + b9;
+      ////const int gx = - r7 - (r4<<2) - r1 + r3 + (r6<<2) + r9;
+      ////const int gy = - r7 - (r8<<2) - r9 + r1 + (r2<<2) + r3;
+      //const int r_dx = r_tmp1 + r_tmp2 - (r4<<2) + (r6<<2);
+      //const int r_dy = r_tmp1 - r_tmp2 - (r8<<2) + (r2<<2);
+      //const int g_dx = g_tmp1 + g_tmp2 - (g4<<2) + (g6<<2);
+      //const int g_dy = g_tmp1 - g_tmp2 - (g8<<2) + (g2<<2);
+      //const int b_dx = b_tmp1 + b_tmp2 - (b4<<2) + (b6<<2);
+      //const int b_dy = b_tmp1 - b_tmp2 - (b8<<2) + (b2<<2);
+
+      //const int r_tmp1 = - r7 + r3;
+      //const int r_tmp2 = - r1 + r9;
+      //const int g_tmp1 = - g7 + g3;
+      //const int g_tmp2 = - g1 + g9;
+      //const int b_tmp1 = - b7 + b3;
+      //const int b_tmp2 = - b1 + b9;
+      //const int gx = - r7 - (r4<<2) - r1 + r3 + (r6<<2) + r9;
+      //const int gy = - r7 - (r8<<2) - r9 + r1 + (r2<<2) + r3;
+      const int r_dx = r9 + 2*r6 + r3 - (r7 + 2*r4 + r1);
+      const int r_dy = r1 + 2*r2 + r3 - (r7 + 2*r8 + r9);
+      const int g_dx = g9 + 2*g6 + g3 - (g7 + 2*g4 + g1);
+      const int g_dy = g1 + 2*g2 + g3 - (g7 + 2*g8 + g9);
+      const int b_dx = b9 + 2*b6 + b3 - (b7 + 2*b4 + b1);
+      const int b_dy = b1 + 2*b2 + b3 - (b7 + 2*b8 + b9);
+
+      const int sqr_mag_r = r_dx*r_dx + r_dy*r_dy;
+      const int sqr_mag_g = g_dx*g_dx + g_dy*g_dy;
+      const int sqr_mag_b = b_dx*b_dx + b_dy*b_dy;
+
+      if (sqr_mag_r > sqr_mag_g && sqr_mag_r > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrtf (static_cast<float> (sqr_mag_r));
+        gradient.angle = atan2f (static_cast<float> (r_dy), static_cast<float> (r_dx)) * 180.0f / pi;
+        if (gradient.angle < -180.0f) gradient.angle += 360.0f;
+        if (gradient.angle >= 180.0f) gradient.angle -= 360.0f;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index, row_index) = gradient;
+      }
+      else if (sqr_mag_g > sqr_mag_b)
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrtf (static_cast<float> (sqr_mag_g));
+        gradient.angle = atan2f (static_cast<float> (g_dy), static_cast<float> (g_dx)) * 180.0f / pi;
+        if (gradient.angle < -180.0f) gradient.angle += 360.0f;
+        if (gradient.angle >= 180.0f) gradient.angle -= 360.0f;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index, row_index) = gradient;
+      }
+      else
+      {
+        GradientXY gradient;
+        gradient.magnitude = sqrtf (static_cast<float> (sqr_mag_b));
+        gradient.angle = atan2f (static_cast<float> (b_dy), static_cast<float> (b_dx)) * 180.0f / pi;
+        if (gradient.angle < -180.0f) gradient.angle += 360.0f;
+        if (gradient.angle >= 180.0f) gradient.angle -= 360.0f;
+        gradient.x = static_cast<float> (col_index);
+        gradient.y = static_cast<float> (row_index);
+
+        color_gradients_ (col_index, row_index) = gradient;
+      }
+
+      assert (color_gradients_ (col_index, row_index).angle >= -180 &&
+              color_gradients_ (col_index, row_index).angle <=  180);
+    }
+  }
+
+  return;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+quantizeColorGradients ()
+{
+  //std::cerr << "quantize this, bastard!!!" << std::endl;
+
+  //unsigned char quantization_map[16] = {0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7};
+  //unsigned char quantization_map[16] = {1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8};
+
+  //for (float angle = 0.0f; angle < 360.0f; angle += 1.0f)
+  //{
+  //  const int quantized_value = quantization_map[static_cast<int> (angle * angleScale)];
+  //  std::cerr << angle << ": " << quantized_value << std::endl;
+  //}
+
+
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  quantized_color_gradients_.resize (width, height);
+
+  const float angleScale = 16.0f/360.0f;
+
+  //float min_angle = std::numeric_limits<float>::max ();
+  //float max_angle = -std::numeric_limits<float>::max ();
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      if (color_gradients_ (col_index, row_index).magnitude < gradient_magnitude_threshold_) 
+      {
+        quantized_color_gradients_ (col_index, row_index) = 0;
+        continue;
+      }
+
+      const float angle = 11.25f + color_gradients_ (col_index, row_index).angle + 180.0f;
+      const int quantized_value = (static_cast<int> (angle * angleScale)) & 7;
+      quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> (quantized_value + 1); 
+
+      //const float angle = color_gradients_ (col_index, row_index).angle + 180.0f;
+
+      //min_angle = std::min (min_angle, angle);
+      //max_angle = std::max (max_angle, angle);
+
+      //if (angle < 0.0f || angle >= 360.0f)
+      //{
+      //  std::cerr << "angle shitty: " << angle << std::endl;
+      //}
+
+      //const int quantized_value = quantization_map[static_cast<int> (angle * angleScale)];
+      //quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> (quantized_value); 
+
+      //assert (0 <= quantized_value && quantized_value < 16);
+      //quantized_color_gradients_ (col_index, row_index) = quantization_map[quantized_value];
+      //quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> ((quantized_value & 7) + 1); // = (quantized_value % 8) + 1
+    }
+  }
+
+  //std::cerr << ">>>>> " << min_angle << ", " << max_angle << std::endl;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+filterQuantizedColorGradients ()
+{
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  filtered_quantized_color_gradients_.resize (width, height);
+
+  // filter data
+  for (size_t row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (size_t col_index = 1; col_index < width-1; ++col_index)
+    {
+      unsigned char histogram[9] = {0,0,0,0,0,0,0,0,0};
+
+      {
+        const unsigned char * data_ptr = quantized_color_gradients_.getData () + (row_index-1)*width+col_index-1;
+        assert (data_ptr[0] < 9 && data_ptr[1] < 9 && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_color_gradients_.getData () + row_index*width+col_index-1;
+        assert (data_ptr[0] < 9 && data_ptr[1] < 9 && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_color_gradients_.getData () + (row_index+1)*width+col_index-1;
+        assert (data_ptr[0] < 9 && data_ptr[1] < 9 && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+
+      unsigned char max_hist_value = 0;
+      int max_hist_index = -1;
+
+      // for (int i = 0; i < 8; ++i)
+      // {
+      //   if (max_hist_value < histogram[i+1])
+      //   {
+      //     max_hist_index = i;
+      //     max_hist_value = histogram[i+1]
+      //   }
+      // }
+      // Unrolled for performance optimization:
+      if (max_hist_value < histogram[1]) {max_hist_index = 0; max_hist_value = histogram[1];}
+      if (max_hist_value < histogram[2]) {max_hist_index = 1; max_hist_value = histogram[2];}
+      if (max_hist_value < histogram[3]) {max_hist_index = 2; max_hist_value = histogram[3];}
+      if (max_hist_value < histogram[4]) {max_hist_index = 3; max_hist_value = histogram[4];}
+      if (max_hist_value < histogram[5]) {max_hist_index = 4; max_hist_value = histogram[5];}
+      if (max_hist_value < histogram[6]) {max_hist_index = 5; max_hist_value = histogram[6];}
+      if (max_hist_value < histogram[7]) {max_hist_index = 6; max_hist_value = histogram[7];}
+      if (max_hist_value < histogram[8]) {max_hist_index = 7; max_hist_value = histogram[8];}
+
+      if (max_hist_index != -1 && max_hist_value >= 5)
+        filtered_quantized_color_gradients_ (col_index, row_index) = static_cast<unsigned char> (0x1 << max_hist_index);
+      else
+        filtered_quantized_color_gradients_ (col_index, row_index) = 0;
+
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorGradientModality<PointInT>::
+erode (const pcl::MaskMap & mask_in, 
+       pcl::MaskMap & mask_out)
+{
+  const size_t width = mask_in.getWidth ();
+  const size_t height = mask_in.getHeight ();
+
+  mask_out.resize (width, height);
+
+  for (size_t row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (size_t col_index = 1; col_index < width-1; ++col_index)
+    {
+      if (mask_in (col_index, row_index-1) == 0 ||
+          mask_in (col_index-1, row_index) == 0 ||
+          mask_in (col_index+1, row_index) == 0 ||
+          mask_in (col_index, row_index+1) == 0)
+      {
+        mask_out (col_index, row_index) = 0;
+      }
+      else
+      {
+        mask_out (col_index, row_index) = 255;
+      }
+    }
+  }
+}
+
+#endif 
+
+###
+
+# color_modality.h
+namespace pcl
+{
+
+  // --------------------------------------------------------------------------
+
+  template <typename PointInT>
+  class ColorModality
+    : public QuantizableModality, public PCLBase<PointInT>
+  {
+    protected:
+      using PCLBase<PointInT>::input_;
+
+      struct Candidate
+      {
+        float distance;
+
+        unsigned char bin_index;
+    
+        size_t x;
+        size_t y;   
+
+        bool 
+        operator< (const Candidate & rhs)
+        {
+          return (distance > rhs.distance);
+        }
+      };
+
+    public:
+      typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+
+      ColorModality ();
+  
+      virtual ~ColorModality ();
+  
+      inline QuantizedMap &
+      getQuantizedMap () 
+      { 
+        return (filtered_quantized_colors_);
+      }
+  
+      inline QuantizedMap &
+      getSpreadedQuantizedMap () 
+      { 
+        return (spreaded_filtered_quantized_colors_);
+      }
+  
+      void
+      extractFeatures (const MaskMap & mask, size_t nr_features, size_t modalityIndex,
+                       std::vector<QuantizedMultiModFeature> & features) const;
+  
+      /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        * \param cloud the const boost shared pointer to a PointCloud message
+        */
+      virtual void 
+      setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+      { 
+        input_ = cloud;
+      }
+
+      virtual void
+      processInputData ();
+
+    protected:
+
+      void
+      quantizeColors ();
+  
+      void
+      filterQuantizedColors ();
+
+      static inline int
+      quantizeColorOnRGBExtrema (const float r,
+                                 const float g,
+                                 const float b);
+  
+      void
+      computeDistanceMap (const MaskMap & input, DistanceMap & output) const;
+
+    private:
+      float feature_distance_threshold_;
+      
+      pcl::QuantizedMap quantized_colors_;
+      pcl::QuantizedMap filtered_quantized_colors_;
+      pcl::QuantizedMap spreaded_filtered_quantized_colors_;
+  
+  };
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorModality<PointInT>::ColorModality ()
+  : feature_distance_threshold_ (1.0f), quantized_colors_ (), filtered_quantized_colors_ (), spreaded_filtered_quantized_colors_ ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+pcl::ColorModality<PointInT>::~ColorModality ()
+{
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorModality<PointInT>::processInputData ()
+{
+  // quantize gradients
+  quantizeColors ();
+
+  // filter quantized gradients to get only dominants one + thresholding
+  filterQuantizedColors ();
+
+  // spread filtered quantized gradients
+  //spreadFilteredQunatizedColorGradients ();
+  const int spreading_size = 8;
+  pcl::QuantizedMap::spreadQuantizedMap (filtered_quantized_colors_,
+                                         spreaded_filtered_quantized_colors_, spreading_size);
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void pcl::ColorModality<PointInT>::extractFeatures (const MaskMap & mask, 
+                                                    const size_t nr_features, 
+                                                    const size_t modality_index,
+                                                    std::vector<QuantizedMultiModFeature> & features) const
+{
+  const size_t width = mask.getWidth ();
+  const size_t height = mask.getHeight ();
+
+  MaskMap mask_maps[8];
+  for (size_t map_index = 0; map_index < 8; ++map_index)
+    mask_maps[map_index].resize (width, height);
+
+  unsigned char map[255];
+  memset(map, 0, 255);
+
+  map[0x1<<0] = 0;
+  map[0x1<<1] = 1;
+  map[0x1<<2] = 2;
+  map[0x1<<3] = 3;
+  map[0x1<<4] = 4;
+  map[0x1<<5] = 5;
+  map[0x1<<6] = 6;
+  map[0x1<<7] = 7;
+
+  QuantizedMap distance_map_indices (width, height);
+  //memset (distance_map_indices.data, 0, sizeof (distance_map_indices.data[0])*width*height);
+
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      if (mask (col_index, row_index) != 0)
+      {
+        //const unsigned char quantized_value = quantized_surface_normals_ (row_index, col_index);
+        const unsigned char quantized_value = filtered_quantized_colors_ (col_index, row_index);
+
+        if (quantized_value == 0) 
+          continue;
+        const int dist_map_index = map[quantized_value];
+
+        distance_map_indices (col_index, row_index) = dist_map_index;
+        //distance_maps[dist_map_index].at<unsigned char>(row_index, col_index) = 255;
+        mask_maps[dist_map_index] (col_index, row_index) = 255;
+      }
+    }
+  }
+
+  DistanceMap distance_maps[8];
+  for (int map_index = 0; map_index < 8; ++map_index)
+    computeDistanceMap (mask_maps[map_index], distance_maps[map_index]);
+
+  std::list<Candidate> list1;
+  std::list<Candidate> list2;
+
+  float weights[8] = {0,0,0,0,0,0,0,0};
+
+  const size_t off = 4;
+  for (size_t row_index = off; row_index < height-off; ++row_index)
+  {
+    for (size_t col_index = off; col_index < width-off; ++col_index)
+    {
+      if (mask (col_index, row_index) != 0)
+      {
+        //const unsigned char quantized_value = quantized_surface_normals_ (row_index, col_index);
+        const unsigned char quantized_value = filtered_quantized_colors_ (col_index, row_index);
+
+        //const float nx = surface_normals_ (col_index, row_index).normal_x;
+        //const float ny = surface_normals_ (col_index, row_index).normal_y;
+        //const float nz = surface_normals_ (col_index, row_index).normal_z;
+
+        if (quantized_value != 0)
+        {
+          const int distance_map_index = map[quantized_value];
+
+          //const float distance = distance_maps[distance_map_index].at<float> (row_index, col_index);
+          const float distance = distance_maps[distance_map_index] (col_index, row_index);
+
+          if (distance >= feature_distance_threshold_)
+          {
+            Candidate candidate;
+
+            candidate.distance = distance;
+            candidate.x = col_index;
+            candidate.y = row_index;
+            candidate.bin_index = distance_map_index;
+
+            list1.push_back (candidate);
+
+            ++weights[distance_map_index];
+          }
+        }
+      }
+    }
+  }
+
+  for (typename std::list<Candidate>::iterator iter = list1.begin (); iter != list1.end (); ++iter)
+    iter->distance *= 1.0f / weights[iter->bin_index];
+
+  list1.sort ();
+
+  if (list1.size () <= nr_features)
+  {
+    features.reserve (list1.size ());
+    for (typename std::list<Candidate>::iterator iter = list1.begin (); iter != list1.end (); ++iter)
+    {
+      QuantizedMultiModFeature feature;
+
+      feature.x = static_cast<int> (iter->x);
+      feature.y = static_cast<int> (iter->y);
+      feature.modality_index = modality_index;
+      feature.quantized_value = filtered_quantized_colors_ (iter->x, iter->y);
+
+      features.push_back (feature);
+    }
+
+    return;
+  }
+
+  int distance = static_cast<int> (list1.size () / nr_features + 1); // ???  @todo:!:!:!:!:!:!
+  while (list2.size () != nr_features)
+  {
+    const int sqr_distance = distance*distance;
+    for (typename std::list<Candidate>::iterator iter1 = list1.begin (); iter1 != list1.end (); ++iter1)
+    {
+      bool candidate_accepted = true;
+
+      for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+      {
+        const int dx = static_cast<int> (iter1->x) - static_cast<int> (iter2->x);
+        const int dy = static_cast<int> (iter1->y) - static_cast<int> (iter2->y);
+        const int tmp_distance = dx*dx + dy*dy;
+
+        if (tmp_distance < sqr_distance)
+        {
+          candidate_accepted = false;
+          break;
+        }
+      }
+
+      if (candidate_accepted)
+        list2.push_back (*iter1);
+
+      if (list2.size () == nr_features) break;
+    }
+    --distance;
+  }
+
+  for (typename std::list<Candidate>::iterator iter2 = list2.begin (); iter2 != list2.end (); ++iter2)
+  {
+    QuantizedMultiModFeature feature;
+
+    feature.x = static_cast<int> (iter2->x);
+    feature.y = static_cast<int> (iter2->y);
+    feature.modality_index = modality_index;
+    feature.quantized_value = filtered_quantized_colors_ (iter2->x, iter2->y);
+
+    features.push_back (feature);
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorModality<PointInT>::quantizeColors ()
+{
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  quantized_colors_.resize (width, height);
+
+  for (size_t row_index = 0; row_index < height; ++row_index)
+  {
+    for (size_t col_index = 0; col_index < width; ++col_index)
+    {
+      const float r = static_cast<float> ((*input_) (col_index, row_index).r);
+      const float g = static_cast<float> ((*input_) (col_index, row_index).g);
+      const float b = static_cast<float> ((*input_) (col_index, row_index).b);
+
+      quantized_colors_ (col_index, row_index) = quantizeColorOnRGBExtrema (r, g, b);
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+void
+pcl::ColorModality<PointInT>::filterQuantizedColors ()
+{
+  const size_t width = input_->width;
+  const size_t height = input_->height;
+
+  filtered_quantized_colors_.resize (width, height);
+
+  // filter data
+  for (size_t row_index = 1; row_index < height-1; ++row_index)
+  {
+    for (size_t col_index = 1; col_index < width-1; ++col_index)
+    {
+      unsigned char histogram[8] = {0,0,0,0,0,0,0,0};
+
+      {
+        const unsigned char * data_ptr = quantized_colors_.getData () + (row_index-1)*width+col_index-1;
+        assert (0 <= data_ptr[0] && data_ptr[0] < 9 && 
+                0 <= data_ptr[1] && data_ptr[1] < 9 && 
+                0 <= data_ptr[2] && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_colors_.getData () + row_index*width+col_index-1;
+        assert (0 <= data_ptr[0] && data_ptr[0] < 9 && 
+                0 <= data_ptr[1] && data_ptr[1] < 9 && 
+                0 <= data_ptr[2] && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+      {
+        const unsigned char * data_ptr = quantized_colors_.getData () + (row_index+1)*width+col_index-1;
+        assert (0 <= data_ptr[0] && data_ptr[0] < 9 && 
+                0 <= data_ptr[1] && data_ptr[1] < 9 && 
+                0 <= data_ptr[2] && data_ptr[2] < 9);
+        ++histogram[data_ptr[0]];
+        ++histogram[data_ptr[1]];
+        ++histogram[data_ptr[2]];
+      }
+
+      unsigned char max_hist_value = 0;
+      int max_hist_index = -1;
+
+      // for (int i = 0; i < 8; ++i)
+      // {
+      //   if (max_hist_value < histogram[i+1])
+      //   {
+      //     max_hist_index = i;
+      //     max_hist_value = histogram[i+1]
+      //   }
+      // }
+      // Unrolled for performance optimization:
+      if (max_hist_value < histogram[0]) {max_hist_index = 0; max_hist_value = histogram[0];}
+      if (max_hist_value < histogram[1]) {max_hist_index = 1; max_hist_value = histogram[1];}
+      if (max_hist_value < histogram[2]) {max_hist_index = 2; max_hist_value = histogram[2];}
+      if (max_hist_value < histogram[3]) {max_hist_index = 3; max_hist_value = histogram[3];}
+      if (max_hist_value < histogram[4]) {max_hist_index = 4; max_hist_value = histogram[4];}
+      if (max_hist_value < histogram[5]) {max_hist_index = 5; max_hist_value = histogram[5];}
+      if (max_hist_value < histogram[6]) {max_hist_index = 6; max_hist_value = histogram[6];}
+      if (max_hist_value < histogram[7]) {max_hist_index = 7; max_hist_value = histogram[7];}
+
+      //if (max_hist_index != -1 && max_hist_value >= 5)
+        filtered_quantized_colors_ (col_index, row_index) = 0x1 << max_hist_index;
+      //else
+      //  filtered_quantized_color_gradients_ (col_index, row_index) = 0;
+
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT>
+int
+pcl::ColorModality<PointInT>::quantizeColorOnRGBExtrema (const float r,
+                                                         const float g,
+                                                         const float b)
+{
+  const float r_inv = 255.0f-r;
+  const float g_inv = 255.0f-g;
+  const float b_inv = 255.0f-b;
+
+  const float dist_0 = (r*r + g*g + b*b)*2.0f;
+  const float dist_1 = r*r + g*g + b_inv*b_inv;
+  const float dist_2 = r*r + g_inv*g_inv+ b*b;
+  const float dist_3 = r*r + g_inv*g_inv + b_inv*b_inv;
+  const float dist_4 = r_inv*r_inv + g*g + b*b;
+  const float dist_5 = r_inv*r_inv + g*g + b_inv*b_inv;
+  const float dist_6 = r_inv*r_inv + g_inv*g_inv+ b*b;
+  const float dist_7 = (r_inv*r_inv + g_inv*g_inv + b_inv*b_inv)*1.5f;
+
+  const float min_dist = std::min (std::min (std::min (dist_0, dist_1), std::min (dist_2, dist_3)), std::min (std::min (dist_4, dist_5), std::min (dist_6, dist_7)));
+
+  if (min_dist == dist_0)
+  {
+    return 0;
+  }
+  if (min_dist == dist_1)
+  {
+    return 1;
+  }
+  if (min_dist == dist_2)
+  {
+    return 2;
+  }
+  if (min_dist == dist_3)
+  {
+    return 3;
+  }
+  if (min_dist == dist_4)
+  {
+    return 4;
+  }
+  if (min_dist == dist_5)
+  {
+    return 5;
+  }
+  if (min_dist == dist_6)
+  {
+    return 6;
+  }
+  return 7;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+template <typename PointInT> void
+pcl::ColorModality<PointInT>::computeDistanceMap (const MaskMap & input, 
+                                                  DistanceMap & output) const
+{
+  const size_t width = input.getWidth ();
+  const size_t height = input.getHeight ();
+
+  output.resize (width, height);
+
+  // compute distance map
+  //float *distance_map = new float[input_->points.size ()];
+  const unsigned char * mask_map = input.getData ();
+  float * distance_map = output.getData ();
+  for (size_t index = 0; index < width*height; ++index)
+  {
+    if (mask_map[index] == 0)
+      distance_map[index] = 0.0f;
+    else
+      distance_map[index] = static_cast<float> (width + height);
+  }
+
+  // first pass
+  float * previous_row = distance_map;
+  float * current_row = previous_row + width;
+  for (size_t ri = 1; ri < height; ++ri)
+  {
+    for (size_t ci = 1; ci < width; ++ci)
+    {
+      const float up_left  = previous_row [ci - 1] + 1.4f; //distance_map[(ri-1)*input_->width + ci-1] + 1.4f;
+      const float up       = previous_row [ci]     + 1.0f; //distance_map[(ri-1)*input_->width + ci] + 1.0f;
+      const float up_right = previous_row [ci + 1] + 1.4f; //distance_map[(ri-1)*input_->width + ci+1] + 1.4f;
+      const float left     = current_row  [ci - 1] + 1.0f; //distance_map[ri*input_->width + ci-1] + 1.0f;
+      const float center   = current_row  [ci];            //distance_map[ri*input_->width + ci];
+
+      const float min_value = std::min (std::min (up_left, up), std::min (left, up_right));
+
+      if (min_value < center)
+        current_row[ci] = min_value; //distance_map[ri * input_->width + ci] = min_value;
+    }
+    previous_row = current_row;
+    current_row += width;
+  }
+
+  // second pass
+  float * next_row = distance_map + width * (height - 1);
+  current_row = next_row - width;
+  for (int ri = static_cast<int> (height)-2; ri >= 0; --ri)
+  {
+    for (int ci = static_cast<int> (width)-2; ci >= 0; --ci)
+    {
+      const float lower_left  = next_row    [ci - 1] + 1.4f; //distance_map[(ri+1)*input_->width + ci-1] + 1.4f;
+      const float lower       = next_row    [ci]     + 1.0f; //distance_map[(ri+1)*input_->width + ci] + 1.0f;
+      const float lower_right = next_row    [ci + 1] + 1.4f; //distance_map[(ri+1)*input_->width + ci+1] + 1.4f;
+      const float right       = current_row [ci + 1] + 1.0f; //distance_map[ri*input_->width + ci+1] + 1.0f;
+      const float center      = current_row [ci];            //distance_map[ri*input_->width + ci];
+
+      const float min_value = std::min (std::min (lower_left, lower), std::min (right, lower_right));
+
+      if (min_value < center)
+        current_row[ci] = min_value; //distance_map[ri*input_->width + ci] = min_value;
+    }
+    next_row = current_row;
+    current_row -= width;
+  }
+}
+
+
+#endif 
+
+###
+
+# crh_alignment.h
+namespace pcl
+{
+
+  /** \brief CRHAlignment uses two Camera Roll Histograms (CRH) to find the
+   * roll rotation that aligns both views. See:
+   *   - CAD-Model Recognition and 6 DOF Pose Estimation
+   *     A. Aldoma, N. Blodow, D. Gossow, S. Gedikli, R.B. Rusu, M. Vincze and G. Bradski
+   *     ICCV 2011, 3D Representation and Recognition (3dRR11) workshop
+   *     Barcelona, Spain, (2011)
+   *
+   * \author Aitor Aldoma
+   * \ingroup recognition
+   */
+
+  template<typename PointT, int nbins_>
+    class PCL_EXPORTS CRHAlignment
+    {
+    private:
+
+      /** \brief Sorts peaks */
+      typedef struct
+      {
+        bool
+        operator() (std::pair<float, int> const& a, std::pair<float, int> const& b)
+        {
+          return a.first > b.first;
+        }
+      } peaks_ordering;
+
+      typedef typename pcl::PointCloud<PointT>::Ptr PointTPtr;
+
+      /** \brief View of the model to be aligned to input_view_ */
+      PointTPtr target_view_;
+      /** \brief View of the input */
+      PointTPtr input_view_;
+      /** \brief Centroid of the model_view_ */
+      Eigen::Vector3f centroid_target_;
+      /** \brief Centroid of the input_view_ */
+      Eigen::Vector3f centroid_input_;
+      /** \brief transforms from model view to input view */
+      std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > transforms_;
+      /** \brief Allowed maximum number of peaks  */
+      int max_peaks_;
+      /** \brief Quantile of peaks after sorting to be checked  */
+      float quantile_;
+      /** \brief Threshold for a peak to be accepted.
+       * If peak_i >= (max_peak * accept_threhsold_) => peak is accepted
+       */
+      float accept_threshold_;
+
+      /** \brief computes the transformation to the z-axis
+        * \param[in] centroid
+        * \param[out] trasnformation to z-axis
+        */
+      void
+      computeTransformToZAxes (Eigen::Vector3f & centroid, Eigen::Affine3f & transform)
+      {
+        Eigen::Vector3f plane_normal;
+        plane_normal[0] = -centroid[0];
+        plane_normal[1] = -centroid[1];
+        plane_normal[2] = -centroid[2];
+        Eigen::Vector3f z_vector = Eigen::Vector3f::UnitZ ();
+        plane_normal.normalize ();
+        Eigen::Vector3f axis = plane_normal.cross (z_vector);
+        double rotation = -asin (axis.norm ());
+        axis.normalize ();
+        transform = Eigen::Affine3f (Eigen::AngleAxisf (static_cast<float>(rotation), axis));
+      }
+
+      /** \brief computes the roll transformation
+        * \param[in] centroid input
+        * \param[in] centroid view
+        * \param[in] roll_angle
+        * \param[out] roll transformation
+        */
+      void
+      computeRollTransform (Eigen::Vector3f & centroidInput, Eigen::Vector3f & centroidResult, double roll_angle, Eigen::Affine3f & final_trans)
+      {
+        Eigen::Affine3f transformInputToZ;
+        computeTransformToZAxes (centroidInput, transformInputToZ);
+
+        transformInputToZ = transformInputToZ.inverse ();
+        Eigen::Affine3f transformRoll (Eigen::AngleAxisf (-static_cast<float>(roll_angle * M_PI / 180), Eigen::Vector3f::UnitZ ()));
+        Eigen::Affine3f transformDBResultToZ;
+        computeTransformToZAxes (centroidResult, transformDBResultToZ);
+
+        final_trans = transformInputToZ * transformRoll * transformDBResultToZ;
+      }
+    public:
+
+      /** \brief Constructor. */
+      CRHAlignment() {
+        max_peaks_ = 5;
+        quantile_ = 0.2f;
+        accept_threshold_ = 0.8f;
+      }
+
+      /** \brief returns the computed transformations
+       * \param[out] transforms transformations
+       */
+      void getTransforms(std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > & transforms) {
+        transforms = transforms_;
+      }
+
+      /** \brief sets model and input views
+       * \param[in] input_view
+       * \param[in] target_view
+       */
+      void
+      setInputAndTargetView (PointTPtr & input_view, PointTPtr & target_view)
+      {
+        target_view_ = target_view;
+        input_view_ = input_view;
+      }
+
+      /** \brief sets model and input centroids
+        * \param[in] c1 model view centroid
+        * \param[in] c2 input view centroid
+        */
+      void
+      setInputAndTargetCentroids (Eigen::Vector3f & c1, Eigen::Vector3f & c2)
+      {
+        centroid_target_ = c2;
+        centroid_input_ = c1;
+      }
+
+      /** \brief Computes the transformation aligning model to input
+       * \param[in] input_ftt CRH histogram of the input cloud
+       * \param[in] target_ftt CRH histogram of the target cloud
+       */
+      void
+      align (pcl::PointCloud<pcl::Histogram<nbins_> > & input_ftt, pcl::PointCloud<pcl::Histogram<nbins_> > & target_ftt)
+      {
+
+        transforms_.clear(); //clear from last round...
+
+        std::vector<float> peaks;
+        computeRollAngle (input_ftt, target_ftt, peaks);
+
+        //if the number of peaks is too big, we should try to reduce using siluette matching
+
+        for (size_t i = 0; i < peaks.size(); i++)
+        {
+          Eigen::Affine3f rollToRot;
+          computeRollTransform (centroid_input_, centroid_target_, peaks[i], rollToRot);
+
+          Eigen::Matrix4f rollHomMatrix = Eigen::Matrix4f ();
+          rollHomMatrix.setIdentity (4, 4);
+          rollHomMatrix = rollToRot.matrix ();
+
+          Eigen::Matrix4f translation2;
+          translation2.setIdentity (4, 4);
+          Eigen::Vector3f centr = rollToRot * centroid_target_;
+          translation2 (0, 3) = centroid_input_[0] - centr[0];
+          translation2 (1, 3) = centroid_input_[1] - centr[1];
+          translation2 (2, 3) = centroid_input_[2] - centr[2];
+
+          Eigen::Matrix4f resultHom (translation2 * rollHomMatrix);
+          transforms_.push_back(resultHom.inverse());
+        }
+
+      }
+
+      /** \brief Computes the roll angle that aligns input to modle.
+       * \param[in] input_ftt CRH histogram of the input cloud
+       * \param[in] target_ftt CRH histogram of the target cloud
+       * \param[out] peaks Vector containing angles where the histograms correlate
+       */
+      void
+      computeRollAngle (pcl::PointCloud<pcl::Histogram<nbins_> > & input_ftt, pcl::PointCloud<pcl::Histogram<nbins_> > & target_ftt,
+                        std::vector<float> & peaks)
+      {
+
+        pcl::PointCloud<pcl::Histogram<nbins_> > input_ftt_negate (input_ftt);
+
+        for (int i = 2; i < (nbins_); i += 2)
+          input_ftt_negate.points[0].histogram[i] = -input_ftt_negate.points[0].histogram[i];
+
+        int nr_bins_after_padding = 180;
+        int peak_distance = 5;
+        int cutoff = nbins_ - 1;
+
+        kiss_fft_cpx * multAB = new kiss_fft_cpx[nr_bins_after_padding];
+        for (int i = 0; i < nr_bins_after_padding; i++)
+          multAB[i].r = multAB[i].i = 0.f;
+
+        int k = 0;
+        multAB[k].r = input_ftt_negate.points[0].histogram[0] * target_ftt.points[0].histogram[0];
+        k++;
+
+        float a, b, c, d;
+        for (int i = 1; i < cutoff; i += 2, k++)
+        {
+          a = input_ftt_negate.points[0].histogram[i];
+          b = input_ftt_negate.points[0].histogram[i + 1];
+          c = target_ftt.points[0].histogram[i];
+          d = target_ftt.points[0].histogram[i + 1];
+          multAB[k].r = a * c - b * d;
+          multAB[k].i = b * c + a * d;
+
+          float tmp = sqrtf (multAB[k].r * multAB[k].r + multAB[k].i * multAB[k].i);
+
+          multAB[k].r /= tmp;
+          multAB[k].i /= tmp;
+        }
+
+        multAB[nbins_ - 1].r = input_ftt_negate.points[0].histogram[nbins_ - 1] * target_ftt.points[0].histogram[nbins_ - 1];
+
+        kiss_fft_cfg mycfg = kiss_fft_alloc (nr_bins_after_padding, 1, NULL, NULL);
+        kiss_fft_cpx * invAB = new kiss_fft_cpx[nr_bins_after_padding];
+        kiss_fft (mycfg, multAB, invAB);
+
+        std::vector < std::pair<float, int> > scored_peaks (nr_bins_after_padding);
+        for (int i = 0; i < nr_bins_after_padding; i++)
+          scored_peaks[i] = std::make_pair (invAB[i].r, i);
+
+        std::sort (scored_peaks.begin (), scored_peaks.end (), peaks_ordering ());
+
+        std::vector<int> peaks_indices;
+        std::vector<float> peaks_values;
+
+        // we look at the upper quantile_
+        float quantile = quantile_;
+        int max_inserted= max_peaks_;
+
+        int inserted=0;
+        bool stop=false;
+        for (int i = 0; (i < static_cast<int> (quantile * static_cast<float> (nr_bins_after_padding))) && !stop; i++)
+        {
+          if (scored_peaks[i].first >= scored_peaks[0].first * accept_threshold_)
+          {
+            bool insert = true;
+
+            for (size_t j = 0; j < peaks_indices.size (); j++)
+            { //check inserted peaks, first pick always inserted
+              if (std::abs (peaks_indices[j] - scored_peaks[i].second) <= peak_distance || std::abs (
+                                                                                             peaks_indices[j] - (scored_peaks[i].second
+                                                                                                 - nr_bins_after_padding)) <= peak_distance)
+              {
+                insert = false;
+                break;
+              }
+            }
+
+            if (insert)
+            {
+              peaks_indices.push_back (scored_peaks[i].second);
+              peaks_values.push_back (scored_peaks[i].first);
+              peaks.push_back (static_cast<float> (scored_peaks[i].second * (360 / nr_bins_after_padding)));
+              inserted++;
+              if(inserted >= max_inserted)
+                stop = true;
+            }
+          }
+        }
+      }
+    };
+}
+
+#endif /* CRH_ALIGNMENT_H_ */
+###
+
+# dense_quantized_multi_mod_template.h
+namespace pcl
+{
+
+  struct DenseQuantizedSingleModTemplate
+  {
+    std::vector<unsigned char> features;
+
+    void 
+    serialize (std::ostream & stream) const
+    {
+      const size_t num_of_features = static_cast<size_t> (features.size ());
+      write (stream, num_of_features);
+      for (size_t feature_index = 0; feature_index < num_of_features; ++feature_index)
+      {
+        write (stream, features[feature_index]);
+      }
+    }
+
+    void 
+    deserialize (std::istream & stream)
+    {
+      features.clear ();
+
+      size_t num_of_features;
+      read (stream, num_of_features);
+      features.resize (num_of_features);
+      for (size_t feature_index = 0; feature_index < num_of_features; ++feature_index)
+      {
+        read (stream, features[feature_index]);
+      }
+    }
+  };
+
+  struct DenseQuantizedMultiModTemplate
+  {
+    std::vector<DenseQuantizedSingleModTemplate> modalities;
+    float response_factor;
+
+    RegionXY region;
+
+    void 
+    serialize (std::ostream & stream) const
+    {
+      const size_t num_of_modalities = static_cast<size_t> (modalities.size ());
+      write (stream, num_of_modalities);
+      for (size_t modality_index = 0; modality_index < num_of_modalities; ++modality_index)
+      {
+        modalities[modality_index].serialize (stream);
+      }
+
+      region.serialize (stream);
+    }
+
+    void 
+    deserialize (std::istream & stream)
+    {
+      modalities.clear ();
+
+      size_t num_of_modalities;
+      read (stream, num_of_modalities);
+      modalities.resize (num_of_modalities);
+      for (size_t modality_index = 0; modality_index < num_of_modalities; ++modality_index)
+      {
+        modalities[modality_index].deserialize (stream);
+      }
+
+      region.deserialize (stream);
+    }
+  };
+
+}
+
+#endif 
+###
+
+# distance_map.h
+namespace pcl
+{
+
+  /** \brief Represents a distance map obtained from a distance transformation. 
+    * \author Stefan Holzer
+    */
+  class DistanceMap
+  {
+    public:
+      /** \brief Constructor. */
+      DistanceMap () : data_ (0), width_ (0), height_ (0) {}
+      /** \brief Destructor. */
+      virtual ~DistanceMap () {}
+
+      /** \brief Returns the width of the map. */
+      inline size_t 
+      getWidth () const
+      {
+        return (width_); 
+      }
+
+      /** \brief Returns the height of the map. */
+      inline size_t 
+      getHeight () const
+      { 
+        return (height_); 
+      }
+    
+      /** \brief Returns a pointer to the beginning of map. */
+      inline float * 
+      getData () 
+      { 
+        return (&data_[0]); 
+      }
+
+      /** \brief Resizes the map to the specified size.
+        * \param[in] width the new width of the map.
+        * \param[in] height the new height of the map.
+        */
+      void 
+      resize (const size_t width, const size_t height)
+      {
+        data_.resize (width*height);
+        width_ = width;
+        height_ = height;
+      }
+
+      /** \brief Operator to access an element of the map.
+        * \param[in] col_index the column index of the element to access.
+        * \param[in] row_index the row index of the element to access.
+        */
+      inline float & 
+      operator() (const size_t col_index, const size_t row_index)
+      {
+        return (data_[row_index*width_ + col_index]);
+      }
+
+      /** \brief Operator to access an element of the map.
+        * \param[in] col_index the column index of the element to access.
+        * \param[in] row_index the row index of the element to access.
+        */
+      inline const float & 
+      operator() (const size_t col_index, const size_t row_index) const
+      {
+        return (data_[row_index*width_ + col_index]);
+      }
+
+    protected:
+      /** \brief The storage for the distance map data. */
+      std::vector<float> data_;
+      /** \brief The width of the map. */
+      size_t width_;
+      /** \brief The height of the map. */
+      size_t height_;
+  };
+
+}
+
+
+#endif 
+
+###
+
+# dotmod.h
+namespace pcl
+{
+  class PCL_EXPORTS DOTModality
+  {
+    public:
+
+      virtual ~DOTModality () {};
+
+      //virtual QuantizedMap &
+      //getDominantQuantizedMap () = 0;
+
+      virtual QuantizedMap &
+      getDominantQuantizedMap () = 0;
+
+      virtual QuantizedMap
+      computeInvariantQuantizedMap (const MaskMap & mask,
+                                    const RegionXY & region) = 0;
+
+  };
+}
+
+#endif    // PCL_FEATURES_DOT_MODALITY
+
+###
+
+# dot_modality.h
+namespace pcl
+{
+
+  struct DOTMODDetection
+  {
+    size_t bin_x;
+    size_t bin_y;
+    size_t template_id;
+    float score;
+  };
+
+  /**
+    * \brief Template matching using the DOTMOD approach.
+    * \author Stefan Holzer, Stefan Hinterstoisser
+    */
+  class PCL_EXPORTS DOTMOD
+  {
+    public:
+      /** \brief Constructor */
+      DOTMOD (size_t template_width,
+              size_t template_height);
+
+      /** \brief Destructor */
+      virtual ~DOTMOD ();
+
+      /** \brief Creates a template from the specified data and adds it to the matching queue. 
+        * \param modalities
+        * \param masks
+        * \param template_anker_x
+        * \param template_anker_y
+        * \param region
+        */
+      size_t 
+      createAndAddTemplate (const std::vector<DOTModality*> & modalities,
+                            const std::vector<MaskMap*> & masks,
+                            size_t template_anker_x,
+                            size_t template_anker_y,
+                            const RegionXY & region);
+
+      void
+      detectTemplates (const std::vector<DOTModality*> & modalities,
+                       float template_response_threshold,
+                       std::vector<DOTMODDetection> & detections,
+                       const size_t bin_size) const;
+
+      inline const DenseQuantizedMultiModTemplate &
+      getTemplate (size_t template_id) const
+      { 
+        return (templates_[template_id]);
+      }
+
+      inline size_t
+      getNumOfTemplates ()
+      {
+        return (templates_.size ());
+      }
+
+      void
+      saveTemplates (const char * file_name) const;
+
+      void
+      loadTemplates (const char * file_name);
+
+      void 
+      serialize (std::ostream & stream) const;
+
+      void 
+      deserialize (std::istream & stream);
+
+
+    private:
+      /** template width */
+      size_t template_width_;
+      /** template height */
+      size_t template_height_;
+      /** template storage */
+      std::vector<DenseQuantizedMultiModTemplate> templates_;
+  };
+
+}
+
+#endif 
+
+###
+
+# hypothesis.h
+# ransac_based
+namespace pcl
+{
+  namespace recognition
+  {
+    class HypothesisBase
+    {
+      public:
+        HypothesisBase (const ModelLibrary::Model* obj_model)
+        : obj_model_ (obj_model)
+        {}
+
+        HypothesisBase (const ModelLibrary::Model* obj_model, const float* rigid_transform)
+        : obj_model_ (obj_model)
+        {
+          memcpy (rigid_transform_, rigid_transform, 12*sizeof (float));
+        }
+
+        virtual  ~HypothesisBase (){}
+
+        void
+        setModel (const ModelLibrary::Model* model)
+        {
+          obj_model_ = model;
+        }
+
+      public:
+        float rigid_transform_[12];
+        const ModelLibrary::Model* obj_model_;
+    };
+
+    class Hypothesis: public HypothesisBase
+    {
+      public:
+        Hypothesis (const ModelLibrary::Model* obj_model = NULL)
+         : HypothesisBase (obj_model),
+           match_confidence_ (-1.0f),
+           linear_id_ (-1)
+        {
+        }
+
+        Hypothesis (const Hypothesis& src)
+        : HypothesisBase (src.obj_model_, src.rigid_transform_),
+          match_confidence_  (src.match_confidence_),
+          explained_pixels_ (src.explained_pixels_)
+        {
+        }
+
+        virtual ~Hypothesis (){}
+
+        const Hypothesis&
+        operator =(const Hypothesis& src)
+        {
+          memcpy (this->rigid_transform_, src.rigid_transform_, 12*sizeof (float));
+          this->obj_model_  = src.obj_model_;
+          this->match_confidence_  = src.match_confidence_;
+          this->explained_pixels_ = src.explained_pixels_;
+
+          return *this;
+        }
+
+        void
+        setLinearId (int id)
+        {
+          linear_id_ = id;
+        }
+
+        int
+        getLinearId () const
+        {
+          return (linear_id_);
+        }
+
+        void
+        computeBounds (float bounds[6]) const
+        {
+          const float *b = obj_model_->getBoundsOfOctreePoints ();
+          float p[3];
+
+          // Initialize 'bounds'
+          aux::transform (rigid_transform_, b[0], b[2], b[4], p);
+          bounds[0] = bounds[1] = p[0];
+          bounds[2] = bounds[3] = p[1];
+          bounds[4] = bounds[5] = p[2];
+
+          // Expand 'bounds' to contain the other 7 points of the octree bounding box
+          aux::transform (rigid_transform_, b[0], b[2], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[0], b[3], b[4], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[0], b[3], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[2], b[4], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[2], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[3], b[4], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+          aux::transform (rigid_transform_, b[1], b[3], b[5], p); aux::expandBoundingBoxToContainPoint (bounds, p);
+        }
+
+        void
+        computeCenterOfMass (float center_of_mass[3]) const
+        {
+          aux::transform (rigid_transform_, obj_model_->getOctreeCenterOfMass (), center_of_mass);
+        }
+
+      public:
+        float match_confidence_;
+        std::set<int> explained_pixels_;
+        int linear_id_;
+    };
+  } // namespace recognition
+} // namespace pcl
+
+#endif /* PCL_RECOGNITION_HYPOTHESIS_H_ */
+###
+
+# implicit_shape_model.h
+namespace pcl
+{
+  /** \brief This struct is used for storing peak. */
+  struct ISMPeak
+  {
+    /** \brief Point were this peak is located. */
+    PCL_ADD_POINT4D;
+
+    /** \brief Density of this peak. */
+    double density;
+
+    /** \brief Determines which class this peak belongs. */
+    int class_id;
+
+    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+  } EIGEN_ALIGN16;
+
+  namespace features
+  {
+    /** \brief This class is used for storing, analyzing and manipulating votes
+      * obtained from ISM algorithm. */
+    template <typename PointT>
+    class PCL_EXPORTS ISMVoteList
+    {
+      public:
+
+        /** \brief Empty constructor with member variables initialization. */
+        ISMVoteList ();
+
+        /** \brief virtual descriptor. */
+        virtual
+        ~ISMVoteList ();
+
+        /** \brief This method simply adds another vote to the list.
+          * \param[in] in_vote vote to add
+          * \param[in] vote_origin origin of the added vote
+          * \param[in] in_class class for which this vote is cast
+          */
+        void
+        addVote (pcl::InterestPoint& in_vote, const PointT &vote_origin, int in_class);
+
+        /** \brief Returns the colored cloud that consists of votes for center (blue points) and
+          * initial point cloud (if it was passed).
+          * \param[in] cloud cloud that needs to be merged with votes for visualizing. */
+        typename pcl::PointCloud<pcl::PointXYZRGB>::Ptr
+        getColoredCloud (typename pcl::PointCloud<PointT>::Ptr cloud = 0);
+
+        /** \brief This method finds the strongest peaks (points were density has most higher values).
+          * It is based on the non maxima supression principles.
+          * \param[out] out_peaks it will contain the strongest peaks
+          * \param[in] in_class_id class of interest for which peaks are evaluated
+          * \param[in] in_non_maxima_radius non maxima supression radius. The shapes radius is recommended for this value.
+          * \param in_sigma
+          */
+        void
+        findStrongestPeaks (std::vector<ISMPeak, Eigen::aligned_allocator<ISMPeak> > &out_peaks, int in_class_id, double in_non_maxima_radius, double in_sigma);
+
+        /** \brief Returns the density at the specified point.
+          * \param[in] point point of interest
+          * \param[in] sigma_dist
+          */
+        double
+        getDensityAtPoint (const PointT &point, double sigma_dist);
+
+        /** \brief This method simply returns the number of votes. */
+        unsigned int
+        getNumberOfVotes ();
+
+      protected:
+
+        /** \brief this method is simply setting up the search tree. */
+        void
+        validateTree ();
+
+        Eigen::Vector3f
+        shiftMean (const Eigen::Vector3f& snapPt, const double in_dSigmaDist);
+
+      protected:
+
+        /** \brief Stores all votes. */
+        pcl::PointCloud<pcl::InterestPoint>::Ptr votes_;
+
+        /** \brief Signalizes if the tree is valid. */
+        bool tree_is_valid_;
+
+        /** \brief Stores the origins of the votes. */
+        typename pcl::PointCloud<PointT>::Ptr votes_origins_;
+
+        /** \brief Stores classes for which every single vote was cast. */
+        std::vector<int> votes_class_;
+
+        /** \brief Stores the search tree. */
+        pcl::KdTreeFLANN<pcl::InterestPoint>::Ptr tree_;
+
+        /** \brief Stores neighbours indices. */
+        std::vector<int> k_ind_;
+
+        /** \brief Stores square distances to the corresponding neighbours. */
+        std::vector<float> k_sqr_dist_;
+    };
+ 
+    /** \brief The assignment of this structure is to store the statistical/learned weights and other information
+      * of the trained Implict Shape Model algorithm.
+      */
+    struct PCL_EXPORTS ISMModel
+    {
+      /** \brief Simple constructor that initializes the structure. */
+      ISMModel ();
+
+      /** \brief Copy constructor for deep copy. */
+      ISMModel (ISMModel const & copy);
+
+      /** Destructor that frees memory. */
+      virtual
+      ~ISMModel ();
+
+      /** \brief This method simply saves the trained model for later usage.
+        * \param[in] file_name path to file for saving model
+        */
+      bool
+      saveModelToFile (std::string& file_name);
+
+      /** \brief This method loads the trained model from file.
+        * \param[in] file_name path to file which stores trained model
+        */
+      bool
+      loadModelFromfile (std::string& file_name);
+
+      /** \brief this method resets all variables and frees memory. */
+      void
+      reset ();
+
+      /** Operator overloading for deep copy. */
+      ISMModel & operator = (const ISMModel& other);
+
+      /** \brief Stores statistical weights. */
+      std::vector<std::vector<float> > statistical_weights_;
+
+      /** \brief Stores learned weights. */
+      std::vector<float> learned_weights_;
+
+      /** \brief Stores the class label for every direction. */
+      std::vector<unsigned int> classes_;
+
+      /** \brief Stores the sigma value for each class. This values were used to compute the learned weights. */
+      std::vector<float> sigmas_;
+
+      /** \brief Stores the directions to objects center for each visual word. */
+      Eigen::MatrixXf directions_to_center_;
+
+      /** \brief Stores the centers of the clusters that were obtained during the visual words clusterization. */
+      Eigen::MatrixXf clusters_centers_;
+
+      /** \brief This is an array of clusters. Each cluster stores the indices of the visual words that it contains. */
+      std::vector<std::vector<unsigned int> > clusters_;
+
+      /** \brief Stores the number of classes. */
+      unsigned int number_of_classes_;
+
+      /** \brief Stores the number of visual words. */
+      unsigned int number_of_visual_words_;
+
+      /** \brief Stores the number of clusters. */
+      unsigned int number_of_clusters_;
+
+      /** \brief Stores descriptors dimension. */
+      unsigned int descriptors_dimension_;
+
+      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+    };
+  }
+
+  namespace ism
+  {
+    /** \brief This class implements Implicit Shape Model algorithm described in
+      * "Hough Transforms and 3D SURF for robust three dimensional classication"
+      * by Jan Knopp1, Mukta Prasad, Geert Willems1, Radu Timofte, and Luc Van Gool.
+      * It has two main member functions. One for training, using the data for which we know
+      * which class it belongs to. And second for investigating a cloud for the presence
+      * of the class of interest.
+      * Implementation of the ISM algorithm described in "Hough Transforms and 3D SURF for robust three dimensional classication"
+      * by Jan Knopp, Mukta Prasad, Geert Willems, Radu Timofte, and Luc Van Gool
+      *
+      * Authors: Roman Shapovalov, Alexander Velizhev, Sergey Ushakov
+      */
+    template <int FeatureSize, typename PointT, typename NormalT = pcl::Normal>
+    class PCL_EXPORTS ImplicitShapeModelEstimation
+    {
+      public:
+
+        typedef boost::shared_ptr<pcl::features::ISMModel> ISMModelPtr;
+
+      protected:
+
+        /** \brief This structure stores the information about the keypoint. */
+        struct PCL_EXPORTS LocationInfo
+        {
+          /** \brief Location info constructor.
+            * \param[in] model_num number of training model.
+            * \param[in] dir_to_center expected direction to center
+            * \param[in] origin initial point
+            * \param[in] normal normal of the initial point
+            */
+          LocationInfo (unsigned int model_num, const PointT& dir_to_center, const PointT& origin, const NormalT& normal) :
+            model_num_ (model_num),
+            dir_to_center_ (dir_to_center),
+            point_ (origin),
+            normal_ (normal) {};
+
+          /** \brief Tells from which training model this keypoint was extracted. */
+          unsigned int model_num_;
+
+          /** \brief Expected direction to center for this keypoint. */
+          PointT dir_to_center_;
+
+          /** \brief Stores the initial point. */
+          PointT point_;
+
+          /** \brief Stores the normal of the initial point. */
+          NormalT normal_;
+        };
+
+        /** \brief This structure is used for determining the end of the
+          * k-means clustering process. */
+        typedef struct PCL_EXPORTS TC
+        {
+          enum
+          {
+            COUNT = 1,
+            EPS = 2
+          };
+
+          /** \brief Termination criteria constructor.
+            * \param[in] type defines the condition of termination(max iter., desired accuracy)
+            * \param[in] max_count defines the max number of iterations
+            * \param[in] epsilon defines the desired accuracy
+            */
+          TC(int type, int max_count, float epsilon) :
+            type_ (type),
+            max_count_ (max_count),
+            epsilon_ (epsilon) {};
+
+          /** \brief Flag that determines when the k-means clustering must be stopped.
+            * If type_ equals COUNT then it must be stopped when the max number of iterations will be
+            * reached. If type_ eaquals EPS then it must be stopped when the desired accuracy will be reached.
+            * These flags can be used together, in that case the clustering will be finished when one of these
+            * conditions will be reached.
+            */
+          int type_;
+
+          /** \brief Defines maximum number of iterations for k-means clustering. */
+          int max_count_;
+
+          /** \brief Defines the accuracy for k-means clustering. */
+          float epsilon_;
+        } TermCriteria;
+
+        /** \brief Structure for storing the visual word. */
+        struct PCL_EXPORTS VisualWordStat
+        {
+          /** \brief Empty constructor with member variables initialization. */
+          VisualWordStat () :
+            class_ (-1),
+            learned_weight_ (0.0f),
+            dir_to_center_ (0.0f, 0.0f, 0.0f) {};
+
+          /** \brief Which class this vote belongs. */
+          int class_;
+
+          /** \brief Weight of the vote. */
+          float learned_weight_;
+
+          /** \brief Expected direction to center. */
+          pcl::PointXYZ dir_to_center_;
+        };
+
+      public:
+
+        /** \brief Simple constructor that initializes everything. */
+        ImplicitShapeModelEstimation ();
+
+        /** \brief Simple destructor. */
+        virtual
+        ~ImplicitShapeModelEstimation ();
+
+        /** \brief This method simply returns the clouds that were set as the training clouds. */
+        std::vector<typename pcl::PointCloud<PointT>::Ptr>
+        getTrainingClouds ();
+
+        /** \brief Allows to set clouds for training the ISM model.
+          * \param[in] training_clouds array of point clouds for training
+          */
+        void
+        setTrainingClouds (const std::vector< typename pcl::PointCloud<PointT>::Ptr >& training_clouds);
+
+        /** \brief Returns the array of classes that indicates which class the corresponding training cloud belongs. */
+        std::vector<unsigned int>
+        getTrainingClasses ();
+
+        /** \brief Allows to set the class labels for the corresponding training clouds.
+          * \param[in] training_classes array of class labels
+          */
+        void
+        setTrainingClasses (const std::vector<unsigned int>& training_classes);
+
+        /** \brief This method returns the coresponding cloud of normals for every training point cloud. */
+        std::vector<typename pcl::PointCloud<NormalT>::Ptr>
+        getTrainingNormals ();
+
+        /** \brief Allows to set normals for the training clouds that were passed through setTrainingClouds method.
+          * \param[in] training_normals array of clouds, each cloud is the cloud of normals
+          */
+        void
+        setTrainingNormals (const std::vector< typename pcl::PointCloud<NormalT>::Ptr >& training_normals);
+
+        /** \brief Returns the sampling size used for cloud simplification. */
+        float
+        getSamplingSize ();
+
+        /** \brief Changes the sampling size used for cloud simplification.
+          * \param[in] sampling_size desired size of grid bin
+          */
+        void
+        setSamplingSize (float sampling_size);
+
+        /** \brief Returns the current feature estimator used for extraction of the descriptors. */
+        boost::shared_ptr<pcl::Feature<PointT, pcl::Histogram<FeatureSize> > >
+        getFeatureEstimator ();
+
+        /** \brief Changes the feature estimator.
+          * \param[in] feature feature estimator that will be used to extract the descriptors.
+          * Note that it must be fully initialized and configured.
+          */
+        void
+        setFeatureEstimator (boost::shared_ptr<pcl::Feature<PointT, pcl::Histogram<FeatureSize> > > feature);
+
+        /** \brief Returns the number of clusters used for descriptor clustering. */
+        unsigned int
+        getNumberOfClusters ();
+
+        /** \brief Changes the number of clusters.
+          * \param num_of_clusters desired number of clusters
+          */
+        void
+        setNumberOfClusters (unsigned int num_of_clusters);
+
+        /** \brief Returns the array of sigma values. */
+        std::vector<float>
+        getSigmaDists ();
+
+        /** \brief This method allows to set the value of sigma used for calculating the learned weights for every single class.
+          * \param[in] training_sigmas new sigmas for every class. If you want these values to be computed automatically,
+          * just pass the empty array. The automatic regime calculates the maximum distance between the objects points and takes 10% of
+          * this value as recomended in the article. If there are several objects of the same class,
+          * then it computes the average maximum distance and takes 10%. Note that each class has its own sigma value.
+          */
+        void
+        setSigmaDists (const std::vector<float>& training_sigmas);
+
+        /** \brief Returns the state of Nvot coeff from [Knopp et al., 2010, (4)],
+          * if set to false then coeff is taken as 1.0. It is just a kind of heuristic.
+          * The default behavior is as in the article. So you can ignore this if you want.
+          */
+        bool
+        getNVotState ();
+
+        /** \brief Changes the state of the Nvot coeff from [Knopp et al., 2010, (4)].
+          * \param[in] state desired state, if false then Nvot is taken as 1.0
+          */
+        void
+        setNVotState (bool state);
+
+        /** \brief This method performs training and forms a visual vocabulary. It returns a trained model that
+          * can be saved to file for later usage.
+          * \param[out] trained_model trained model
+          */
+        bool
+        trainISM (ISMModelPtr& trained_model);
+
+        /** \brief This function is searching for the class of interest in a given cloud
+          * and returns the list of votes.
+          * \param[in] model trained model which will be used for searching the objects
+          * \param[in] in_cloud input cloud that need to be investigated
+          * \param[in] in_normals cloud of normals coresponding to the input cloud
+          * \param[in] in_class_of_interest class which we are looking for
+          */
+        boost::shared_ptr<pcl::features::ISMVoteList<PointT> >
+        findObjects (ISMModelPtr model, typename pcl::PointCloud<PointT>::Ptr in_cloud, typename pcl::PointCloud<Normal>::Ptr in_normals, int in_class_of_interest);
+
+      protected:
+
+        /** \brief Extracts the descriptors from the input clouds.
+          * \param[out] histograms it will store the descriptors for each key point
+          * \param[out] locations it will contain the comprehensive information (such as direction, initial keypoint)
+          * for the corresponding descriptors
+          */
+        bool
+        extractDescriptors (std::vector<pcl::Histogram<FeatureSize> >& histograms,
+                            std::vector<LocationInfo, Eigen::aligned_allocator<LocationInfo> >& locations);
+
+        /** \brief This method performs descriptor clustering.
+          * \param[in] histograms descriptors to cluster
+          * \param[out] labels it contains labels for each descriptor
+          * \param[out] clusters_centers stores the centers of clusters
+          */
+        bool
+        clusterDescriptors (std::vector< pcl::Histogram<FeatureSize> >& histograms, Eigen::MatrixXi& labels, Eigen::MatrixXf& clusters_centers);
+
+        /** \brief This method calculates the value of sigma used for calculating the learned weights for every single class.
+          * \param[out] sigmas computed sigmas.
+          */
+        void
+        calculateSigmas (std::vector<float>& sigmas);
+
+        /** \brief This function forms a visual vocabulary and evaluates weights
+          * described in [Knopp et al., 2010, (5)].
+          * \param[in] locations array containing description of each keypoint: its position, which cloud belongs
+          * and expected direction to center
+          * \param[in] labels labels that were obtained during k-means clustering
+          * \param[in] sigmas array of sigmas for each class
+          * \param[in] clusters clusters that were obtained during k-means clustering
+          * \param[out] statistical_weights stores the computed statistical weights
+          * \param[out] learned_weights stores the computed learned weights
+          */
+        void
+        calculateWeights (const std::vector< LocationInfo, Eigen::aligned_allocator<LocationInfo> >& locations,
+                          const Eigen::MatrixXi &labels,
+                          std::vector<float>& sigmas,
+                          std::vector<std::vector<unsigned int> >& clusters,
+                          std::vector<std::vector<float> >& statistical_weights,
+                          std::vector<float>& learned_weights);
+
+        /** \brief Simplifies the cloud using voxel grid principles.
+          * \param[in] in_point_cloud cloud that need to be simplified
+          * \param[in] in_normal_cloud normals of the cloud that need to be simplified
+          * \param[out] out_sampled_point_cloud simplified cloud
+          * \param[out] out_sampled_normal_cloud and the corresponding normals
+          */
+        void
+        simplifyCloud (typename pcl::PointCloud<PointT>::ConstPtr in_point_cloud,
+                       typename pcl::PointCloud<NormalT>::ConstPtr in_normal_cloud,
+                       typename pcl::PointCloud<PointT>::Ptr out_sampled_point_cloud,
+                       typename pcl::PointCloud<NormalT>::Ptr out_sampled_normal_cloud);
+
+        /** \brief This method simply shifts the clouds points relative to the passed point.
+          * \param[in] in_cloud cloud to shift
+          * \param[in] shift_point point relative to which the cloud will be shifted
+          */
+        void
+        shiftCloud (typename pcl::PointCloud<PointT>::Ptr in_cloud, Eigen::Vector3f shift_point);
+
+        /** \brief This method simply computes the rotation matrix, so that the given normal
+          * would match the Y axis after the transformation. This is done because the algorithm needs to be invariant
+          * to the affine transformations.
+          * \param[in] in_normal normal for which the rotation matrix need to be computed
+          */
+        Eigen::Matrix3f
+        alignYCoordWithNormal (const NormalT& in_normal);
+
+        /** \brief This method applies transform set in in_transform to vector io_vector.
+          * \param[in] io_vec vector that need to be transformed
+          * \param[in] in_transform matrix that contains the transformation
+          */
+        void
+        applyTransform (Eigen::Vector3f& io_vec, const Eigen::Matrix3f& in_transform);
+
+        /** \brief This method estimates features for the given point cloud.
+          * \param[in] sampled_point_cloud sampled point cloud for which the features must be computed
+          * \param[in] normal_cloud normals for the original point cloud
+          * \param[out] feature_cloud it will store the computed histograms (features) for the given cloud
+          */
+        void
+        estimateFeatures (typename pcl::PointCloud<PointT>::Ptr sampled_point_cloud,
+                          typename pcl::PointCloud<NormalT>::Ptr normal_cloud,
+                          typename pcl::PointCloud<pcl::Histogram<FeatureSize> >::Ptr feature_cloud);
+
+        /** \brief Performs K-means clustering.
+          * \param[in] points_to_cluster points to cluster
+          * \param[in] number_of_clusters desired number of clusters
+          * \param[out] io_labels output parameter, which stores the label for each point
+          * \param[in] criteria defines when the computational process need to be finished. For example if the
+          * desired accuracy is achieved or the iteration number exceeds given value
+          * \param[in] attempts number of attempts to compute clustering
+          * \param[in] flags if set to USE_INITIAL_LABELS then initial approximation of labels is taken from io_labels
+          * \param[out] cluster_centers it will store the cluster centers
+          */
+        double
+        computeKMeansClustering (const Eigen::MatrixXf& points_to_cluster,
+                                 int number_of_clusters,
+                                 Eigen::MatrixXi& io_labels,
+                                 TermCriteria criteria,
+                                 int attempts,
+                                 int flags,
+                                 Eigen::MatrixXf& cluster_centers);
+
+        /** \brief Generates centers for clusters as described in 
+          * Arthur, David and Sergei Vassilvitski (2007) k-means++: The Advantages of Careful Seeding.
+          * \param[in] data points to cluster
+          * \param[out] out_centers it will contain generated centers
+          * \param[in] number_of_clusters defines the number of desired cluster centers
+          * \param[in] trials number of trials to generate a center
+          */
+        void
+        generateCentersPP (const Eigen::MatrixXf& data,
+                           Eigen::MatrixXf& out_centers,
+                           int number_of_clusters,
+                           int trials);
+
+        /** \brief Generates random center for cluster.
+          * \param[in] boxes contains min and max values for each dimension
+          * \param[out] center it will the contain generated center
+          */
+        void
+        generateRandomCenter (const std::vector<Eigen::Vector2f>& boxes, Eigen::VectorXf& center);
+
+        /** \brief Computes the square distance beetween two vectors.
+          * \param[in] vec_1 first vector
+          * \param[in] vec_2 second vector
+          */
+        float
+        computeDistance (Eigen::VectorXf& vec_1, Eigen::VectorXf& vec_2);
+
+        /** \brief Forbids the assignment operator. */
+        ImplicitShapeModelEstimation&
+        operator= (const ImplicitShapeModelEstimation&);
+
+      protected:
+
+        /** \brief Stores the clouds used for training. */
+        std::vector<typename pcl::PointCloud<PointT>::Ptr> training_clouds_;
+
+        /** \brief Stores the class number for each cloud from training_clouds_. */
+        std::vector<unsigned int> training_classes_;
+
+        /** \brief Stores the normals for each training cloud. */
+        std::vector<typename pcl::PointCloud<NormalT>::Ptr> training_normals_;
+
+        /** \brief This array stores the sigma values for each training class. If this array has a size equals 0, then
+          * sigma values will be calculated automatically.
+          */
+        std::vector<float> training_sigmas_;
+
+        /** \brief This value is used for the simplification. It sets the size of grid bin. */
+        float sampling_size_;
+
+        /** \brief Stores the feature estimator. */
+        boost::shared_ptr<pcl::Feature<PointT, pcl::Histogram<FeatureSize> > > feature_estimator_;
+
+        /** \brief Number of clusters, is used for clustering descriptors during the training. */
+        unsigned int number_of_clusters_;
+
+        /** \brief If set to false then Nvot coeff from [Knopp et al., 2010, (4)] is equal 1.0. */
+        bool n_vot_ON_;
+
+        /** \brief This const value is used for indicating that for k-means clustering centers must
+          * be generated as described in
+          * Arthur, David and Sergei Vassilvitski (2007) k-means++: The Advantages of Careful Seeding. */
+        static const int PP_CENTERS = 2;
+
+        /** \brief This const value is used for indicating that input labels must be taken as the
+          * initial approximation for k-means clustering. */
+        static const int USE_INITIAL_LABELS = 1;
+    };
+  }
+}
+
+POINT_CLOUD_REGISTER_POINT_STRUCT (pcl::ISMPeak,
+  (float, x, x)
+  (float, y, y)
+  (float, z, z)
+  (float, density, ism_density)
+  (float, class_id, ism_class_id)
+)
+
+#endif  //#ifndef PCL_IMPLICIT_SHAPE_MODEL_H_
+###
+
+# linemod.h
+namespace pcl
+{
+
+  /** \brief Stores a set of energy maps.
+    * \author Stefan Holzer
+    */
+  class PCL_EXPORTS EnergyMaps
+  {
+    public:
+      /** \brief Constructor. */
+      EnergyMaps () : width_ (0), height_ (0), nr_bins_ (0), maps_ () 
+      {
+      }
+
+      /** \brief Destructor. */
+      virtual ~EnergyMaps () 
+      {
+      }
+
+      /** \brief Returns the width of the energy maps. */
+      inline size_t 
+      getWidth () const 
+      { 
+        return (width_); 
+      }
+      
+      /** \brief Returns the height of the energy maps. */
+      inline size_t 
+      getHeight () const 
+      { 
+        return (height_); 
+      }
+      
+      /** \brief Returns the number of bins used for quantization (which is equal to the number of energy maps). */
+      inline size_t 
+      getNumOfBins () const
+      { 
+        return (nr_bins_);
+      }
+
+      /** \brief Initializes the set of energy maps.
+        * \param[in] width the width of the energy maps.
+        * \param[in] height the height of the energy maps.
+        * \param[in] nr_bins the number of bins used for quantization.
+        */
+      void 
+      initialize (const size_t width, const size_t height, const size_t nr_bins)
+      {
+        maps_.resize(nr_bins, NULL);
+        width_ = width;
+        height_ = height;
+        nr_bins_ = nr_bins;
+
+        const size_t mapsSize = width*height;
+
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+        {
+          //maps_[map_index] = new unsigned char[mapsSize];
+          maps_[map_index] = reinterpret_cast<unsigned char*> (aligned_malloc (mapsSize));
+          memset (maps_[map_index], 0, mapsSize);
+        }
+      }
+
+      /** \brief Releases the internal data. */
+      void 
+      releaseAll ()
+      {
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+          //if (maps_[map_index] != NULL) delete[] maps_[map_index];
+          if (maps_[map_index] != NULL) aligned_free (maps_[map_index]);
+
+        maps_.clear ();
+        width_ = 0;
+        height_ = 0;
+        nr_bins_ = 0;
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] col_index the column index within the specified energy map.
+        * \param[in] row_index the row index within the specified energy map.
+        */
+      inline unsigned char & 
+      operator() (const size_t bin_index, const size_t col_index, const size_t row_index)
+      {
+        return (maps_[bin_index][row_index*width_ + col_index]);
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] index the element index within the specified energy map.
+        */
+      inline unsigned char & 
+      operator() (const size_t bin_index, const size_t index)
+      {
+        return (maps_[bin_index][index]);
+      }
+
+      /** \brief Returns a pointer to the data of the specified energy map.
+        * \param[in] bin_index the index of the energy map to return (== the quantization bin).
+        */
+      inline unsigned char * 
+      operator() (const size_t bin_index)
+      {
+        return (maps_[bin_index]);
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] col_index the column index within the specified energy map.
+        * \param[in] row_index the row index within the specified energy map.
+        */
+      inline const unsigned char & 
+      operator() (const size_t bin_index, const size_t col_index, const size_t row_index) const
+      {
+        return (maps_[bin_index][row_index*width_ + col_index]);
+      }
+
+      /** \brief Operator for accessing a specific element in the set of energy maps.
+        * \param[in] bin_index the quantization bin (states which of the energy maps to access).
+        * \param[in] index the element index within the specified energy map.
+        */
+      inline const unsigned char & 
+      operator() (const size_t bin_index, const size_t index) const
+      {
+        return (maps_[bin_index][index]);
+      }
+
+      /** \brief Returns a pointer to the data of the specified energy map.
+        * \param[in] bin_index the index of the energy map to return (== the quantization bin).
+        */
+      inline const unsigned char * 
+      operator() (const size_t bin_index) const
+      {
+        return (maps_[bin_index]);
+      }
+
+    private:
+      /** \brief The width of the energy maps. */
+      size_t width_;
+      /** \brief The height of the energy maps. */
+      size_t height_;
+      /** \brief The number of quantization bins (== the number of internally stored energy maps). */
+      size_t nr_bins_;
+      /** \brief Storage for the energy maps. */
+      std::vector<unsigned char*> maps_;
+  };
+
+  /** \brief Stores a set of linearized maps.
+    * \author Stefan Holzer
+    */
+  class PCL_EXPORTS LinearizedMaps
+  {
+    public:
+      /** \brief Constructor. */
+      LinearizedMaps () : width_ (0), height_ (0), mem_width_ (0), mem_height_ (0), step_size_ (0), maps_ ()
+      {
+      }
+      
+      /** \brief Destructor. */
+      virtual ~LinearizedMaps () 
+      {
+      }
+
+      /** \brief Returns the width of the linearized map. */
+      inline size_t 
+      getWidth () const { return (width_); }
+      
+      /** \brief Returns the height of the linearized map. */
+      inline size_t 
+      getHeight () const { return (height_); }
+      
+      /** \brief Returns the step-size used to construct the linearized map. */
+      inline size_t 
+      getStepSize () const { return (step_size_); }
+      
+      /** \brief Returns the size of the memory map. */
+      inline size_t 
+      getMapMemorySize () const { return (mem_width_ * mem_height_); }
+
+      /** \brief Initializes the linearized map.
+        * \param[in] width the width of the source map.
+        * \param[in] height the height of the source map.
+        * \param[in] step_size the step-size used to sample the source map.
+        */
+      void 
+      initialize (const size_t width, const size_t height, const size_t step_size)
+      {
+        maps_.resize(step_size*step_size, NULL);
+        width_ = width;
+        height_ = height;
+        mem_width_ = width / step_size;
+        mem_height_ = height / step_size;
+        step_size_ = step_size;
+
+        const size_t mapsSize = mem_width_ * mem_height_;
+
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+        {
+          //maps_[map_index] = new unsigned char[2*mapsSize];
+          maps_[map_index] = reinterpret_cast<unsigned char*> (aligned_malloc (2*mapsSize));
+          memset (maps_[map_index], 0, 2*mapsSize);
+        }
+      }
+
+      /** \brief Releases the internal memory. */
+      void 
+      releaseAll ()
+      {
+        for (size_t map_index = 0; map_index < maps_.size (); ++map_index)
+          //if (maps_[map_index] != NULL) delete[] maps_[map_index];
+          if (maps_[map_index] != NULL) aligned_free (maps_[map_index]);
+
+        maps_.clear ();
+        width_ = 0;
+        height_ = 0;
+        mem_width_ = 0;
+        mem_height_ = 0;
+        step_size_ = 0;
+      }
+
+      /** \brief Operator to access elements of the linearized map by column and row index.
+        * \param[in] col_index the column index.
+        * \param[in] row_index the row index.
+        */
+      inline unsigned char * 
+      operator() (const size_t col_index, const size_t row_index)
+      {
+        return (maps_[row_index*step_size_ + col_index]);
+      }
+
+      /** \brief Returns a linearized map starting at the specified position.
+        * \param[in] col_index the column index at which the returned map starts.
+        * \param[in] row_index the row index at which the returned map starts.
+        */
+      inline unsigned char * 
+      getOffsetMap (const size_t col_index, const size_t row_index)
+      {
+        const size_t map_col = col_index % step_size_;
+        const size_t map_row = row_index % step_size_;
+
+        const size_t map_mem_col_index = col_index / step_size_;
+        const size_t map_mem_row_index = row_index / step_size_;
+
+        return (maps_[map_row*step_size_ + map_col] + map_mem_row_index*mem_width_ + map_mem_col_index);
+      }
+
+    private:
+      /** \brief the original width of the data represented by the map. */
+      size_t width_;
+      /** \brief the original height of the data represented by the map. */
+      size_t height_;
+      /** \brief the actual width of the linearized map. */
+      size_t mem_width_;
+      /** \brief the actual height of the linearized map. */
+      size_t mem_height_;
+      /** \brief the step-size used for sampling the original data. */
+      size_t step_size_;
+      /** \brief a vector containing all the linearized maps. */
+      std::vector<unsigned char*> maps_;
+  };
+
+  /** \brief Represents a detection of a template using the LINEMOD approach.
+    * \author Stefan Holzer
+    */
+  struct PCL_EXPORTS LINEMODDetection
+  {
+    /** \brief Constructor. */
+    LINEMODDetection () : x (0), y (0), template_id (0), score (0.0f), scale (1.0f) {}
+
+    /** \brief x-position of the detection. */
+    int x;
+    /** \brief y-position of the detection. */
+    int y;
+    /** \brief ID of the detected template. */
+    int template_id;
+    /** \brief score of the detection. */
+    float score;
+    /** \brief scale at which the template was detected. */
+    float scale;
+  };
+
+  /**
+    * \brief Template matching using the LINEMOD approach.
+    * \author Stefan Holzer, Stefan Hinterstoisser
+    */
+  class PCL_EXPORTS LINEMOD
+  {
+    public:
+      /** \brief Constructor */
+      LINEMOD ();
+
+      /** \brief Destructor */
+      virtual ~LINEMOD ();
+
+      /** \brief Creates a template from the specified data and adds it to the matching queue. 
+        * \param[in] modalities the modalities used to create the template.
+        * \param[in] masks the masks that determine which parts of the modalities are used for creating the template.
+        * \param[in] region the region which will be associated with the template (can be larger than the actual modality-maps).
+        */
+      int 
+      createAndAddTemplate (const std::vector<QuantizableModality*> & modalities,
+                            const std::vector<MaskMap*> & masks,
+                            const RegionXY & region);
+
+      /** \brief Adds the specified template to the matching queue.
+        * \param[in] linemod_template the template to add.
+        */
+      int
+      addTemplate (const SparseQuantizedMultiModTemplate & linemod_template);
+
+      /** \brief Detects the stored templates in the supplied modality data.
+        * \param[in] modalities the modalities that will be used for detection.
+        * \param[out] detections the destination for the detections.
+        */
+      void
+      detectTemplates (const std::vector<QuantizableModality*> & modalities,
+                       std::vector<LINEMODDetection> & detections) const;
+
+      /** \brief Detects the stored templates in a semi scale invariant manner 
+        *        by applying the detection to multiple scaled versions of the input data.
+        * \param[in] modalities the modalities that will be used for detection.
+        * \param[out] detections the destination for the detections.
+        * \param[in] min_scale the minimum scale.
+        * \param[in] max_scale the maximum scale.
+        * \param[in] scale_multiplier the multiplier for getting from one scale to the next.
+        */
+      void
+      detectTemplatesSemiScaleInvariant (const std::vector<QuantizableModality*> & modalities,
+                                         std::vector<LINEMODDetection> & detections,
+                                         float min_scale = 0.6944444f,
+                                         float max_scale = 1.44f,
+                                         float scale_multiplier = 1.2f) const;
+
+      /** \brief Matches the stored templates to the supplied modality data.
+        * \param[in] modalities the modalities that will be used for matching.
+        * \param[out] matches the found matches.
+        */
+      void
+      matchTemplates (const std::vector<QuantizableModality*> & modalities,
+                      std::vector<LINEMODDetection> & matches) const;
+
+      /** \brief Sets the detection threshold. 
+        * \param[in] threshold the detection threshold.
+        */
+      inline void
+      setDetectionThreshold (float threshold)
+      {
+        template_threshold_ = threshold;
+      }
+
+      /** \brief Enables/disables non-maximum suppression.
+        * \param[in] use_non_max_suppression determines whether to use non-maximum suppression or not.
+        */
+      inline void
+      setNonMaxSuppression (bool use_non_max_suppression)
+      {
+        use_non_max_suppression_ = use_non_max_suppression;
+      }
+
+      /** \brief Enables/disables averaging of close detections.
+        * \param[in] average_detections determines whether to average close detections or not.
+        */
+      inline void
+      setDetectionAveraging (bool average_detections)
+      {
+        average_detections_ = average_detections;
+      }
+
+      /** \brief Returns the template with the specified ID.
+        * \param[in] template_id the ID of the template to return.
+        */
+      inline const SparseQuantizedMultiModTemplate &
+      getTemplate (int template_id) const
+      { 
+        return (templates_[template_id]);
+      }
+
+      /** \brief Returns the number of stored/trained templates. */
+      inline size_t
+      getNumOfTemplates () const
+      {
+        return (templates_.size ());
+      }
+
+      /** \brief Saves the stored templates to the specified file.
+        * \param[in] file_name the name of the file to save the templates to.
+        */
+      void
+      saveTemplates (const char * file_name) const;
+
+      /** \brief Loads templates from the specified file.
+        * \param[in] file_name the name of the file to load the template from.
+        */
+      void
+      loadTemplates (const char * file_name);
+
+      /** \brief Loads templates from the specified files.
+        * \param[in] file_names vector of files to load the templates from.
+        */
+
+      void
+      loadTemplates (std::vector<std::string> & file_names);
+
+      /** \brief Serializes the stored templates to the specified stream.
+        * \param[in] stream the stream the templates will be written to.
+        */
+      void 
+      serialize (std::ostream & stream) const;
+
+      /** \brief Deserializes templates from the specified stream.
+        * \param[in] stream the stream the templates will be read from.
+        */
+      void 
+      deserialize (std::istream & stream);
+
+
+    private:
+      /** template response threshold */
+      float template_threshold_;
+      /** states whether non-max-suppression on detections is enabled or not */
+      bool use_non_max_suppression_;
+      /** states whether to return an averaged detection */
+      bool average_detections_;
+      /** template storage */
+      std::vector<SparseQuantizedMultiModTemplate> templates_;
+  };
+
+}
+
+#endif 
+
+###
+
+# line_rgbd.h
+# namespace pcl
+# struct BoundingBoxXYZ
+    # /** \brief Constructor. */
+    # BoundingBoxXYZ () : x (0.0f), y (0.0f), z (0.0f), width (0.0f), height (0.0f), depth (0.0f) {}
+	# 
+    # /** \brief X-coordinate of the upper left front point */
+    # float x;
+    # /** \brief Y-coordinate of the upper left front point */
+    # float y;
+    # /** \brief Z-coordinate of the upper left front point */
+    # float z;
+	# 
+    # /** \brief Width of the bounding box */
+    # float width;
+    # /** \brief Height of the bounding box */
+    # float height;
+    # /** \brief Depth of the bounding box */
+    # float depth;
+	
+	# /** \brief High-level class for template matching using the LINEMOD approach based on RGB and Depth data.
+    # * \author Stefan Holzer
+    # */
+  	# template <typename PointXYZT, typename PointRGBT=PointXYZT>
+  	# class PCL_EXPORTS LineRGBD
+  	# {
+    	# public:
+		# 
+      	# /** \brief A LineRGBD detection. */
+      	# struct Detection
+      		# /** \brief Constructor. */
+        	# Detection () : template_id (0), object_id (0), detection_id (0), response (0.0f), bounding_box () {}
+			# 
+        	# /** \brief The ID of the template. */
+        	# size_t template_id;
+        	# /** \brief The ID of the object corresponding to the template. */
+        	# size_t object_id;
+        	# /** \brief The ID of this detection. This is only valid for the last call of the method detect (...). */
+        	# size_t detection_id;
+        	# /** \brief The response of this detection. Responses are between 0 and 1, where 1 is best. */
+        	# float response;
+        	# /** \brief The 3D bounding box of the detection. */
+        	# BoundingBoxXYZ bounding_box;
+        	# /** \brief The 2D template region of the detection. */
+        	# RegionXY region;
+		
+		
+      	# /** \brief Constructor */
+      	# LineRGBD ()
+        # : intersection_volume_threshold_ (1.0f)
+        # , linemod_ ()
+        # , color_gradient_mod_ ()
+        # , surface_normal_mod_ ()
+        # , cloud_xyz_ ()
+        # , cloud_rgb_ ()
+        # , template_point_clouds_ ()
+        # , bounding_boxes_ ()
+        # , object_ids_ ()
+        # , detections_ ()
+		# /** \brief Destructor */
+      	# virtual ~LineRGBD ()
+      	# /** \brief Loads templates from a LMT (LineMod Template) file. Overrides old templates.
+        # 	* LineMod Template files are TAR files that store pairs of PCD datasets
+        # 	* together with their LINEMOD signatures in \ref
+        # 	* SparseQuantizedMultiModTemplate format.
+        # 	* \param[in] file_name The name of the file that stores the templates.
+        # 	* \param object_id
+        # 	* \return true, if the operation was successful, false otherwise.
+        # */
+      	# bool loadTemplates (const std::string &file_name, size_t object_id = 0);
+		# 
+      	# bool addTemplate (const SparseQuantizedMultiModTemplate & sqmmt, pcl::PointCloud<pcl::PointXYZRGBA> & cloud, size_t object_id = 0);
+		# 
+      	# /** \brief Sets the threshold for the detection responses. Responses are between 0 and 1, where 1 is a best. 
+        #  * \param[in] threshold The threshold used to decide where a template is detected.
+        # */
+      	# inline void setDetectionThreshold (float threshold)
+		# 
+      	# /** \brief Sets the threshold on the magnitude of color gradients. Color gradients with a magnitude below 
+        #  *        this threshold are not considered in the detection process.
+        #  * \param[in] threshold The threshold on the magnitude of color gradients.
+        # */
+      	# inline void setGradientMagnitudeThreshold (const float threshold)
+		# 
+      	# /** \brief Sets the threshold for the decision whether two detections of the same template are merged or not. 
+        #  *        If ratio between the intersection of the bounding boxes of two detections and the original bounding 
+        #  *        boxes is larger than the specified threshold then they are merged. If detection A overlaps with 
+        #  *        detection B and B with C than A, B, and C are merged. Threshold has to be between 0 and 1.
+        #  * \param[in] threshold The threshold on the ratio between the intersection bounding box and the original 
+        #  *                      bounding box.
+        # */
+      	# inline void setIntersectionVolumeThreshold (const float threshold = 1.0f)
+		# 
+      	# /** \brief Sets the input cloud with xyz point coordinates. The cloud has to be organized. 
+        #  * \param[in] cloud The input cloud with xyz point coordinates.
+        # */
+      	# inline void setInputCloud (const typename pcl::PointCloud<PointXYZT>::ConstPtr & cloud)
+      	# 
+      	# /** \brief Sets the input cloud with rgb values. The cloud has to be organized. 
+        #  * \param[in] cloud The input cloud with rgb values.
+        # */
+      	# inline void setInputColors (const typename pcl::PointCloud<PointRGBT>::ConstPtr & cloud)
+		# 
+      	# /** \brief Creates a template from the specified data and adds it to the matching queue. 
+        #  * \param cloud
+        #  * \param object_id
+        #  * \param[in] mask_xyz the mask that determine which parts of the xyz-modality are used for creating the template.
+        #  * \param[in] mask_rgb the mask that determine which parts of the rgb-modality are used for creating the template.
+        #  * \param[in] region the region which will be associated with the template (can be larger than the actual modality-maps).
+        #  */
+      	# int createAndAddTemplate (
+        # 	pcl::PointCloud<pcl::PointXYZRGBA> & cloud,
+        # 	const size_t object_id,
+        # 	const MaskMap & mask_xyz,
+        # 	const MaskMap & mask_rgb,
+        # 	const RegionXY & region);
+		# 
+      	# /** \brief Applies the detection process and fills the supplied vector with the detection instances. 
+        #  * \param[out] detections The storage for the detection instances.
+        #  */
+      	# void detect (std::vector<typename pcl::LineRGBD<PointXYZT, PointRGBT>::Detection> & detections);
+		# 
+      	# /** \brief Applies the detection process in a semi-scale-invariant manner. This is done by acutally
+        #  *        scaling the template to different sizes.
+        #  */
+      	# void detectSemiScaleInvariant (std::vector<typename pcl::LineRGBD<PointXYZT, PointRGBT>::Detection> & detections,
+        #                         		float min_scale = 0.6944444f,
+        #                         		float max_scale = 1.44f,
+        #                         		float scale_multiplier = 1.2f);
+		# 
+      	# /** \brief Computes and returns the point cloud of the specified detection. This is the template point 
+        #  *        cloud transformed to the detection coordinates. The detection ID refers to the last call of 
+        #  *        the method detect (...).
+        #  * \param[in] detection_id The ID of the detection (according to the last call of the method detect (...)).
+        #  * \param[out] cloud The storage for the transformed points.
+        #  */
+      	# void computeTransformedTemplatePoints (const size_t detection_id,
+        #                                 pcl::PointCloud<pcl::PointXYZRGBA> & cloud);
+		# 
+      	# /** \brief Finds the indices of the points in the input cloud which correspond to the specified detection. 
+        #  *        The detection ID refers to the last call of the method detect (...).
+        #  * \param[in] detection_id The ID of the detection (according to the last call of the method detect (...)).
+        #  */
+      	# inline std::vector<size_t> findObjectPointIndices (const size_t detection_id)
+
+###
+
+# mask_map.h
+# namespace pcl
+	# class PCL_EXPORTS MaskMap
+  	# public:
+    	# MaskMap ();
+      	# MaskMap (size_t width, size_t height);
+      	# virtual ~MaskMap ();
+		# 
+      	# void resize (size_t width, size_t height);
+		# 
+      	# inline size_t getWidth () const { return (width_); }
+      	# inline size_t getHeight () const { return (height_); }
+        # inline unsigned char* getData () { return (&data_[0]); }
+		# inline const unsigned char* getData () const { return (&data_[0]); }
+      	# static void getDifferenceMask (const MaskMap & mask0,
+        #             					const MaskMap & mask1,
+        #                  				MaskMap & diff_mask);
+		# 
+      	# inline void set (const size_t x, const size_t y)
+      	# inline void unset (const size_t x, const size_t y)
+	    # inline bool isSet (const size_t x, const size_t y) const
+      	# inline void reset ()
+      	# inline unsigned char & operator() (const size_t x, const size_t y) 
+      	# inline const unsigned char &operator() (const size_t x, const size_t y) const
+      	# void erode (MaskMap & eroded_mask) const;
+
+
+###
+
+# model_library.h
+# #include <pcl/recognition/ransac_based/model_library.h>
+# namespace pcl
+# namespace recognition
+    # class PCL_EXPORTS ModelLibrary
+    	# public:
+        # typedef pcl::PointCloud<pcl::PointXYZ> PointCloudIn;
+        # typedef pcl::PointCloud<pcl::Normal> PointCloudN;
+		# 
+        # /** \brief Stores some information about the model. */
+        # class Model
+        	# public:
+            # Model (const PointCloudIn& points, const PointCloudN& normals, float voxel_size, const std::string& object_name,
+            #        float frac_of_points_for_registration, void* user_data = NULL)
+            # : obj_name_(object_name),
+            #   user_data_ (user_data)
+            virtual ~Model ()
+            inline const std::string& getObjectName () const
+            inline const ORROctree& getOctree () const
+            inline void* getUserData () const
+            inline const float* getOctreeCenterOfMass () const
+            inline const float* getBoundsOfOctreePoints () const
+            inline const PointCloudIn& getPointsForRegistration () const
+          	
+		# typedef std::list<std::pair<const ORROctree::Node::Data*, const ORROctree::Node::Data*> > node_data_pair_list;
+        # typedef std::map<const Model*, node_data_pair_list> HashTableCell;
+        # typedef VoxelStructure<HashTableCell, float> HashTable;
+		
+      	# public:
+        # /** \brief This class is used by 'ObjRecRANSAC' to maintain the object models to be recognized. Normally, you do not need to use
+        #   * this class directly. */
+        # ModelLibrary (float pair_width, float voxel_size, float max_coplanarity_angle = 3.0f*AUX_DEG_TO_RADIANS/*3 degrees*/);
+        # virtual ~ModelLibrary ()
+        # 
+        # /** \brief Removes all models from the library and clears the hash table. */
+        # void removeAllModels ();
+		# 
+        # /** \brief This is a threshold. The larger the value the more point pairs will be considered as co-planar and will
+        #   * be ignored in the off-line model pre-processing and in the online recognition phases. This makes sense only if
+        #   * "ignore co-planar points" is on. Call this method before calling addModel. */
+        # inline void setMaxCoplanarityAngleDegrees (float max_coplanarity_angle_degrees)
+		# 
+        # /** \brief Call this method in order NOT to add co-planar point pairs to the hash table. The default behavior
+        #   * is ignoring co-planar points on. */
+        # inline void ignoreCoplanarPointPairsOn ()
+		# 
+        # /** \brief Call this method in order to add all point pairs (co-planar as well) to the hash table. The default
+        #   * behavior is ignoring co-planar points on. */
+        # inline void ignoreCoplanarPointPairsOff ()
+		# 
+        # /** \brief Adds a model to the hash table.
+        #   *
+        #   * \param[in] points represents the model to be added.
+        #   * \param[in] normals are the normals at the model points.
+        #   * \param[in] object_name is the unique name of the object to be added.
+        #   * \param[in] frac_of_points_for_registration is the number of points used for fast ICP registration prior to hypothesis testing
+        #   * \param[in] user_data is a pointer to some data (can be NULL)
+        #   *
+        #   * Returns true if model successfully added and false otherwise (e.g., if object_name is not unique). */
+        # bool addModel (
+        # 		const PointCloudIn& points, const PointCloudN& normals, const std::string& object_name,
+        #         float frac_of_points_for_registration, void* user_data = NULL);
+		# 
+        # /** \brief Returns the hash table built by this instance. */
+        # inline const HashTable& getHashTable () const
+		# inline const Model* getModel (const std::string& name) const
+        # inline const std::map<std::string,Model*>& getModels () const
+
+
+###
+
+# obj_rec_ransac.h
+# #include <pcl/recognition/ransac_based/obj_rec_ransac.h>
+# #error "Using pcl/recognition/obj_rec_ransac.h is deprecated, please use pcl/recognition/ransac_based/obj_rec_ransac.h instead."
+# namespace pcl
+# namespace recognition
+    # /** \brief This is a RANSAC-based 3D object recognition method. Do the following to use it: (i) call addModel() k times with k different models
+    #   * representing the objects to be recognized and (ii) call recognize() with the 3D scene in which the objects should be recognized. Recognition means both
+    #   * object identification and pose (position + orientation) estimation. Check the method descriptions for more details.
+    #   *
+    #   * \note If you use this code in any academic work, please cite:
+    #   *
+    #   *   - Chavdar Papazov, Sami Haddadin, Sven Parusel, Kai Krieger and Darius Burschka.
+    #   *     Rigid 3D geometry matching for grasping of known objects in cluttered scenes.
+    #   *     The International Journal of Robotics Research 2012. DOI: 10.1177/0278364911436019
+    #   *
+    #   *   - Chavdar Papazov and Darius Burschka.
+    #   *     An Efficient RANSAC for 3D Object Recognition in Noisy and Occluded Scenes.
+    #   *     In Proceedings of the 10th Asian Conference on Computer Vision (ACCV'10),
+    #   *     November 2010.
+    #   *
+    #   *
+    #   * \author Chavdar Papazov
+    #   * \ingroup recognition
+    #   */
+    # class PCL_EXPORTS ObjRecRANSAC
+    	# public:
+        # typedef ModelLibrary::PointCloudIn PointCloudIn;
+        # typedef ModelLibrary::PointCloudN PointCloudN;
+		# 
+        # typedef BVH<Hypothesis*> BVHH;
+		# 
+        # /** \brief This is an output item of the ObjRecRANSAC::recognize() method. It contains the recognized model, its name (the ones passed to
+        #   * ObjRecRANSAC::addModel()), the rigid transform which aligns the model with the input scene and the match confidence which is a number
+        #   * in the interval (0, 1] which gives the fraction of the model surface area matched to the scene. E.g., a match confidence of 0.3 means
+        #   * that 30% of the object surface area was matched to the scene points. If the scene is represented by a single range image, the match
+        #   * confidence can not be greater than 0.5 since the range scanner sees only one side of each object.
+        #   */
+        # class Output
+        	# public:
+            # Output (const std::string& object_name, const float rigid_transform[12], float match_confidence, void* user_data) :
+            #   object_name_ (object_name),
+            #   match_confidence_ (match_confidence),
+            #   user_data_ (user_data)
+            # virtual ~Output (){}
+			# 
+          	# public:
+            # std::string object_name_;
+            # float rigid_transform_[12];
+            # float match_confidence_;
+            # void* user_data_;
+
+        # class OrientedPointPair
+        	# public:
+            # OrientedPointPair (const float *p1, const float *n1, const float *p2, const float *n2)
+            #   : p1_ (p1), n1_ (n1), p2_ (p2), n2_ (n2)
+            # 
+            # virtual ~OrientedPointPair (){}
+			# 
+            # public:
+            #   const float *p1_, *n1_, *p2_, *n2_;
+
+        # class HypothesisCreator
+        	# public:
+            # HypothesisCreator (){}
+            # virtual ~HypothesisCreator (){}
+			# 
+            # Hypothesis* create (const SimpleOctree<Hypothesis, HypothesisCreator, float>::Node* ) const { return new Hypothesis ();}
+        # typedef SimpleOctree<Hypothesis, HypothesisCreator, float> HypothesisOctree;
+		# 
+		# 
+      	# public:
+        # /** \brief Constructor with some important parameters which can not be changed once an instance of that class is created.
+        #   *
+        #   * \param[in] pair_width should be roughly half the extent of the visible object part. This means, for each object point p there should be (at least)
+        #   * one point q (from the same object) such that ||p - q|| <= pair_width. Tradeoff: smaller values allow for detection in more occluded scenes but lead
+        #   * to more imprecise alignment. Bigger values lead to better alignment but require large visible object parts (i.e., less occlusion).
+        #   *
+        #   * \param[in] voxel_size is the size of the leafs of the octree, i.e., the "size" of the discretization. Tradeoff: High values lead to less
+        #   * computation time but ignore object details. Small values allow to better distinguish between objects, but will introduce more holes in the resulting
+        #   * "voxel-surface" (especially for a sparsely sampled scene). */
+        # ObjRecRANSAC (float pair_width, float voxel_size);
+        # virtual ~ObjRecRANSAC ()
+        # 
+        # /** \brief Removes all models from the model library and releases some memory dynamically allocated by this instance. */
+        # void inline clear()
+        # 
+        # /** \brief This is a threshold. The larger the value the more point pairs will be considered as co-planar and will
+        #   * be ignored in the off-line model pre-processing and in the online recognition phases. This makes sense only if
+        #   * "ignore co-planar points" is on. Call this method before calling addModel. This method calls the corresponding
+        #   * method of the model library. */
+        # inline void setMaxCoplanarityAngleDegrees (float max_coplanarity_angle_degrees)
+        # inline void setSceneBoundsEnlargementFactor (float value)
+		# 
+        # /** \brief Default is on. This method calls the corresponding method of the model library. */
+        # inline void ignoreCoplanarPointPairsOn ()
+        # 
+        # /** \brief Default is on. This method calls the corresponding method of the model library. */
+        # inline void ignoreCoplanarPointPairsOff ()
+        # 
+        # inline void icpHypothesesRefinementOn ()
+        # inline void icpHypothesesRefinementOff ()
+		# 
+        # /** \brief Add an object model to be recognized.
+        #   *
+        #   * \param[in] points are the object points.
+        #   * \param[in] normals at each point.
+        #   * \param[in] object_name is an identifier for the object. If that object is detected in the scene 'object_name'
+        #   * is returned by the recognition method and you know which object has been detected. Note that 'object_name' has
+        #   * to be unique!
+        #   * \param[in] user_data is a pointer to some data (can be NULL)
+        #   *
+        #   * The method returns true if the model was successfully added to the model library and false otherwise (e.g., if 'object_name' is already in use).
+        #   */
+        # inline bool addModel (const PointCloudIn& points, const PointCloudN& normals, const std::string& object_name, void* user_data = NULL)
+        # 
+        # /** \brief This method performs the recognition of the models loaded to the model library with the method addModel().
+        #   *
+        #   * \param[in]  scene is the 3d scene in which the object should be recognized.
+        #   * \param[in]  normals are the scene normals.
+        #   * \param[out] recognized_objects is the list of output items each one containing the recognized model instance, its name, the aligning rigid transform
+        #   * and the match confidence (see ObjRecRANSAC::Output for further explanations).
+        #   * \param[in]  success_probability is the user-defined probability of detecting all objects in the scene.
+        #   */
+        # void recognize (const PointCloudIn& scene, const PointCloudN& normals, std::list<ObjRecRANSAC::Output>& recognized_objects, double success_probability = 0.99);
+		# 
+        # inline void enterTestModeSampleOPP ()
+        # inline void enterTestModeTestHypotheses ()
+        # inline void leaveTestMode ()
+		# 
+        # /** \brief This function is useful for testing purposes. It returns the oriented point pairs which were sampled from the
+        #   * scene during the recognition process. Makes sense only if some of the testing modes are active. */
+        # inline const std::list<ObjRecRANSAC::OrientedPointPair>& getSampledOrientedPointPairs () const
+		# 
+        # /** \brief This function is useful for testing purposes. It returns the accepted hypotheses generated during the
+        #   * recognition process. Makes sense only if some of the testing modes are active. */
+        # inline const std::vector<Hypothesis>& getAcceptedHypotheses () const
+		# 
+        # /** \brief This function is useful for testing purposes. It returns the accepted hypotheses generated during the
+        #   * recognition process. Makes sense only if some of the testing modes are active. */
+        # inline void getAcceptedHypotheses (std::vector<Hypothesis>& out) const
+		# 
+        # /** \brief Returns the hash table in the model library. */
+        # inline const pcl::recognition::ModelLibrary::HashTable& getHashTable () const
+		# 
+        # inline const ModelLibrary& getModelLibrary () const
+        # inline const ModelLibrary::Model* getModel (const std::string& name) const
+        # inline const ORROctree& getSceneOctree () const
+        # inline RigidTransformSpace& getRigidTransformSpace ()
+        # inline float getPairWidth () const
+		# 
+      	# protected:
+        # enum Recognition_Mode {SAMPLE_OPP, TEST_HYPOTHESES, /*BUILD_CONFLICT_GRAPH,*/ FULL_RECOGNITION};
+        # friend class ModelLibrary;
+		# 
+        # inline int computeNumberOfIterations (double success_probability) const
+        # inline void clearTestData ()
+        # void sampleOrientedPointPairs (int num_iterations, const std::vector<ORROctree::Node*>& full_scene_leaves, std::list<OrientedPointPair>& output) const;
+        # int generateHypotheses (const std::list<OrientedPointPair>& pairs, std::list<HypothesisBase>& out) const;
+		# 
+        # /** \brief Groups close hypotheses in 'hypotheses'. Saves a representative for each group in 'out'. Returns the
+        #   * number of hypotheses after grouping. */
+        # int groupHypotheses(std::list<HypothesisBase>& hypotheses, int num_hypotheses, RigidTransformSpace& transform_space, HypothesisOctree& grouped_hypotheses) const;
+        # inline void testHypothesis (Hypothesis* hypothesis, int& match, int& penalty) const;
+        # inline void testHypothesisNormalBased (Hypothesis* hypothesis, float& match) const;
+        # void buildGraphOfCloseHypotheses (HypothesisOctree& hypotheses, ORRGraph<Hypothesis>& graph) const;
+        # void filterGraphOfCloseHypotheses (ORRGraph<Hypothesis>& graph, std::vector<Hypothesis>& out) const;
+        # void buildGraphOfConflictingHypotheses (const BVHH& bvh, ORRGraph<Hypothesis*>& graph) const;
+        # void filterGraphOfConflictingHypotheses (ORRGraph<Hypothesis*>& graph, std::list<ObjRecRANSAC::Output>& recognized_objects) const;
+		# 
+        # /** \brief Computes the rigid transform that maps the line (a1, b1) to (a2, b2).
+        #  * The computation is based on the corresponding points 'a1' <-> 'a2' and 'b1' <-> 'b2'
+        #  * and the normals 'a1_n', 'b1_n', 'a2_n', and 'b2_n'. The result is saved in
+        #  * 'rigid_transform' which is an array of length 12. The first 9 elements are the
+        #  * rotational part (row major order) and the last 3 are the translation. */
+        # inline void computeRigidTransform(
+        #   const float *a1, const float *a1_n, const float *b1, const float* b1_n,
+        #   const float *a2, const float *a2_n, const float *b2, const float* b2_n,
+        #   float* rigid_transform) const
+		# 
+        # /** \brief Computes the signature of the oriented point pair ((p1, n1), (p2, n2)) consisting of the angles between
+        #   * \param p1
+        #   * \param n1
+        #   * \param p2
+        #   * \param n2
+        #   * \param[out] signature is an array of three doubles saving the three angles in the order shown above. */
+        # static inline void compute_oriented_point_pair_signature (const float *p1, const float *n1, const float *p2, const float *n2, float signature[3])
+
+
+###
+
+# orr_graph.h
+# #include <pcl/recognition/ransac_based/orr_graph.h>
+# #error "Using pcl/recognition/orr_graph.h is deprecated, please use pcl/recognition/ransac_based/orr_graph.h instead."
+# namespace pcl
+# namespace recognition
+# template<class NodeData>
+# class ORRGraph
+		# public:
+        # class Node
+        	# public:
+            # enum State {ON, OFF, UNDEF};
+			# 
+            # Node (int id)
+            # : id_ (id),
+            #   state_(UNDEF)
+            # virtual ~Node (){}
+			# inline const std::set<Node*>& getNeighbors () const
+            # inline const NodeData& getData () const
+            # inline void setData (const NodeData& data)
+            # inline int getId () const
+            # inline void setId (int id)
+            # inline void setFitness (int fitness)
+            # static inline bool compare (const Node* a, const Node* b)
+            # friend class ORRGraph;
+		# public:
+        # ORRGraph (){}
+        # virtual ~ORRGraph (){ this->clear ();}
+		# inline void clear ()
+		# 
+        # /** \brief Drops all existing graph nodes and creates 'n' new ones. */
+        # inline void resize (int n)
+        # inline void computeMaximalOnOffPartition (std::list<Node*>& on_nodes, std::list<Node*>& off_nodes)
+        # inline void insertUndirectedEdge (int id1, int id2)
+        # inline void insertDirectedEdge (int id1, int id2)
+        # inline void deleteUndirectedEdge (int id1, int id2)
+        # inline void deleteDirectedEdge (int id1, int id2)
+        # inline typename std::vector<Node*>& getNodes (){ return nodes_;}
+		# 
+      	# public:
+        # typename std::vector<Node*> nodes_;
+
+
+###
+
+# orr_octree.h
+# #include <pcl/recognition/ransac_based/orr_octree.h>
+# #error "Using pcl/recognition/orr_octree.h is deprecated, please use pcl/recognition/ransac_based/orr_octree.h instead."
+# namespace pcl
+# namespace recognition
+    # /** \brief That's a very specialized and simple octree class. That's the way it is intended to
+    #   * be, that's why no templates and stuff like this.
+    #   *
+    #   * \author Chavdar Papazov
+    #   * \ingroup recognition
+    #   */
+    # class PCL_EXPORTS ORROctree
+    	# public:
+        # typedef pcl::PointCloud<pcl::PointXYZ> PointCloudIn;
+        # typedef pcl::PointCloud<pcl::PointXYZ> PointCloudOut;
+        # typedef pcl::PointCloud<pcl::Normal> PointCloudN;
+		# 
+        # class Node
+        	# public:
+            # class Data
+            	# public:
+                # Data (int id_x, int id_y, int id_z, int lin_id, void* user_data = NULL) 
+                # : id_x_ (id_x), id_y_ (id_y), id_z_ (id_z), lin_id_ (lin_id), num_points_ (0), user_data_ (user_data)
+                # virtual~ Data (){}
+				# 
+                # inline void addToPoint (float x, float y, float z)
+                # inline void computeAveragePoint ()
+                # inline void addToNormal (float x, float y, float z) { n_[0] += x; n_[1] += y; n_[2] += z;}
+                # inline const float* getPoint () const { return p_;}
+                # inline float* getPoint (){ return p_;}
+                # inline const float* getNormal () const { return n_;}
+                # inline float* getNormal (){ return n_;}
+                # inline void get3dId (int id[3]) const
+                # inline int get3dIdX () const {return id_x_;}
+                # inline int get3dIdY () const {return id_y_;}
+                # inline int get3dIdZ () const {return id_z_;}
+                # inline int getLinearId () const { return lin_id_;}
+                # inline void setUserData (void* user_data){ user_data_ = user_data;}
+                # inline void* getUserData () const { return user_data_;}
+                # inline void insertNeighbor (Node* node){ neighbors_.insert (node);}
+                # inline const std::set<Node*>& getNeighbors () const { return (neighbors_);}
+
+            # Node ()
+            # : data_ (NULL),
+            #   parent_ (NULL),
+            #   children_(NULL)
+            # virtual~ Node ()
+            # 
+            # inline void setCenter(const float *c) { center_[0] = c[0]; center_[1] = c[1]; center_[2] = c[2];}
+			# 
+            # inline void setBounds(const float *b) { bounds_[0] = b[0]; bounds_[1] = b[1]; bounds_[2] = b[2]; bounds_[3] = b[3]; bounds_[4] = b[4]; bounds_[5] = b[5];}
+            # inline void setParent(Node* parent) { parent_ = parent;}
+            # inline void setData(Node::Data* data) { data_ = data;}
+            # /** \brief Computes the "radius" of the node which is half the diagonal length. */
+            # inline void computeRadius()
+            # inline const float* getCenter() const { return center_;}
+            # inline const float* getBounds() const { return bounds_;}
+            # inline void getBounds(float b[6]) const
+            # inline Node* getChild (int id) { return &children_[id];}
+            # inline Node* getChildren () { return children_;}
+            # inline Node::Data* getData (){ return data_;}
+            # inline const Node::Data* getData () const { return data_;}
+            # inline void setUserData (void* user_data){ data_->setUserData (user_data);}
+            # inline Node* getParent (){ return parent_;}
+            # inline bool hasData (){ return static_cast<bool> (data_);}
+            # inline bool hasChildren (){ return static_cast<bool> (children_);}
+            # /** \brief Computes the "radius" of the node which is half the diagonal length. */
+            # inline float getRadius (){ return radius_;}
+            # bool createChildren ();
+			# inline void deleteChildren ()
+			# inline void deleteData ()
+            # 
+            # /** \brief Make this and 'node' neighbors by inserting each node in the others node neighbor set. Nothing happens
+            #   * of either of the nodes has no data. */
+            # inline void makeNeighbors (Node* node)
+		
+		
+        # ORROctree ();
+        # virtual ~ORROctree (){ this->clear ();}
+		# void clear ();
+		# 
+        # /** \brief Creates an octree which encloses 'points' and with leaf size equal to 'voxel_size'.
+        #   * 'enlarge_bounds' makes sure that no points from the input will lie on the octree boundary
+        #   * by enlarging the bounds by that factor. For example, enlarge_bounds = 1 means that the
+        #   * bounds will be enlarged by 100%. The default value is fine. */
+        # void build (const PointCloudIn& points, float voxel_size, const PointCloudN* normals = NULL, float enlarge_bounds = 0.00001f);
+		# 
+        # /** \brief Creates an empty octree with bounds at least as large as the ones provided as input and with leaf
+        #   * size equal to 'voxel_size'. */
+        # void build (const float* bounds, float voxel_size);
+		# 
+        # /** \brief Creates the leaf containing p = (x, y, z) and returns a pointer to it, however, only if p lies within
+        #   * the octree bounds! A more general version which allows p to be out of bounds is not implemented yet. The method
+        #   * returns NULL if p is not within the root bounds. If the leaf containing p already exists nothing happens and
+        #   * method just returns a pointer to the leaf. */
+        # inline ORROctree::Node* createLeaf (float x, float y, float z)
+		# 
+        # /** \brief This method returns a super set of the full leavess which are intersected by the sphere
+        #   * with radius 'radius' and centered at 'p'. Pointers to the intersected full leaves are saved in
+        #   * 'out'. The method computes a super set in the sense that in general not all leaves saved in 'out'
+        #   * are really intersected by the sphere. The intersection test is based on the leaf radius (since
+        #   * its faster than checking all leaf corners and sides), so we report more leaves than we should,
+        #   * but still, this is a fair approximation. */
+        # void getFullLeavesIntersectedBySphere (const float* p, float radius, std::list<ORROctree::Node*>& out) const;
+		# 
+        # /** \brief Randomly chooses and returns a full leaf that is intersected by the sphere with center 'p'
+        #   * and 'radius'. Returns NULL if no leaf is intersected by that sphere. */
+        # ORROctree::Node* getRandomFullLeafOnSphere (const float* p, float radius) const;
+		# 
+        # /** \brief Since the leaves are aligned in a rectilinear grid, each leaf has a unique id. The method returns the leaf
+        #   * with id [i, j, k] or NULL is no such leaf exists. */
+        # ORROctree::Node* getLeaf (int i, int j, int k)
+		# 
+        # /** \brief Returns a pointer to the leaf containing p = (x, y, z) or NULL if no such leaf exists. */
+        # inline ORROctree::Node* getLeaf (float x, float y, float z)
+        # 
+        # /** \brief Deletes the branch 'node' is part of. */
+        # void deleteBranch (Node* node);
+		# 
+        # /** \brief Returns a vector with all octree leaves which contain at least one point. */
+        # inline std::vector<ORROctree::Node*>& getFullLeaves () { return full_leaves_;}
+        # inline const std::vector<ORROctree::Node*>& getFullLeaves () const { return full_leaves_;}
+        # void getFullLeavesPoints (PointCloudOut& out) const;
+        # void getNormalsOfFullLeaves (PointCloudN& out) const;
+        # inline ORROctree::Node* getRoot (){ return root_;}
+        # inline const float* getBounds () const
+        # inline void getBounds (float b[6]) const
+        # inline float getVoxelSize () const { return voxel_size_;}
+        # inline void insertNeighbors (Node* node)
+
+
+###
+
+# orr_octree_zprojection.h
+# #include <pcl/recognition/ransac_based/orr_octree_zprojection.h>
+# #error "Using pcl/recognition/orr_octree_zprojection.h is deprecated, please use pcl/recognition/ransac_based/orr_octree_zprojection.h instead."
+# namespace pcl
+# namespace recognition
+	# class ORROctree;
+    # class PCL_EXPORTS ORROctreeZProjection
+    	# public:
+        # class Pixel
+        	# public:
+            # Pixel (int id): id_ (id) {}
+            # inline void set_z1 (float z1) { z1_ = z1;}
+            # inline void set_z2 (float z2) { z2_ = z2;}
+            # float z1 () const { return z1_;}
+            # float z2 () const { return z2_;}
+            # int getId () const { return id_;}
+
+          	# protected:
+            # float z1_, z2_;
+            # int id_;
+
+    	# public:
+        # class Set
+        	# public:
+            # Set (int x, int y) : nodes_ (compare_nodes_z), x_ (x), y_ (y)
+			# 
+            # static inline bool compare_nodes_z (ORROctree::Node* node1, ORROctree::Node* node2)
+			# inline void insert (ORROctree::Node* leaf) { nodes_.insert(leaf);}
+			# inline std::set<ORROctree::Node*, bool(*)(ORROctree::Node*,ORROctree::Node*)>& get_nodes (){ return nodes_;}
+			# inline int get_x () const { return x_;}
+			# inline int get_y () const { return y_;}
+
+      	# public:
+        # ORROctreeZProjection () : pixels_(NULL), sets_(NULL)
+        # virtual ~ORROctreeZProjection (){ this->clear();}
+		# void build (const ORROctree& input, float eps_front, float eps_back);
+		# void clear ();
+        # inline void getPixelCoordinates (const float* p, int& x, int& y) const
+		# inline const Pixel* getPixel (const float* p) const
+		# inline Pixel* getPixel (const float* p)
+		# inline const std::set<ORROctree::Node*, bool(*)(ORROctree::Node*,ORROctree::Node*)>* getOctreeNodes (const float* p) const
+		# 
+        # inline std::list<Pixel*>& getFullPixels (){ return full_pixels_;}
+        # inline const Pixel* getPixel (int i, int j) const
+        # inline float getPixelSize () const
+        # inline const float* getBounds () const
+        # /** \brief Get the width ('num_x') and height ('num_y') of the image. */
+        # inline void getNumberOfPixels (int& num_x, int& num_y) const
+
+
+###
+
+# point_types.h
+# namespace pcl
+# /** \brief A point structure representing Euclidean xyz coordinates, and the intensity value.
+# * \ingroup common
+# */
+# struct EIGEN_ALIGN16 GradientXY
+    # union
+    # {
+    	# struct
+      	# {
+	    #     float x;
+        # 	float y;
+        # 	float angle;
+        # 	float magnitude;
+      	# };
+      	# float data[4];
+    # };
+    # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+	# 
+    # inline bool operator< (const GradientXY & rhs)
+	# 
+	# inline std::ostream & operator << (std::ostream & os, const GradientXY & p)
+
+###
+
+# quantized_map.h
+# namespace pcl
+	# class PCL_EXPORTS QuantizedMap
+  	# {
+    	# public:
+      	# QuantizedMap ();
+      	# QuantizedMap (size_t width, size_t height);
+      	# QuantizedMap (const QuantizedMap & copy_me);
+      	# virtual ~QuantizedMap ();
+		# 
+      	# inline size_t getWidth () const { return (width_); }
+      	# inline size_t getHeight () const { return (height_); }
+      	# inline unsigned char* getData () { return (&data_[0]); }
+		# inline const unsigned char* getData () const { return (&data_[0]); }
+		# inline QuantizedMap getSubMap (
+		# 		size_t x,
+        #         size_t y,
+        #         size_t width,
+        #         size_t height)
+		# 
+      	# void resize (size_t width, size_t height);
+		# 
+      	# inline unsigned char & operator() (const size_t x, const size_t y) 
+	    # inline const unsigned char &operator() (const size_t x, const size_t y) const
+		# 
+      	# static void spreadQuantizedMap (const QuantizedMap & input_map, QuantizedMap & output_map, size_t spreading_size);
+		# 
+      	# void serialize (std::ostream & stream) const
+		# 
+      	# void deserialize (std::istream & stream)
+    	# //private:
+      	# std::vector<unsigned char> data_;
+      	# size_t width_;
+      	# size_t height_;  
+
+###
+
+# region_xy.h
+# namespace pcl
+    # /** \brief Function for reading data from a stream. */
+    # template <class Type> void read (std::istream & stream, Type & value)
+	# 
+  	# /** \brief Function for reading data arrays from a stream. */
+  	# template <class Type> void read (std::istream & stream, Type * value, int nr_values)
+  	# 
+  	# /** \brief Function for writing data to a stream. */
+  	# template <class Type> void write (std::ostream & stream, Type value)
+	# 
+  	# /** \brief Function for writing data arrays to a stream. */
+  	# template <class Type> void write (std::ostream & stream, Type * value, int nr_values)
+	# 
+  	# /** \brief Defines a region in XY-space.
+    #  * \author Stefan Holzer
+    #  */
+  	# struct PCL_EXPORTS RegionXY
+    # 	/** \brief Constructor. */
+    # 	RegionXY () : x (0), y (0), width (0), height (0) {}
+	# 	
+    # 	/** \brief x-position of the region. */
+    # 	int x;
+    # 	/** \brief y-position of the region. */
+    # 	int y;
+    # 	/** \brief width of the region. */
+    # 	int width;
+    # 	/** \brief height of the region. */
+    # 	int height;
+	# 	/** \brief Serializes the object to the specified stream.
+    #    * \param[out] stream the stream the object will be serialized to. */
+    # 	void serialize (std::ostream & stream) const
+	# 	
+    # 	/** \brief Deserializes the object from the specified stream.
+    #    * \param[in] stream the stream the object will be deserialized from. */
+    # 	void deserialize (::std::istream & stream)
+
+###
+
+# rigid_transform_space.h
+# namespace pcl
+# namespace recognition
+# class RotationSpaceCell
+		# public:
+        # class Entry
+        # {
+        # 	public:
+        #     Entry () : num_transforms_ (0)
+        #     Entry (const Entry& src) : num_transforms_ (src.num_transforms_)
+        #     const Entry& operator = (const Entry& src)
+        #     inline const Entry& addRigidTransform (const float axis_angle[3], const float translation[3])
+        #     inline void computeAverageRigidTransform (float *rigid_transform = NULL)
+        #     inline const float* getAxisAngle () const
+        #     inline const float* getTranslation () const
+        #     inline int getNumberOfTransforms () const
+        # };// class Entry
+		# 
+		# 
+      	# public:
+        # RotationSpaceCell (){}
+        # virtual ~RotationSpaceCell ()
+        # 
+        # inline std::map<const ModelLibrary::Model*,Entry>& getEntries ()
+		# 
+        # inline const RotationSpaceCell::Entry* getEntry (const ModelLibrary::Model* model) const
+		# 
+        # inline const RotationSpaceCell::Entry& addRigidTransform (const ModelLibrary::Model* model, const float axis_angle[3], const float translation[3])
+    # }; // class RotationSpaceCell
+	# 
+    # class RotationSpaceCellCreator
+    # {
+    #   public:
+    #     RotationSpaceCellCreator (){}
+    #     virtual ~RotationSpaceCellCreator (){}
+	# 
+    #     RotationSpaceCell* create (const SimpleOctree<RotationSpaceCell, RotationSpaceCellCreator, float>::Node* )
+    #     {
+    #       return (new RotationSpaceCell ());
+    #     }
+    # };
+	# 
+    # typedef SimpleOctree<RotationSpaceCell, RotationSpaceCellCreator, float> CellOctree;
+	# 
+	# 
+    # /** \brief This is a class for a discrete representation of the rotation space based on the axis-angle representation.
+    #   * This class is not supposed to be very general. That's why it is dependent on the class ModelLibrary.
+    #   * \author Chavdar Papazov
+    #   * \ingroup recognition
+    #   */
+    # class PCL_EXPORTS RotationSpace
+    # {
+    	# public:
+        # /** \brief We use the axis-angle representation for rotations. The axis is encoded in the vector
+        #   * and the angle is its magnitude. This is represented in an octree with bounds [-pi, pi]^3. */
+        # RotationSpace (float discretization)
+        # 
+        # inline void setCenter (const float* c)
+        # inline const float* getCenter () const { return center_;}
+        # inline bool getTransformWithMostVotes (const ModelLibrary::Model* model, float rigid_transform[12]) const
+        # inline bool addRigidTransform (const ModelLibrary::Model* model, const float axis_angle[3], const float translation[3])
+    # };// class RotationSpace
+	
+    # class RotationSpaceCreator
+    	# public:
+        # RotationSpaceCreator() : counter_ (0)
+        # virtual ~RotationSpaceCreator(){}
+        # RotationSpace* create(const SimpleOctree<RotationSpace, RotationSpaceCreator, float>::Node* leaf)
+        # void setDiscretization (float value){ discretization_ = value;}
+        # int getNumberOfRotationSpaces () const { return (counter_);}
+        # const std::list<RotationSpace*>& getRotationSpaces () const { return (rotation_spaces_);}
+		# 
+        # std::list<RotationSpace*>& getRotationSpaces (){ return (rotation_spaces_);}
+		# 
+        # void reset ()
+	# 
+    # typedef SimpleOctree<RotationSpace, RotationSpaceCreator, float> RotationSpaceOctree;
+
+    # class PCL_EXPORTS RigidTransformSpace
+    	# public:
+        # RigidTransformSpace (){}
+        # virtual ~RigidTransformSpace (){ this->clear ();}
+        inline void build (const float* pos_bounds, float translation_cell_size, float rotation_cell_size)
+        inline void clear ()
+        inline std::list<RotationSpace*>& getRotationSpaces ()
+        inline const std::list<RotationSpace*>& getRotationSpaces () const
+        inline int getNumberOfOccupiedRotationSpaces ()
+        inline bool addRigidTransform (const ModelLibrary::Model* model, const float position[3], const float rigid_transform[12])
+
+###
+
+# simple_octree.h
+# namespace pcl
+# namespace recognition
+# template<typename NodeData, typename NodeDataCreator, typename Scalar = float>
+# class PCL_EXPORTS SimpleOctree
+	# public:
+    #     class Node
+    #     	public:
+    #         Node ();
+	# 		virtual~ Node ();
+    #         inline void setCenter (const Scalar *c);
+    #         inline void setBounds (const Scalar *b);
+    #         inline const Scalar* getCenter () const { return center_;}
+    #         inline const Scalar* getBounds () const { return bounds_;}
+    #         inline void getBounds (Scalar b[6]) const { memcpy (b, bounds_, 6*sizeof (Scalar));}
+    #         inline Node* getChild (int id) { return &children_[id];}
+    #         inline Node* getChildren () { return children_;}
+    #         inline void setData (const NodeData& src){ *data_ = src;}
+    #         inline NodeData& getData (){ return *data_;}
+    #         inline const NodeData& getData () const { return *data_;}
+    #         inline Node* getParent (){ return parent_;}
+    #         inline float getRadius () const { return radius_;}
+    #         inline bool hasData (){ return static_cast<bool> (data_);}
+    #         inline bool hasChildren (){ return static_cast<bool> (children_);}
+    #         inline const std::set<Node*>& getNeighbors () const { return (full_leaf_neighbors_);}
+    #         inline void deleteChildren ();
+    #         inline void deleteData ();
+    #         friend class SimpleOctree;
+    #     };
+    # 
+    # 
+    	# SimpleOctree ();
+    	# virtual ~SimpleOctree ();
+        # void clear ();
+		# 
+        # /** \brief Creates an empty octree with bounds at least as large as the ones provided as input and with leaf
+        #   * size equal to 'voxel_size'. */
+        # void build (const Scalar* bounds, Scalar voxel_size, NodeDataCreator* node_data_creator);
+		# 
+        # /** \brief Creates the leaf containing p = (x, y, z) and returns a pointer to it, however, only if p lies within
+        #   * the octree bounds! A more general version which allows p to be out of bounds is not implemented yet. The method
+        #   * returns NULL if p is not within the root bounds. If the leaf containing p already exists nothing happens and
+        #   * method just returns a pointer to the leaf. Note that for a new created leaf, the method also creates its data
+        #   * object. */
+        # inline Node* createLeaf (Scalar x, Scalar y, Scalar z);
+		# 
+        # /** \brief Since the leaves are aligned in a rectilinear grid, each leaf has a unique id. The method returns the full
+        #   * leaf, i.e., the one having a data object, with id [i, j, k] or NULL is no such leaf exists. */
+        # inline Node* getFullLeaf (int i, int j, int k);
+		# 
+        # /** \brief Returns a pointer to the full leaf, i.e., one having a data pbject, containing p = (x, y, z) or NULL if no such leaf exists. */
+        # inline Node* getFullLeaf (Scalar x, Scalar y, Scalar z);
+		# 
+        # inline std::vector<Node*>& getFullLeaves () { return full_leaves_;}
+		# 
+        # inline const std::vector<Node*>& getFullLeaves () const { return full_leaves_;}
+		# 
+        # inline Node* getRoot (){ return root_;}
+		# 
+        # inline const Scalar* getBounds () const { return (bounds_);}
+		# 
+        # inline void getBounds (Scalar b[6]) const { memcpy (b, bounds_, 6*sizeof (Scalar));}
+		# 
+        # inline Scalar getVoxelSize () const { return voxel_size_;}
+		
+###
+
+# sparse_quantized_multi_mod_template.h
+# namespace pcl
+# 
+# /** \brief Feature that defines a position and quantized value in a specific modality. 
+# * \author Stefan Holzer
+# */
+# struct QuantizedMultiModFeature
+    # /** \brief Constructor. */
+    # QuantizedMultiModFeature () : x (0), y (0), modality_index (0), quantized_value (0) {}
+	# 
+    # /** \brief x-position. */
+    # int x;
+    # /** \brief y-position. */
+    # int y;
+    # /** \brief the index of the corresponding modality. */
+    # size_t modality_index;
+    # /** \brief the quantized value attached to the feature. */
+    # unsigned char quantized_value;
+	# 
+    # /** \brief Compares whether two features are the same. 
+    #   * \param[in] base the feature to compare to.
+    #   */
+    # bool compareForEquality (const QuantizedMultiModFeature & base)
+    # 
+    # /** \brief Serializes the object to the specified stream.
+    #   * \param[out] stream the stream the object will be serialized to. */
+    # void serialize (std::ostream & stream) const
+    # 
+    # /** \brief Deserializes the object from the specified stream.
+    #   * \param[in] stream the stream the object will be deserialized from. */
+    # void deserialize (std::istream & stream)
+    # 
+  	# /** \brief A multi-modality template constructed from a set of quantized multi-modality features.
+    #  * \author Stefan Holzer 
+    #  */
+  	# struct SparseQuantizedMultiModTemplate
+  		# /** \brief Constructor. */
+    	# SparseQuantizedMultiModTemplate () : features (), region () {}
+		# 
+    	# /** \brief The storage for the multi-modality features. */
+    	# std::vector<QuantizedMultiModFeature> features;
+		# 
+    	# /** \brief The region assigned to the template. */
+    	# RegionXY region;
+		# 
+    	# /** \brief Serializes the object to the specified stream.
+      	#  * \param[out] stream the stream the object will be serialized to. */
+    	# void serialize (std::ostream & stream) const
+    	# 
+    	# /** \brief Deserializes the object from the specified stream.
+      	#  * \param[in] stream the stream the object will be deserialized from. */
+    	# void deserialize (std::istream & stream)
+
+
+###
+
+# surface_normal_modality.h
+# namespace pcl
+# /** \brief Map that stores orientations.
+#  * \author Stefan Holzer
+#  */
+# struct PCL_EXPORTS LINEMOD_OrientationMap
+    	# public:
+      	# /** \brief Constructor. */
+      	# inline LINEMOD_OrientationMap () : width_ (0), height_ (0), map_ () {}
+      	# /** \brief Destructor. */
+      	# inline ~LINEMOD_OrientationMap () {}
+		# 
+      	# /** \brief Returns the width of the modality data map. */
+      	# inline size_t getWidth () const
+		# 
+      	# /** \brief Returns the height of the modality data map. */
+      	# inline size_t getHeight () const
+		# 
+      	# /** \brief Resizes the map to the specific width and height and initializes 
+        # 	*        all new elements with the specified value.
+        # 	* \param[in] width the width of the resized map.
+        # 	* \param[in] height the height of the resized map.
+        # 	* \param[in] value the value all new elements will be initialized with.
+        # */
+      	# inline void resize (const size_t width, const size_t height, const float value)
+		# 
+      	# /** \brief Operator to access elements of the map. 
+        # 	* \param[in] col_index the column index of the element to access.
+        # 	* \param[in] row_index the row index of the element to access.
+        # */
+      	# inline float & operator() (const size_t col_index, const size_t row_index)
+		# 
+      	# /** \brief Operator to access elements of the map. 
+        # 	* \param[in] col_index the column index of the element to access.
+        # 	* \param[in] row_index the row index of the element to access.
+        # */
+      	# inline const float &operator() (const size_t col_index, const size_t row_index) const
+		# 
+		# /** \brief Look-up-table for fast surface normal quantization.
+		# * \author Stefan Holzer
+		# */
+		# struct QuantizedNormalLookUpTable
+		# {
+		#     /** \brief The range of the LUT in x-direction. */
+		#     int range_x;
+		#     /** \brief The range of the LUT in y-direction. */
+		#     int range_y;
+		#     /** \brief The range of the LUT in z-direction. */
+		#     int range_z;
+		# 
+		#     /** \brief The offset in x-direction. */
+		#     int offset_x;
+		#     /** \brief The offset in y-direction. */
+		#     int offset_y;
+		#     /** \brief The offset in z-direction. */
+		#     int offset_z;
+		# 
+		#     /** \brief The size of the LUT in x-direction. */
+		#     int size_x;
+		#     /** \brief The size of the LUT in y-direction. */
+		#     int size_y;
+		#     /** \brief The size of the LUT in z-direction. */
+		#     int size_z;
+		# 
+		#     /** \brief The LUT data. */
+		#     unsigned char * lut;
+		# 
+		#     /** \brief Constructor. */
+		#     QuantizedNormalLookUpTable () : 
+		#       range_x (-1), range_y (-1), range_z (-1), 
+		#       offset_x (-1), offset_y (-1), offset_z (-1), 
+		#       size_x (-1), size_y (-1), size_z (-1), lut (NULL) 
+		#     {}
+		# 
+		#     /** \brief Destructor. */
+		#     ~QuantizedNormalLookUpTable () 
+		#     { 
+		#       if (lut != NULL) 
+		#         delete[] lut; 
+		#     }
+		# 
+    	# /** \brief Initializes the LUT.
+      	# * \param[in] range_x_arg the range of the LUT in x-direction.
+      	# * \param[in] range_y_arg the range of the LUT in y-direction.
+      	# * \param[in] range_z_arg the range of the LUT in z-direction.
+      	# */
+    	# void initializeLUT (const int range_x_arg, const int range_y_arg, const int range_z_arg)
+		# 
+    	# /** \brief Operator to access an element in the LUT.
+      	# * \param[in] x the x-component of the normal.
+      	# * \param[in] y the y-component of the normal.
+      	# * \param[in] z the z-component of the normal. 
+      	# */
+    	# inline unsigned char operator() (const float x, const float y, const float z) const
+		# 
+    	# /** \brief Operator to access an element in the LUT.
+      	# * \param[in] index the index of the element. 
+      	# */
+    	# inline unsigned char operator() (const int index) const
+
+
+# /** \brief Modality based on surface normals.
+# * \author Stefan Holzer
+# */
+# template <typename PointInT>
+# class SurfaceNormalModality : public QuantizableModality, public PCLBase<PointInT>
+        # protected:
+        # using PCLBase<PointInT>::input_;
+        # 
+        # /** \brief Candidate for a feature (used in feature extraction methods). */
+        # struct Candidate
+        #     /** \brief Constructor. */
+        #   Candidate () : normal (), distance (0.0f), bin_index (0), x (0), y (0) {}
+        #   
+        #   /** \brief Normal. */
+        #   Normal normal;
+        #   /** \brief Distance to the next different quantized value. */
+        #   float distance;
+        #   
+        #   /** \brief Quantized value. */
+        #   unsigned char bin_index;
+        #     
+        #   /** \brief x-position of the feature. */
+        #   size_t x;
+        #   /** \brief y-position of the feature. */
+        #   size_t y;   
+        #   /** \brief Compares two candidates based on their distance to the next different quantized value. 
+        #       * \param[in] rhs the candidate to compare with. 
+        #       */
+        #   bool operator< (const Candidate & rhs) const
+        # 
+        # public:
+        #   typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # 
+        # /** \brief Constructor. */
+        # SurfaceNormalModality ();
+        # /** \brief Destructor. */
+        # virtual ~SurfaceNormalModality ();
+        # 
+        # /** \brief Sets the spreading size.
+        #  * \param[in] spreading_size the spreading size.
+        #  */
+        # inline void setSpreadingSize (const size_t spreading_size)
+        # 
+        # /** \brief Enables/disables the use of extracting a variable number of features.
+        #  * \param[in] enabled specifies whether extraction of a variable number of features will be enabled/disabled.
+        #  */
+        # inline void setVariableFeatureNr (const bool enabled)
+        # 
+        # /** \brief Returns the surface normals. */
+        # inline pcl::PointCloud<pcl::Normal> &getSurfaceNormals ()
+        # 
+        # /** \brief Returns the surface normals. */
+        # inline const pcl::PointCloud<pcl::Normal> &getSurfaceNormals () const
+        # 
+        # /** \brief Returns a reference to the internal quantized map. */
+        # inline QuantizedMap &getQuantizedMap () 
+        # 
+        # /** \brief Returns a reference to the internal spreaded quantized map. */
+        # inline QuantizedMap &getSpreadedQuantizedMap () 
+        # 
+        # /** \brief Returns a reference to the orientation map. */
+        # inline LINEMOD_OrientationMap &getOrientationMap ()
+        # 
+        # /** \brief Extracts features from this modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features defines the number of features to be extracted 
+        #   *            (might be less if not sufficient information is present in the modality).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # void extractFeatures (
+        #           const MaskMap & mask, size_t nr_features, size_t modality_index,
+        #             std::vector<QuantizedMultiModFeature> & features) const;
+        # 
+        # /** \brief Extracts all possible features from the modality within the specified mask.
+        #   * \param[in] mask defines the areas where features are searched in. 
+        #   * \param[in] nr_features IGNORED (TODO: remove this parameter).
+        #   * \param[in] modality_index the index which is stored in the extracted features.
+        #   * \param[out] features the destination for the extracted features.
+        # */
+        # void extractAllFeatures (
+        #           const MaskMap & mask, size_t nr_features, size_t modality_index,
+        #             std::vector<QuantizedMultiModFeature> & features) const;
+        # 
+        # /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        #  * \param[in] cloud the const boost shared pointer to a PointCloud message
+        #  */
+        # virtual void setInputCloud (const typename PointCloudIn::ConstPtr & cloud) 
+        # 
+        # /** \brief Processes the input data (smoothing, computing gradients, quantizing, filtering, spreading). */
+        # virtual void processInputData ();
+        # 
+        # /** \brief Processes the input data assuming that everything up to filtering is already done/available 
+        #  *        (so only spreading is performed). */
+        # virtual void processInputDataFromFiltered ();
+
+
+# template <typename PointInT> pcl::SurfaceNormalModality<PointInT>::SurfaceNormalModality ()
+
+# template <typename PointInT> pcl::SurfaceNormalModality<PointInT>::~SurfaceNormalModality ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::processInputData ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::processInputDataFromFiltered ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::computeSurfaceNormals ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::computeAndQuantizeSurfaceNormals ()
+
+# static void accumBilateral(long delta, long i, long j, long * A, long * b, int threshold)
+
+# /**
+#  * \brief Compute quantized normal image from depth image.
+#  * Implements section 2.6 "Extension to Dense Depth Sensors."
+#  * \todo Should also need camera model, or at least focal lengths? Replace distance_threshold with mask?
+#  */
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::computeAndQuantizeSurfaceNormals2 ()
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::extractFeatures (const MaskMap & mask,
+#                                                        const size_t nr_features,
+#                                                        const size_t modality_index,
+#                                                        std::vector<QuantizedMultiModFeature> & features) const
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::extractAllFeatures (
+#     	const MaskMap & mask, const size_t, const size_t modality_index, std::vector<QuantizedMultiModFeature> & features) const
+
+# template <typename PointInT> void pcl::SurfaceNormalModality<PointInT>::quantizeSurfaceNormals ()
+
+# pcl::SurfaceNormalModality<PointInT>::filterQuantizedSurfaceNormals ()
+
+# template <typename PointInT> void
+# pcl::SurfaceNormalModality<PointInT>::computeDistanceMap (const MaskMap & input, DistanceMap & output) const
+
+
+# trimmed_icp.h
+# namespace pcl
+# namespace recognition
+# template<typename PointT, typename Scalar>
+# class PCL_EXPORTS TrimmedICP : public pcl::registration::TransformationEstimationSVD<PointT, PointT, Scalar>
+# {
+cdef extern from "pcl/Recognition/trimmed_icp.h" namespace "pcl::registration":
+    cdef cppclass TrimmedICP[PointT, Scalar](pcl::registration::TransformationEstimationSVD[PointT, PointT, Scalar])
+        TrimmedICP ()
+      	# public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename Eigen::Matrix<Scalar, 4, 4> Matrix4;
+      	# public:
+        # TrimmedICP () : new_to_old_energy_ratio_ (0.99f)
+		# 
+        # /** \brief Call this method before calling align().
+        #   * \param[in] target is target point cloud. The method builds a kd-tree based on 'target' for performing fast closest point search.
+        #   *            The source point cloud will be registered to 'target' (see align() method).
+        #   * */
+        # inline void init (const PointCloudConstPtr& target)
+		# 
+        # /** \brief The method performs trimmed ICP, i.e., it rigidly registers the source to the target (passed to the init() method).
+        #   * \param[in] source_points is the point cloud to be registered to the target.
+        #   * \param[in] num_source_points_to_use gives the number of closest source points taken into account for registration. By closest
+        #   * source points we mean the source points closest to the target. These points are computed anew at each iteration.
+        #   * \param[in,out] guess_and_result is the estimated rigid transform. IMPORTANT: this matrix is also taken as the initial guess
+        #   * for the alignment. If there is no guess, set the matrix to identity!
+        #   * */
+        # inline void align (const PointCloud& source_points, int num_source_points_to_use, Matrix4& guess_and_result) const
+		# 
+        # inline void setNewToOldEnergyRatio (float ratio)
+
+#endif /* TRIMMED_ICP_H_ */
+###
+
+# voxel_structure.h
+# namespace pcl
+# namespace recognition
+# 
+# /** \brief This class is a box in R3 built of voxels ordered in a regular rectangular grid. Each voxel is of type T. */
+# template<class T, typename REAL = float>
+# class VoxelStructure
+cdef extern from "pcl/Recognition/voxel_structure.h" namespace "pcl::recognition":
+    cdef cppclass VoxelStructure[T, float]
+        VoxelStructure ()
+        # public:
+        # inline VoxelStructure (): voxels_(NULL){}
+        # inline virtual ~VoxelStructure (){ this->clear();}
+        # 
+        # /** \brief Call this method before using an instance of this class. Parameter meaning is obvious. */
+        # inline void build (const REAL bounds[6], int num_of_voxels[3]);
+        # 
+        # /** \brief Release the memory allocated for the voxels. */
+        # inline void clear (){ if ( voxels_ ){ delete[] voxels_; voxels_ = NULL;}}
+        # 
+        # /** \brief Returns a pointer to the voxel which contains p or NULL if p is not inside the structure. */
+        # inline T* getVoxel (const REAL p[3]);
+        # 
+        # /** \brief Returns a pointer to the voxel with integer id (x,y,z) or NULL if (x,y,z) is out of bounds. */
+        # inline T* getVoxel (int x, int y, int z) const;
+        # 
+        # /** \brief Returns the linear voxel array. */
+        # const inline T* getVoxels () const
+        # 
+        # /** \brief Returns the linear voxel array. */
+        # inline T* getVoxels ()
+        # 
+        # /** \brief Converts a linear id to a 3D id, i.e., computes the integer 3D coordinates of a voxel from its position in the voxel array.
+        #     *
+        #     * \param[in]  linear_id the position of the voxel in the internal voxel array.
+        #     * \param[out] id3d an array of 3 integers for the integer coordinates of the voxel. */
+        # inline void compute3dId (int linear_id, int id3d[3]) const
+        # 
+        # /** \brief Returns the number of voxels in x, y and z direction. */
+        # inline const int* getNumberOfVoxelsXYZ() const
+		# 
+        # /** \brief Computes the center of the voxel with given integer coordinates.
+        #     *
+        #     * \param[in]  id3 the integer coordinates along the x, y and z axis.
+        #     * \param[out] center */
+        # inline void computeVoxelCenter (const int id3[3], REAL center[3]) const
+		# 
+        # /** \brief Returns the total number of voxels. */
+        # inline int getNumberOfVoxels() const
+		# 
+        # /** \brief Returns the bounds of the voxel structure, which is pointer to the internal array of 6 doubles: (min_x, max_x, min_y, max_y, min_z, max_z). */
+        # inline const float* getBounds() const
+		# 
+        # /** \brief Copies the bounds of the voxel structure to 'b'. */
+        # inline void getBounds(REAL b[6]) const
+		# 
+        # /** \brief Returns the voxel spacing in x, y and z direction. That's the same as the voxel size along each axis. */
+        # const REAL* getVoxelSpacing() const
+		# 
+        # /** \brief Saves pointers to the voxels which are neighbors of the voxels which contains 'p'. The containing voxel is returned too.
+        #     * 'neighs' has to be an array of pointers with space for at least 27 pointers (27 = 3^3 which is the max number of neighbors). The */
+        # inline int getNeighbors (const REAL* p, T **neighs) const;
+
+###
diff --git a/pcl/pcl_base_172.txt b/pcl/pcl_base_172.txt
new file mode 100644
index 0000000..3f75d24
--- /dev/null
+++ b/pcl/pcl_base_172.txt
@@ -0,0 +1,439 @@
+# # cloud_iterator.h
+# #include <pcl/point_cloud.h>
+# #include <pcl/PointIndices.h>
+# #include <pcl/correspondence.h>
+# 
+# namespace pcl
+# {
+# /** \brief Iterator class for point clouds with or without given indices
+# * \author Suat Gedikli
+# */
+# template <typename PointT>
+# class CloudIterator
+		# public:
+		# CloudIterator (PointCloud<PointT>& cloud);
+		# CloudIterator (PointCloud<PointT>& cloud, const std::vector<int>& indices);
+		# CloudIterator (PointCloud<PointT>& cloud, const PointIndices& indices);
+		# CloudIterator (PointCloud<PointT>& cloud, const Correspondences& corrs, bool source);
+		# ~CloudIterator ();
+		# void operator ++ ();
+		# void operator ++ (int);
+		# PointT& operator* () const;
+		# PointT* operator-> () const;
+		# unsigned getCurrentPointIndex () const;
+		# unsigned getCurrentIndex () const;
+		# /** \brief Size of the range the iterator is going through. Depending on how the CloudIterator was constructed this is the size of the cloud or indices/correspondences. */
+		# size_t size () const;
+		# void reset ();
+		# bool isValid () const;
+		# operator bool () const
+
+
+###
+
+# /** \brief Iterator class for point clouds with or without given indices
+# * \author Suat Gedikli
+# */
+# namespace pcl
+# template <typename PointT>
+# class ConstCloudIterator
+# {
+		public:
+		ConstCloudIterator (const PointCloud<PointT>& cloud);
+		ConstCloudIterator (const PointCloud<PointT>& cloud, const std::vector<int>& indices);
+		ConstCloudIterator (const PointCloud<PointT>& cloud, const PointIndices& indices);
+		ConstCloudIterator (const PointCloud<PointT>& cloud, const Correspondences& corrs, bool source);
+		~ConstCloudIterator ();
+		
+		void operator ++ ();
+		void operator ++ (int);
+		const PointT& operator* () const;
+		const PointT* operator-> () const;
+		unsigned getCurrentPointIndex () const;
+		unsigned getCurrentIndex () const;
+		/** \brief Size of the range the iterator is going through. Depending on how the ConstCloudIterator was constructed this is the size of the cloud or indices/correspondences. */
+		size_t size () const;
+		void reset ();
+		bool isValid () const;
+		operator bool () const
+
+
+###
+
+# conversions.h
+namespace pcl
+namespace detail
+// For converting template point cloud to message.
+template<typename PointT>
+struct FieldAdder
+		# FieldAdder (std::vector<pcl::PCLPointField>& fields) : fields_ (fields) {};
+		# template<typename U> void operator() ()
+		# 
+		# // For converting message to template point cloud.
+		# template<typename PointT>
+		# struct FieldMapper
+			# FieldMapper (const std::vector<pcl::PCLPointField>& fields, std::vector<FieldMapping>& map) : fields_ (fields), map_ (map)
+		# 
+		# template<typename Tag> void operator () ()
+		# 
+		# inline bool fieldOrdering (const FieldMapping& a, const FieldMapping& b)
+
+	namespace detail
+  	template<typename PointT> void createMapping (const std::vector<pcl::PCLPointField>& msg_fields, MsgFieldMap& field_map)
+
+  	/** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.
+     * \param[in] msg the PCLPointCloud2 binary blob
+     * \param[out] cloud the resultant pcl::PointCloud<T>
+     * \param[in] field_map a MsgFieldMap object
+     * \note Use fromPCLPointCloud2 (PCLPointCloud2, PointCloud<T>) directly or create you
+     * own MsgFieldMap using:
+     *
+     * \code
+     * MsgFieldMap field_map;
+     * createMapping<PointT> (msg.fields, field_map);
+     * \endcode
+     */
+  	template <typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)
+
+  	/** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object.
+     * \param[in] msg the PCLPointCloud2 binary blob
+     * \param[out] cloud the resultant pcl::PointCloud<T>
+     */
+  	template<typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud)
+
+  	/** \brief Convert a pcl::PointCloud<T> object to a PCLPointCloud2 binary data blob.
+     * \param[in] cloud the input pcl::PointCloud<T>
+     * \param[out] msg the resultant PCLPointCloud2 binary blob
+     */
+  	template<typename PointT> void toPCLPointCloud2 (const pcl::PointCloud<PointT>& cloud, pcl::PCLPointCloud2& msg)
+	
+   	/** \brief Copy the RGB fields of a PointCloud into pcl::PCLImage format
+     * \param[in] cloud the point cloud message
+     * \param[out] msg the resultant pcl::PCLImage
+     * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>
+     * \note will throw std::runtime_error if there is a problem
+     */
+  	template<typename CloudT> void toPCLPointCloud2 (const CloudT& cloud, pcl::PCLImage& msg)
+	
+  	/** \brief Copy the RGB fields of a PCLPointCloud2 msg into pcl::PCLImage format
+     * \param cloud the point cloud message
+     * \param msg the resultant pcl::PCLImage
+     * will throw std::runtime_error if there is a problem
+     */
+  	inline void toPCLPointCloud2 (const pcl::PCLPointCloud2& cloud, pcl::PCLImage& msg)
+
+
+###
+
+# correspondence.h
+# namespace pcl
+	# /** \brief Correspondence represents a match between two entities (e.g., points, descriptors, etc). This is 
+	#  * represesented via the indices of a \a source point and a \a target point, and the distance between them.
+	#  *
+	#  * \author Dirk Holz, Radu B. Rusu, Bastian Steder
+	#  * \ingroup common
+	#  */
+	struct Correspondence
+    	/** \brief Index of the query (source) point. */
+    	int index_query;
+    	/** \brief Index of the matching (target) point. Set to -1 if no correspondence found. */
+    	int index_match;
+    	/** \brief Distance between the corresponding points, or the weight denoting the confidence in correspondence estimation */
+    	union
+    	{
+      		float distance;
+      		float weight;
+    	};
+    	
+    	/** \brief Standard constructor. 
+      	 * Sets \ref index_query to 0, \ref index_match to -1, and \ref distance to FLT_MAX.
+      	 */
+    	inline Correspondence () : index_query (0), index_match (-1), distance (std::numeric_limits<float>::max ())
+		
+    	/** \brief Constructor. */
+    	inline Correspondence (int _index_query, int _index_match, float _distance) : index_query (_index_query), index_match (_index_match), distance (_distance)
+		
+    	/** \brief Empty destructor. */
+    	virtual ~Correspondence () {}
+	
+	/** \brief overloaded << operator */
+  	PCL_EXPORTS std::ostream& operator << (std::ostream& os, const Correspondence& c);
+	
+  	typedef std::vector< pcl::Correspondence, Eigen::aligned_allocator<pcl::Correspondence> > Correspondences;
+  	typedef boost::shared_ptr<Correspondences> CorrespondencesPtr;
+  	typedef boost::shared_ptr<const Correspondences > CorrespondencesConstPtr;
+	
+  	/**
+     * \brief Get the query points of correspondences that are present in
+     * one correspondence vector but not in the other, e.g., to compare
+     * correspondences before and after rejection.
+     * \param[in] correspondences_before Vector of correspondences before rejection
+     * \param[in] correspondences_after Vector of correspondences after rejection
+     * \param[out] indices Query point indices of correspondences that have been rejected
+     * \param[in] presorting_required Enable/disable internal sorting of vectors.
+     * By default (true), vectors are internally sorted before determining their difference.
+     * If the order of correspondences in \a correspondences_after is not different (has not been changed)
+     * from the order in \b correspondences_before this pre-processing step can be disabled
+     * in order to gain efficiency. In order to disable pre-sorting set \a presorting_requered to false.
+     */
+  	void getRejectedQueryIndices (const pcl::Correspondences &correspondences_before, const pcl::Correspondences &correspondences_after, std::vector<int>& indices, bool presorting_required = true);
+	
+  	/**
+     * \brief Representation of a (possible) correspondence between two 3D points in two different coordinate frames
+     *        (e.g. from feature matching)
+     * \ingroup common
+     */
+  	struct PointCorrespondence3D : public Correspondence
+  	{
+    	Eigen::Vector3f point1;  //!< The 3D position of the point in the first coordinate frame
+    	Eigen::Vector3f point2;  //!< The 3D position of the point in the second coordinate frame
+		
+    	/** \brief Empty constructor. */
+    	PointCorrespondence3D () : point1 (), point2 () {}
+		
+    	/** \brief Empty destructor. */
+    	virtual ~PointCorrespondence3D () {}
+    	
+    	EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+  	};
+  	typedef std::vector<PointCorrespondence3D, Eigen::aligned_allocator<PointCorrespondence3D> > PointCorrespondences3DVector;
+	
+  	/**
+     * \brief Representation of a (possible) correspondence between two points (e.g. from feature matching),
+     *        that encode complete 6DOF transoformations.
+     * \ingroup common
+     */
+  	struct PointCorrespondence6D : public PointCorrespondence3D
+  	{
+    	Eigen::Affine3f transformation;  //!< The transformation to go from the coordinate system
+                                         //!< of point2 to the coordinate system of point1
+    	/** \brief Empty destructor. */
+    	virtual ~PointCorrespondence6D () {}
+		
+    	EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+  	};
+  	typedef std::vector<PointCorrespondence6D, Eigen::aligned_allocator<PointCorrespondence6D> > PointCorrespondences6DVector;
+	
+  	/**
+     * \brief Comparator to enable us to sort a vector of PointCorrespondences according to their scores using
+     *        std::sort (begin(), end(), isBetterCorrespondence);
+     * \ingroup common
+     */
+  	inline bool isBetterCorrespondence (const Correspondence &pc1, const Correspondence &pc2)
+
+
+###
+
+# exceptions.h
+#include <stdexcept>
+#include <sstream>
+#include <pcl/pcl_macros.h>
+#include <boost/current_function.hpp>
+
+/** PCL_THROW_EXCEPTION a helper macro to be used for throwing exceptions.
+  * This is an example on how to use:
+  * PCL_THROW_EXCEPTION(IOException,
+  *                     "encountered an error while opening " << filename << " PCD file");
+  */
+#define PCL_THROW_EXCEPTION(ExceptionName, message)                         \
+{                                                                           \
+  std::ostringstream s;                                                     \
+  s << message;                                                             \
+  s.flush ();                                                               \
+  throw ExceptionName(s.str(), __FILE__, BOOST_CURRENT_FUNCTION, __LINE__); \
+}
+
+namespace pcl
+	/** \class PCLException
+     * \brief A base class for all pcl exceptions which inherits from std::runtime_error
+     * \author Eitan Marder-Eppstein, Suat Gedikli, Nizar Sallem
+     */
+  	class PCLException : public std::runtime_error
+  	{
+    	public:
+      	PCLException (const std::string& error_description,
+                      const std::string& file_name = "",
+                      const std::string& function_name = "" ,
+                      unsigned line_number = 0) throw ()
+        : std::runtime_error (error_description)
+        , file_name_ (file_name)
+        , function_name_ (function_name)
+        , message_ (error_description)
+        , line_number_ (line_number) 
+      	
+      	virtual ~PCLException () throw ()
+      	
+      	const std::string& getFileName () const throw ()
+		
+      	const std::string& getFunctionName () const throw ()
+		
+      	unsigned getLineNumber () const throw ()
+		
+      	std::string detailedMessage () const throw ()
+		
+      	char const* what () const throw () 
+		
+	/** \class InvalidConversionException
+     * \brief An exception that is thrown when a PCLPointCloud2 message cannot be converted into a PCL type
+     */
+  	class InvalidConversionException : public PCLException
+    	public:
+      	InvalidConversionException (const std::string& error_description,
+                                    const std::string& file_name = "",
+                                    const std::string& function_name = "" ,
+                                    unsigned line_number = 0) throw ()
+        : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	/** \class IsNotDenseException
+     * \brief An exception that is thrown when a PointCloud is not dense but is attemped to be used as dense
+     */
+  	class IsNotDenseException : public PCLException
+    	public:
+      	IsNotDenseException (const std::string& error_description,
+                             const std::string& file_name = "",
+                             const std::string& function_name = "" ,
+                             unsigned line_number = 0) throw ()
+        : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	/** \class InvalidSACModelTypeException
+     * \brief An exception that is thrown when a sample consensus model doesn't
+     * have the correct number of samples defined in model_types.h
+     */
+  	class InvalidSACModelTypeException : public PCLException
+    	public:
+      	InvalidSACModelTypeException (const std::string& error_description,
+                                      const std::string& file_name = "",
+                                      const std::string& function_name = "" ,
+                                      unsigned line_number = 0) throw ()
+        : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	/** \class IOException
+     * \brief An exception that is thrown during an IO error (typical read/write errors)
+     */
+  	class IOException : public PCLException
+    	public:
+		
+      	IOException (const std::string& error_description,
+                     const std::string& file_name = "",
+                     const std::string& function_name = "" ,
+                     unsigned line_number = 0) throw ()
+        : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+
+  	/** \class InitFailedException
+     * \brief An exception thrown when init can not be performed should be used in all the
+     * PCLBase class inheritants.
+     */
+  	class InitFailedException : public PCLException
+    	public:
+      	InitFailedException (const std::string& error_description = "",
+                             const std::string& file_name = "",
+                             const std::string& function_name = "" ,
+                             unsigned line_number = 0) throw ()
+        : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	/** \class UnorganizedPointCloudException
+     * \brief An exception that is thrown when an organized point cloud is needed
+     * but not provided.
+     */
+  	class UnorganizedPointCloudException : public PCLException
+    	public:
+        UnorganizedPointCloudException (const std::string& error_description,
+                                        const std::string& file_name = "",
+                                        const std::string& function_name = "" ,
+                                        unsigned line_number = 0) throw ()
+        : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	/** \class KernelWidthTooSmallException
+     * \brief An exception that is thrown when the kernel size is too small
+     */
+  	class KernelWidthTooSmallException : public PCLException
+    	public:
+    	KernelWidthTooSmallException (const std::string& error_description,
+                                      const std::string& file_name = "",
+                                      const std::string& function_name = "" ,
+                                      unsigned line_number = 0) throw ()
+      : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	class UnhandledPointTypeException : public PCLException
+    	public:
+    	UnhandledPointTypeException (const std::string& error_description,
+                                     const std::string& file_name = "",
+                                     const std::string& function_name = "" ,
+                                     unsigned line_number = 0) throw ()
+      : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	class ComputeFailedException : public PCLException
+    	public:
+    	ComputeFailedException (const std::string& error_description,
+                                const std::string& file_name = "",
+                                const std::string& function_name = "" ,
+                                unsigned line_number = 0) throw ()
+      : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+	
+  	/** \class BadArgumentException
+     * \brief An exception that is thrown when the argments number or type is wrong/unhandled.
+     */
+  	class BadArgumentException : public PCLException
+    	public:
+    	BadArgumentException (const std::string& error_description,
+                              const std::string& file_name = "",
+                              const std::string& function_name = "" ,
+                              unsigned line_number = 0) throw ()
+      : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+
+
+###
+
+# # for_each_type.h
+# 
+# namespace pcl 
+#   //////////////////////////////////////////////////////////////////////////////////////////////
+#   template <bool done = true>
+#   struct for_each_type_impl
+#   {
+#     template<typename Iterator, typename LastIterator, typename F>
+#     static void execute (F) {}
+#   };
+# 
+#   //////////////////////////////////////////////////////////////////////////////////////////////
+#   template <>
+#   struct for_each_type_impl<false>
+#   {
+#     template<typename Iterator, typename LastIterator, typename F> static void execute (F f)
+#   };
+# 
+#   //////////////////////////////////////////////////////////////////////////////////////////////
+#   template<typename Sequence, typename F> inline void for_each_type (F f)
+# 
+#   //////////////////////////////////////////////////////////////////////////////////////////////
+#   template <typename Sequence1, typename Sequence2>
+#   struct intersect 
+#   { 
+#     typedef typename boost::mpl::remove_if<Sequence1, boost::mpl::not_<boost::mpl::contains<Sequence2, boost::mpl::_1> > >::type type; 
+#   }; 
+# }
+# 
+###
+
+# ModelCoefficients.h
+# PCLHeader.h
+# PCLImage.h
+# PCLPointCloud2.h
+# PCLPointField.h
+# pcl_base.h
+# pcl_config.h
+# pcl_exports.h
+# pcl_macros.h
+# pcl_tests.h
+# PointIndices.h
+# point_cloud.h
+# point_representation.h
+# point_traits.h
+# point_types.h
+# point_types_conversion.h
+# PolygonMesh.h
+# register_point_struct.h
+# sse.h
+# TextureMesh.h
+# Vertices.h
+###
\ No newline at end of file
diff --git a/pcl/pcl_common.pxd b/pcl/pcl_common.pxd
new file mode 100644
index 0000000..a79a55f
--- /dev/null
+++ b/pcl/pcl_common.pxd
@@ -0,0 +1,5329 @@
+# -*- coding: utf-8 -*-
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport numpy as cnp
+
+cimport cython
+
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+
+cimport eigen as eigen3
+
+from boost_shared_ptr cimport shared_ptr
+
+
+# common/angles.h
+# namespace pcl
+cdef extern from "pcl/common/angles.h" namespace "pcl":
+    # brief Convert an angle from radians to degrees
+    # param alpha the input angle (in radians)
+    # ingroup common
+    # inline float rad2deg (float alpha);
+    cdef float rad2deg (float alpha)
+    
+    # brief Convert an angle from degrees to radians
+    # param alpha the input angle (in degrees)
+    # ingroup common
+    # inline float deg2rad (float alpha);
+    cdef float deg2rad (float alpha)
+    
+    # brief Convert an angle from radians to degrees
+    # param alpha the input angle (in radians)
+    # ingroup common
+    # inline double rad2deg (double alpha);
+    cdef double deg2rad (double alpha)
+    
+    # brief Convert an angle from degrees to radians
+    # param alpha the input angle (in degrees)
+    # ingroup common
+    # inline double deg2rad (double alpha);
+    cdef double deg2rad (double alpha)
+    
+    # brief Normalize an angle to (-PI, PI]
+    # param alpha the input angle (in radians)
+    # ingroup common
+    # inline float normAngle (float alpha);
+    cdef float normAngle (float alpha)
+
+
+###
+
+# bivariate_polynomial.h
+# namespace pcl 
+# /** \brief This represents a bivariate polynomial and provides some functionality for it
+#   * \author Bastian Steder 
+#   * \ingroup common
+#   */
+# template<typename real> class BivariatePolynomialT 
+# cdef extern from "pcl/common/bivariate_polynomial.h" namespace "pcl":
+#     class BivariatePolynomialT[real]
+#         BivariatePolynomialT()
+        # public:
+        # //-----CONSTRUCTOR&DESTRUCTOR-----
+        # /** Constructor */
+        # BivariatePolynomialT (int new_degree=0);
+        # /** Copy constructor */
+        # BivariatePolynomialT (const BivariatePolynomialT& other);
+        # /** Destructor */
+        # ~BivariatePolynomialT ();
+        # 
+        # //-----OPERATORS-----
+        # /** = operator */
+        # BivariatePolynomialT& operator= (const BivariatePolynomialT& other) { deepCopy (other); return *this;}
+        # 
+        # //-----METHODS-----
+        # /** Initialize members to default values */
+        # void setDegree (int new_degree);
+        # void setDegree (int new_degree)
+        # 
+        # /** How many parametes has a bivariate polynomial with this degree */
+        # unsigned int getNoOfParameters () const { return getNoOfParametersFromDegree (degree);}
+        # int getNoOfParameters ()
+        # 
+        # /** Calculate the value of the polynomial at the given point */
+        # real getValue (real x, real y) const;  
+        # real getValue (real x, real y)
+        # 
+        # /** Calculate the gradient of this polynomial
+        #  *  If forceRecalc is false, it will do nothing when the gradient already exists */
+        # void calculateGradient (bool forceRecalc=false);
+        # void calculateGradient (bool forceRecalc)
+        # 
+        # /** Calculate the value of the gradient at the given point */
+        # void getValueOfGradient (real x, real y, real& gradX, real& gradY);
+        # void getValueOfGradient (real x, real y, real& gradX, real& gradY);
+        # 
+        # /** Returns critical points of the polynomial. type can be 0=maximum, 1=minimum, or 2=saddle point
+        #  *  !!Currently only implemented for degree 2!! */
+        # void findCriticalPoints (std::vector<real>& x_values, std::vector<real>& y_values, std::vector<int>& types) const;
+        # 
+        # /** write as binary to a stream */
+        # void writeBinary (std::ostream& os) const;
+        # 
+        # /** write as binary into a file */
+        # void writeBinary (const char* filename) const;
+        # 
+        # /** read binary from a stream */
+        # void readBinary (std::istream& os);
+        # 
+        # /** read binary from a file */
+        # void readBinary (const char* filename);
+        # 
+        # /** How many parametes has a bivariate polynomial of the given degree */
+        # static unsigned int getNoOfParametersFromDegree (int n) { return ((n+2)* (n+1))/2;}
+        
+    # template<typename real> std::ostream& operator<< (std::ostream& os, const BivariatePolynomialT<real>& p);
+    # typedef BivariatePolynomialT<double> BivariatePolynomiald;
+    # typedef BivariatePolynomialT<float>  BivariatePolynomial;
+
+
+###
+
+# boost.h
+# // Marking all Boost headers as system headers to remove warnings
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# \brief Compute the 3D (X-Y-Z) centroid of a set of points and return it as a 3D vector.
+# \param[in] cloud_iterator an iterator over the input point cloud
+# \param[out] centroid the output centroid
+# \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+# \note if return value is 0, the centroid is not changed, thus not valid.
+#  The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+# \ingroup common
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Matrix<Scalar, 4, 1> &centroid);
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#     unsigned int compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3D (X-Y-Z) centroid of a set of points and return it as a 3D vector.
+#   * \param[in] cloud the input point cloud
+#   * \param[out] centroid the output centroid
+#   * \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the centroid is not changed, thus not valid.
+#   * The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, Eigen::Vector4f &centroid)
+###
+
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, Eigen::Vector4d &centroid)
+###
+
+# /** \brief Compute the 3D (X-Y-Z) centroid of a set of points using their indices and
+#   * return it as a 3D vector.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[out] centroid the output centroid
+#   * \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the centroid is not changed, thus not valid.
+#   * The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, Eigen::Vector4d &centroid)
+###
+
+# /** \brief Compute the 3D (X-Y-Z) centroid of a set of points using their indices and
+#   * return it as a 3D vector.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[out] centroid the output centroid
+#   * \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the centroid is not changed, thus not valid.
+#   * The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3x3 covariance matrix of a given set of points.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Note: the covariance matrix is not normalized with the number of
+#   * points. For a normalized covariance, please use
+#   * computeNormalizedCovarianceMatrix.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the covariance matrix is not changed, thus not valid.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud, const Eigen::Matrix<Scalar, 4, 1> &centroid, Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const Eigen::Vector4f &centroid,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const Eigen::Vector4d &centroid,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute normalized the 3x3 covariance matrix of a given set of points.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Normalized means that every entry has been divided by the number of points in the point cloud.
+#   * For small number of points, or if you want explicitely the sample-variance, use computeCovarianceMatrix
+#   * and scale the covariance matrix with 1 / (n-1), where n is the number of points used to calculate
+#   * the covariance matrix and is returned by the computeCovarianceMatrix function.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                                    Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const Eigen::Vector4f &centroid,
+#                                    Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const Eigen::Vector4d &centroid,
+#                                    Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3x3 covariance matrix of a given set of points using their indices.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Note: the covariance matrix is not normalized with the number of
+#   * points. For a normalized covariance, please use
+#   * computeNormalizedCovarianceMatrix.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          const Eigen::Vector4f &centroid,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          const Eigen::Vector4d &centroid,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3x3 covariance matrix of a given set of points using their indices.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Note: the covariance matrix is not normalized with the number of
+#   * points. For a normalized covariance, please use
+#   * computeNormalizedCovarianceMatrix.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          const Eigen::Vector4f &centroid,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          const Eigen::Vector4d &centroid,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix of a given set of points using
+#   * their indices.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, use computeCovarianceMatrix
+#   * and scale the covariance matrix with 1 / (n-1), where n is the number of points used to calculate
+#   * the covariance matrix and is returned by the computeCovarianceMatrix function.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const std::vector<int> &indices,
+#                                    const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                                    Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const std::vector<int> &indices,
+#                                    const Eigen::Vector4f &centroid,
+#                                    Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const std::vector<int> &indices,
+#                                    const Eigen::Vector4d &centroid,
+#                                    Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix of a given set of points using
+#   * their indices. The result is returned as a Eigen::Matrix3f.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, use computeCovarianceMatrix
+#   * and scale the covariance matrix with 1 / (n-1), where n is the number of points used to calculate
+#   * the covariance matrix and is returned by the computeCovarianceMatrix function.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const pcl::PointIndices &indices,
+#                                    const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                                    Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const pcl::PointIndices &indices,
+#                                    const Eigen::Vector4f &centroid,
+#                                    Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const pcl::PointIndices &indices,
+#                                    const Eigen::Vector4d &centroid,
+#                                    Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix and the centroid of a given set of points in a single loop.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \param[out] centroid the centroid of the set of points in the cloud
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 Eigen::Matrix<Scalar, 3, 3> &covariance_matrix,
+#                                 Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 Eigen::Matrix3f &covariance_matrix,
+#                                 Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 Eigen::Matrix3d &covariance_matrix,
+#                                 Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix and the centroid of a given set of points in a single loop.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \param[out] centroid the centroid of the set of points in the cloud
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const std::vector<int> &indices,
+#                                 Eigen::Matrix<Scalar, 3, 3> &covariance_matrix,
+#                                 Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const std::vector<int> &indices,
+#                                 Eigen::Matrix3f &covariance_matrix,
+#                                 Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const std::vector<int> &indices,
+#                                 Eigen::Matrix3d &covariance_matrix,
+#                                 Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix and the centroid of a given set of points in a single loop.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const pcl::PointIndices &indices,
+#                                 Eigen::Matrix<Scalar, 3, 3> &covariance_matrix,
+#                                 Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const pcl::PointIndices &indices,
+#                                 Eigen::Matrix3f &covariance_matrix,
+#                                 Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const pcl::PointIndices &indices,
+#                                 Eigen::Matrix3d &covariance_matrix,
+#                                 Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix for a already demeaned point cloud.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix for a already demeaned point cloud.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix for a already demeaned point cloud.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_iterator an iterator over the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] npts the number of samples guaranteed to be left in the input cloud, accessible by the iterator. If not given, it will be calculated.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out,
+#                   int npts = 0);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] centroid the centroid of the point cloud
+#   * \param cloud_out the resultant output point cloud
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] centroid the centroid of the point cloud
+#   * \param cloud_out the resultant output point cloud
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const pcl::PointIndices& indices,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const pcl::PointIndices& indices,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const pcl::PointIndices& indices,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#   * representation as an Eigen matrix
+#   * \param[in] cloud_iterator an iterator over the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#   * an Eigen matrix (4 rows, N pts columns)
+#   * \param[in] npts the number of samples guaranteed to be left in the input cloud, accessible by the iterator. If not given, it will be calculated.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out,
+#                   int npts = 0);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4f &centroid,
+#                   Eigen::MatrixXf &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4d &centroid,
+#                   Eigen::MatrixXd &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#   * representation as an Eigen matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#   * an Eigen matrix (4 rows, N pts columns)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Vector4f &centroid,
+#                   Eigen::MatrixXf &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Vector4d &centroid,
+#                   Eigen::MatrixXd &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#   * representation as an Eigen matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#   * an Eigen matrix (4 rows, N pts columns)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const std::vector<int> &indices,
+#                     const Eigen::Vector4f &centroid,
+#                     Eigen::MatrixXf &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const std::vector<int> &indices,
+#                     const Eigen::Vector4d &centroid,
+#                     Eigen::MatrixXd &cloud_out)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#     * representation as an Eigen matrix
+#     * \param[in] cloud_in the input point cloud
+#     * \param[in] indices the set of point indices to use from the input point cloud
+#     * \param[in] centroid the centroid of the point cloud
+#     * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#     * an Eigen matrix (4 rows, N pts columns)
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const pcl::PointIndices& indices,
+#                     const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                     Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out);
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const pcl::PointIndices& indices,
+#                     const Eigen::Vector4f &centroid,
+#                     Eigen::MatrixXf &cloud_out)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const pcl::PointIndices& indices,
+#                     const Eigen::Vector4d &centroid,
+#                     Eigen::MatrixXd &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief Helper functor structure for n-D centroid estimation. */
+#   template<typename PointT, typename Scalar>
+#   struct NdCentroidFunctor
+#   {
+#     typedef typename traits::POD<PointT>::type Pod;
+# 
+#     NdCentroidFunctor (const PointT &p, Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid)
+#       : f_idx_ (0),
+#         centroid_ (centroid),
+#         p_ (reinterpret_cast<const Pod&>(p)) { }
+# 
+#     template<typename Key> inline void operator() ()
+# 
+#   };
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief General, all purpose nD centroid estimation for a set of points using their
+#     * indices.
+#     * \param cloud the input point cloud
+#     * \param centroid the output centroid
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid);
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      Eigen::VectorXf &centroid)
+#   {
+#     return (computeNDCentroid<PointT, float> (cloud, centroid));
+#   }
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      Eigen::VectorXd &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief General, all purpose nD centroid estimation for a set of points using their
+#     * indices.
+#     * \param cloud the input point cloud
+#     * \param indices the point cloud indices that need to be used
+#     * \param centroid the output centroid
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud,
+#                      const std::vector<int> &indices, 
+#                      Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const std::vector<int> &indices, 
+#                      Eigen::VectorXf &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const std::vector<int> &indices, 
+#                      Eigen::VectorXd &centroid)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief General, all purpose nD centroid estimation for a set of points using their
+#     * indices.
+#     * \param cloud the input point cloud
+#     * \param indices the point cloud indices that need to be used
+#     * \param centroid the output centroid
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud,
+#                      const pcl::PointIndices &indices, 
+#                      Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid);
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const pcl::PointIndices &indices, 
+#                      Eigen::VectorXf &centroid)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const pcl::PointIndices &indices, 
+#                      Eigen::VectorXd &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** A generic class that computes the centroid of points fed to it.
+#     * Here by "centroid" we denote not just the mean of 3D point coordinates,
+#     * but also mean of values in the other data fields. The general-purpose
+#     * \ref computeNDCentroid() function also implements this sort of
+#     * functionality, however it does it in a "dumb" way, i.e. regardless of the
+#     * semantics of the data inside a field it simply averages the values. In
+#     * certain cases (e.g. for \c x, \c y, \c z, \c intensity fields) this
+#     * behavior is reasonable, however in other cases (e.g. \c rgb, \c rgba,
+#     * \c label fields) this does not lead to meaningful results.
+#     * This class is capable of computing the centroid in a "smart" way, i.e.
+#     * taking into account the meaning of the data inside fields. Currently the
+#     * following fields are supported:
+#     * - XYZ (\c x, \c y, \c z)
+#     *   Separate average for each field.
+#     * - Normal (\c normal_x, \c normal_y, \c normal_z)
+#     *   Separate average for each field, and the resulting vector is normalized.
+#     * - Curvature (\c curvature)
+#     *   Average.
+#     * - RGB/RGBA (\c rgb or \c rgba)
+#     *   Separate average for R, G, B, and alpha channels.
+#     * - Intensity (\c intensity)
+#     *   Average.
+#     * - Label (\c label)
+#     *   Majority vote. If several labels have the same largest support then the
+#     *   smaller label wins.
+#     *
+#     * The template parameter defines the type of points that may be accumulated
+#     * with this class. This may be an arbitrary PCL point type, and centroid
+#     * computation will happen only for the fields that are present in it and are
+#     * supported.
+#     *
+#     * Current centroid may be retrieved at any time using get(). Note that the
+#     * function is templated on point type, so it is possible to fetch the
+#     * centroid into a point type that differs from the type of points that are
+#     * being accumulated. All the "extra" fields for which the centroid is not
+#     * being calculated will be left untouched.
+#     *
+#     * Example usage:
+#     *
+#     * \code
+#     * // Create and accumulate points
+#     * CentroidPoint<pcl::PointXYZ> centroid;
+#     * centroid.add (pcl::PointXYZ (1, 2, 3);
+#     * centroid.add (pcl::PointXYZ (5, 6, 7);
+#     * // Fetch centroid using `get()`
+#     * pcl::PointXYZ c1;
+#     * centroid.get (c1);
+#     * // The expected result is: c1.x == 3, c1.y == 4, c1.z == 5
+#     * // It is also okay to use `get()` with a different point type
+#     * pcl::PointXYZRGB c2;
+#     * centroid.get (c2);
+#     * // The expected result is: c2.x == 3, c2.y == 4, c2.z == 5,
+#     * // and c2.rgb is left untouched
+#     * \endcode
+#     *
+#     * \note Assumes that the points being inserted are valid.
+#     *
+#     * \note This class template can be successfully instantiated for *any*
+#     * PCL point type. Of course, each of the field averages is computed only if
+#     * the point type has the corresponding field.
+#     *
+#     * \ingroup common
+#     * \author Sergey Alexandrov */
+# template <typename PointT>
+# class CentroidPoint
+#       
+#       public:
+#       
+#       CentroidPoint ()
+#       : num_points_ (0)
+#       {
+#       }
+# 
+#       /** Add a new point to the centroid computation.
+#         *
+#         * In this function only the accumulators and point counter are updated,
+#         * actual centroid computation does not happen until get() is called. */
+#       void
+#       add (const PointT& point)
+#       {
+#         // Invoke add point on each accumulator
+#         boost::fusion::for_each (accumulators_, detail::AddPoint<PointT> (point));
+#         ++num_points_;
+#       }
+# 
+#       /** Retrieve the current centroid.
+#         *
+#         * Computation (division of accumulated values by the number of points
+#         * and normalization where applicable) happens here. The result is not
+#         * cached, so any subsequent call to this function will trigger
+#         * re-computation.
+#         *
+#         * If the number of accumulated points is zero, then the point will be
+#         * left untouched. */
+#       template <typename PointOutT> void
+#       get (PointOutT& point) const
+#       {
+#         if (num_points_ != 0)
+#         {
+#           // Filter accumulators so that only those that are compatible with
+#           // both PointT and requested point type remain
+#           typename pcl::detail::Accumulators<PointT, PointOutT>::type ca (accumulators_);
+#           // Invoke get point on each accumulator in filtered list
+#           boost::fusion::for_each (ca, detail::GetPoint<PointOutT> (point, num_points_));
+#         }
+#       }
+# 
+#       /** Get the total number of points that were added. */
+#       size_t getSize () const
+# 
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+# 
+# 
+#   };
+# 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** Compute the centroid of a set of points and return it as a point.
+#     *
+#     * Implementation leverages \ref CentroidPoint class and therefore behaves
+#     * differently from \ref compute3DCentroid() and \ref computeNDCentroid().
+#     * See \ref CentroidPoint documentation for explanation.
+#     *
+#     * \param[in] cloud input point cloud
+#     * \param[out] centroid output centroid
+#     *
+#     * \return number of valid points used to determine the centroid (will be the
+#     * same as the size of the cloud if it is dense)
+#     *
+#     * \note If return value is \c 0, then the centroid is not changed, thus is
+#     * not valid.
+#     *
+#     * \ingroup common */
+#   template <typename PointInT, typename PointOutT> size_t
+#   computeCentroid (const pcl::PointCloud<PointInT>& cloud,
+#                    PointOutT& centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** Compute the centroid of a set of points and return it as a point.
+#     * \param[in] cloud
+#     * \param[in] indices point cloud indices that need to be used
+#     * \param[out] centroid
+#     * This is an overloaded function provided for convenience. See the
+#     * documentation for computeCentroid().
+#     *
+#     * \ingroup common */
+#   template <typename PointInT, typename PointOutT> size_t
+#   computeCentroid (const pcl::PointCloud<PointInT>& cloud,
+#                    const std::vector<int>& indices,
+#                    PointOutT& centroid);
+# 
+###
+
+### end of centroid.h file ###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute the smallest angle between two vectors in the [ 0, PI ) interval in 3D.
+#   * \param v1 the first 3D vector (represented as a \a Eigen::Vector4f)
+#   * \param v2 the second 3D vector (represented as a \a Eigen::Vector4f)
+#   * \return the angle between v1 and v2
+#   * \ingroup common
+#   */
+# inline double getAngle3D (const Eigen::Vector4f &v1, const Eigen::Vector4f &v2);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute both the mean and the standard deviation of an array of values
+#   * \param values the array of values
+#   * \param mean the resultant mean of the distribution
+#   * \param stddev the resultant standard deviation of the distribution
+#   * \ingroup common
+#   */
+# inline void getMeanStd (const std::vector<float> &values, double &mean, double &stddev);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get a set of points residing in a box given its bounds
+#   * \param cloud the point cloud data message
+#   * \param min_pt the minimum bounds
+#   * \param max_pt the maximum bounds
+#   * \param indices the resultant set of point indices residing in the box
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getPointsInBox (const pcl::PointCloud<PointT> &cloud, Eigen::Vector4f &min_pt,
+#                 Eigen::Vector4f &max_pt, std::vector<int> &indices);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the point at maximum distance from a given point and a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param pivot_pt the point from where to compute the distance
+#   * \param max_pt the point in cloud that is the farthest point away from pivot_pt
+#   * \ingroup common
+#   */
+# template<typename PointT> inline void
+# getMaxDistance (const pcl::PointCloud<PointT> &cloud, const Eigen::Vector4f &pivot_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the point at maximum distance from a given point and a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param pivot_pt the point from where to compute the distance
+#   * \param indices the vector of point indices to use from \a cloud
+#   * \param max_pt the point in cloud that is the farthest point away from pivot_pt
+#   * \ingroup common
+#   */
+# template<typename PointT> inline void
+# getMaxDistance (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, 
+#                 const Eigen::Vector4f &pivot_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, PointT &min_pt, PointT &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, 
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param indices the vector of point indices to use from \a cloud
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, 
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param indices the vector of point indices to use from \a cloud
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, 
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute the radius of a circumscribed circle for a triangle formed of three points pa, pb, and pc
+#   * \param pa the first point
+#   * \param pb the second point
+#   * \param pc the third point
+#   * \return the radius of the circumscribed circle
+#   * \ingroup common
+#   */
+# template <typename PointT> inline double 
+# getCircumcircleRadius (const PointT &pa, const PointT &pb, const PointT &pc);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on a point histogram
+#   * \param histogram the point representing a multi-dimensional histogram
+#   * \param len the length of the histogram
+#   * \param min_p the resultant minimum 
+#   * \param max_p the resultant maximum 
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax (const PointT &histogram, int len, float &min_p, float &max_p);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Calculate the area of a polygon given a point cloud that defines the polygon 
+#     * \param polygon point cloud that contains those vertices that comprises the polygon. Vertices are stored in counterclockwise.
+#     * \return the polygon area 
+#     * \ingroup common
+#     */
+# template<typename PointT> inline float
+# calculatePolygonArea (const pcl::PointCloud<PointT> &polygon);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on a point histogram
+#   * \param cloud the cloud containing multi-dimensional histograms
+#   * \param idx point index representing the histogram that we need to compute min/max for
+#   * \param field_name the field name containing the multi-dimensional histogram
+#   * \param min_p the resultant minimum 
+#   * \param max_p the resultant maximum 
+#   * \ingroup common
+#   */
+# PCL_EXPORTS void 
+# getMinMax (const pcl::PCLPointCloud2 &cloud, int idx, const std::string &field_name,
+#            float &min_p, float &max_p);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute both the mean and the standard deviation of an array of values
+#   * \param values the array of values
+#   * \param mean the resultant mean of the distribution
+#   * \param stddev the resultant standard deviation of the distribution
+#   * \ingroup common
+#   */
+# PCL_EXPORTS void
+# getMeanStdDev (const std::vector<float> &values, double &mean, double &stddev);
+# 
+###
+
+# common_headers.h
+###
+
+# concatenate.h
+# // We're doing a lot of black magic with Boost here, so disable warnings in Maintainer mode, as we will never
+# // be able to fix them anyway
+# #ifdef BUILD_Maintainer
+# #  if defined __GNUC__
+# #    if __GNUC__ == 4 && __GNUC_MINOR__ > 3
+# #      pragma GCC diagnostic ignored "-Weffc++"
+# #      pragma GCC diagnostic ignored "-pedantic"
+# #    else
+# #      pragma GCC system_header 
+# #    endif
+# #  elif defined _MSC_VER
+# #    pragma warning(push, 1)
+# #  endif
+# #endif
+###
+
+# concatenate.h
+# namespace pcl
+# cdef extern from "pcl/common/concatenate.h" namespace "pcl":
+# /** \brief Helper functor structure for concatenate. 
+#   * \ingroup common
+#   */
+# template<typename PointInT, typename PointOutT>
+# struct NdConcatenateFunctor
+# {
+#   typedef typename traits::POD<PointInT>::type PodIn;
+#   typedef typename traits::POD<PointOutT>::type PodOut;
+#   
+#   NdConcatenateFunctor (const PointInT &p1, PointOutT &p2)
+#     : p1_ (reinterpret_cast<const PodIn&> (p1))
+#     , p2_ (reinterpret_cast<PodOut&> (p2)) { }
+#      template<typename Key> inline void 
+#   operator () ()
+#   {
+#     // This sucks without Fusion :(
+#     //boost::fusion::at_key<Key> (p2_) = boost::fusion::at_key<Key> (p1_);
+#     typedef typename pcl::traits::datatype<PointInT, Key>::type InT;
+#     typedef typename pcl::traits::datatype<PointOutT, Key>::type OutT;
+#     // Note: don't currently support different types for the same field (e.g. converting double to float)
+#     BOOST_MPL_ASSERT_MSG ((boost::is_same<InT, OutT>::value),
+#                           POINT_IN_AND_POINT_OUT_HAVE_DIFFERENT_TYPES_FOR_FIELD,
+#                           (Key, PointInT&, InT, PointOutT&, OutT));
+#     memcpy (reinterpret_cast<uint8_t*>(&p2_) + pcl::traits::offset<PointOutT, Key>::value,
+#             reinterpret_cast<const uint8_t*>(&p1_) + pcl::traits::offset<PointInT, Key>::value,
+#             sizeof (InT));
+#   }
+# }
+###
+
+# concatenate.h
+# namespace pcl
+# cdef extern from "pcl/common/concatenate.h" namespace "pcl":
+#ifdef BUILD_Maintainer
+#  if defined __GNUC__
+#    if __GNUC__ == 4 && __GNUC_MINOR__ > 3
+#      pragma GCC diagnostic warning "-Weffc++"
+#      pragma GCC diagnostic warning "-pedantic"
+#    endif
+#  elif defined _MSC_VER
+#    pragma warning(pop)
+#  endif
+#endif
+###
+
+
+# conversions.h
+# namespace pcl
+# namespace detail
+# cdef extern from "pcl/common/conversions.h" namespace "pcl::detail":
+# // For converting template point cloud to message.
+# template<typename PointT>
+# struct FieldAdder
+# {
+#     FieldAdder (std::vector<pcl::PCLPointField>& fields) : fields_ (fields) {};
+# 
+#       template<typename U> void operator() ()
+#       {
+#         pcl::PCLPointField f;
+#         f.name = traits::name<PointT, U>::value;
+#         f.offset = traits::offset<PointT, U>::value;
+#         f.datatype = traits::datatype<PointT, U>::value;
+#         f.count = traits::datatype<PointT, U>::size;
+#         fields_.push_back (f);
+#       }
+# 
+#       std::vector<pcl::PCLPointField>& fields_;
+#     };
+# 
+#     // For converting message to template point cloud.
+#     template<typename PointT>
+#     struct FieldMapper
+#     {
+#       FieldMapper (const std::vector<pcl::PCLPointField>& fields,
+#                    std::vector<FieldMapping>& map)
+#         : fields_ (fields), map_ (map)
+#       {
+#       }
+# 
+#       template<typename Tag> void
+#       operator () ()
+#       {
+#         BOOST_FOREACH (const pcl::PCLPointField& field, fields_)
+#         {
+#           if (FieldMatches<PointT, Tag>()(field))
+#           {
+#             FieldMapping mapping;
+#             mapping.serialized_offset = field.offset;
+#             mapping.struct_offset = traits::offset<PointT, Tag>::value;
+#             mapping.size = sizeof (typename traits::datatype<PointT, Tag>::type);
+#             map_.push_back (mapping);
+#             return;
+#           }
+#         }
+#         // Disable thrown exception per #595: http://dev.pointclouds.org/issues/595
+#         PCL_WARN ("Failed to find match for field '%s'.\n", traits::name<PointT, Tag>::value);
+#         //throw pcl::InvalidConversionException (ss.str ());
+#       }
+# 
+#       const std::vector<pcl::PCLPointField>& fields_;
+#       std::vector<FieldMapping>& map_;
+#     };
+# 
+#     inline bool fieldOrdering (const FieldMapping& a, const FieldMapping& b)
+# 
+# } //namespace detail
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# template<typename PointT> void createMapping (const std::vector<pcl::PCLPointField>& msg_fields, MsgFieldMap& field_map)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.
+#   * \param[in] msg the PCLPointCloud2 binary blob
+#   * \param[out] cloud the resultant pcl::PointCloud<T>
+#   * \param[in] field_map a MsgFieldMap object
+#   * \note Use fromPCLPointCloud2 (PCLPointCloud2, PointCloud<T>) directly or create you
+#   * own MsgFieldMap using:
+#   * \code
+#   * MsgFieldMap field_map;
+#   * createMapping<PointT> (msg.fields, field_map);
+#   * \endcode
+#   */
+# template <typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object.
+#   * \param[in] msg the PCLPointCloud2 binary blob
+#   * \param[out] cloud the resultant pcl::PointCloud<T>
+#   */
+# template<typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Convert a pcl::PointCloud<T> object to a PCLPointCloud2 binary data blob.
+#   * \param[in] cloud the input pcl::PointCloud<T>
+#   * \param[out] msg the resultant PCLPointCloud2 binary blob
+#   */
+# template<typename PointT> void toPCLPointCloud2 (const pcl::PointCloud<PointT>& cloud, pcl::PCLPointCloud2& msg)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+#  /** \brief Copy the RGB fields of a PointCloud into pcl::PCLImage format
+#    * \param[in] cloud the point cloud message
+#    * \param[out] msg the resultant pcl::PCLImage
+#    * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>
+#    * \note will throw std::runtime_error if there is a problem
+#    */
+# template<typename CloudT> void toPCLPointCloud2 (const CloudT& cloud, pcl::PCLImage& msg)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Copy the RGB fields of a PCLPointCloud2 msg into pcl::PCLImage format
+#   * \param cloud the point cloud message
+#   * \param msg the resultant pcl::PCLImage
+#   * will throw std::runtime_error if there is a problem
+#   */
+# inline void toPCLPointCloud2 (const pcl::PCLPointCloud2& cloud, pcl::PCLImage& msg)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Get the shortest 3D segment between two 3D lines
+#   * \param line_a the coefficients of the first line (point, direction)
+#   * \param line_b the coefficients of the second line (point, direction)
+#   * \param pt1_seg the first point on the line segment
+#   * \param pt2_seg the second point on the line segment
+#   * \ingroup common
+#   */
+# PCL_EXPORTS void lineToLineSegment (const Eigen::VectorXf &line_a, const Eigen::VectorXf &line_b, Eigen::Vector4f &pt1_seg, Eigen::Vector4f &pt2_seg);
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Get the square distance from a point to a line (represented by a point and a direction)
+#   * \param pt a point
+#   * \param line_pt a point on the line (make sure that line_pt[3] = 0 as there are no internal checks!)
+#   * \param line_dir the line direction
+#   * \ingroup common
+#   */
+# double inline sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Get the square distance from a point to a line (represented by a point and a direction)
+#   * \note This one is useful if one has to compute many distances to a fixed line, so the vector length can be pre-computed
+#   * \param pt a point
+#   * \param line_pt a point on the line (make sure that line_pt[3] = 0 as there are no internal checks!)
+#   * \param line_dir the line direction
+#   * \param sqr_length the squared norm of the line direction
+#   * \ingroup common
+#   */
+# double inline sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir, const double sqr_length)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Obtain the maximum segment in a given set of points, and return the minimum and maximum points.
+#   * \param[in] cloud the point cloud dataset
+#   * \param[out] pmin the coordinates of the "minimum" point in \a cloud (one end of the segment)
+#   * \param[out] pmax the coordinates of the "maximum" point in \a cloud (the other end of the segment)
+#   * \return the length of segment length
+#   * \ingroup common
+#   */
+# template <typename PointT> double inline getMaxSegment (const pcl::PointCloud<PointT> &cloud, PointT &pmin, PointT &pmax)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Obtain the maximum segment in a given set of points, and return the minimum and maximum points.
+#   * \param[in] cloud the point cloud dataset
+#   * \param[in] indices a set of point indices to use from \a cloud
+#   * \param[out] pmin the coordinates of the "minimum" point in \a cloud (one end of the segment)
+#   * \param[out] pmax the coordinates of the "maximum" point in \a cloud (the other end of the segment)
+#   * \return the length of segment length
+#   * \ingroup common
+#   */
+# template <typename PointT> double inline getMaxSegment (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, PointT &pmin, PointT &pmax)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Calculate the squared euclidean distance between the two given points.
+#   * \param[in] p1 the first point
+#   * \param[in] p2 the second point
+#   */
+# template<typename PointType1, typename PointType2> inline float
+# squaredEuclideanDistance (const PointType1& p1, const PointType2& p2)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Calculate the squared euclidean distance between the two given points.
+#   * \param[in] p1 the first point
+#   * \param[in] p2 the second point
+#   */
+# template<> inline float
+# squaredEuclideanDistance (const PointXY& p1, const PointXY& p2)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Calculate the euclidean distance between the two given points.
+#   * \param[in] p1 the first point
+#   * \param[in] p2 the second point
+#   */
+# template<typename PointType1, typename PointType2> inline float
+# euclideanDistance (const PointType1& p1, const PointType2& p2)
+###
+
+# eigen.h
+# #ifndef NOMINMAX
+# #define NOMINMAX
+# #endif
+# 
+# #if defined __GNUC__
+# #  pragma GCC system_header
+# #elif defined __SUNPRO_CC
+# #  pragma disable_warn
+# #endif
+# 
+# #include <cmath>
+# #include <pcl/ModelCoefficients.h>
+# 
+# #include <Eigen/StdVector>
+# #include <Eigen/Core>
+# #include <Eigen/Eigenvalues>
+# #include <Eigen/Geometry>
+# #include <Eigen/SVD>
+# #include <Eigen/LU>
+# #include <Eigen/Dense>
+# #include <Eigen/Eigenvalues>
+# 
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Compute the roots of a quadratic polynom x^2 + b*x + c = 0
+#   * \param[in] b linear parameter
+#   * \param[in] c constant parameter
+#   * \param[out] roots solutions of x^2 + b*x + c = 0
+#   */
+# template <typename Scalar, typename Roots> void computeRoots2 (const Scalar &b, const Scalar &c, Roots &roots);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief computes the roots of the characteristic polynomial of the input matrix m, which are the eigenvalues
+#   * \param[in] m input matrix
+#   * \param[out] roots roots of the characteristic polynomial of the input matrix m, which are the eigenvalues
+#   */
+# template <typename Matrix, typename Roots> void computeRoots (const Matrix &m, Roots &roots);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determine the smallest eigenvalue and its corresponding eigenvector
+#   * \param[in] mat input matrix that needs to be symmetric and positive semi definite
+#   * \param[out] eigenvalue the smallest eigenvalue of the input matrix
+#   * \param[out] eigenvector the corresponding eigenvector to the smallest eigenvalue of the input matrix
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void
+# eigen22 (const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determine the smallest eigenvalue and its corresponding eigenvector
+#   * \param[in] mat input matrix that needs to be symmetric and positive semi definite
+#   * \param[out] eigenvectors the corresponding eigenvector to the smallest eigenvalue of the input matrix
+#   * \param[out] eigenvalues the smallest eigenvalue of the input matrix
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen22 (const Matrix &mat, Matrix &eigenvectors, Vector &eigenvalues);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the corresponding eigenvector to the given eigenvalue of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[in] eigenvalue the eigenvalue which corresponding eigenvector is to be computed
+#   * \param[out] eigenvector the corresponding eigenvector for the input eigenvalue
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void computeCorrespondingEigenVector (const Matrix &mat, const typename Matrix::Scalar &eigenvalue, Vector &eigenvector);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the eigenvector and eigenvalue of the smallest eigenvalue of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[out] eigenvalue smallest eigenvalue of the input matrix
+#   * \param[out] eigenvector the corresponding eigenvector for the input eigenvalue
+#   * \note if the smallest eigenvalue is not unique, this function may return any eigenvector that is consistent to the eigenvalue.
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen33 (const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the eigenvalues of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[out] evals resulting eigenvalues in ascending order
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen33 (const Matrix &mat, Vector &evals);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the eigenvalues and corresponding eigenvectors of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[out] evecs resulting eigenvalues in ascending order
+#   * \param[out] evals corresponding eigenvectors in correct order according to eigenvalues
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen33 (const Matrix &mat, Matrix &evecs, Vector &evals);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the inverse of a 2x2 matrix
+#   * \param[in] matrix matrix to be inverted
+#   * \param[out] inverse the resultant inverted matrix
+#   * \note only the upper triangular part is taken into account => non symmetric matrices will give wrong results
+#   * \return determinant of the original matrix => if 0 no inverse exists => result is invalid
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar invert2x2 (const Matrix &matrix, Matrix &inverse);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the inverse of a 3x3 symmetric matrix.
+#   * \param[in] matrix matrix to be inverted
+#   * \param[out] inverse the resultant inverted matrix
+#   * \note only the upper triangular part is taken into account => non symmetric matrices will give wrong results
+#   * \return determinant of the original matrix => if 0 no inverse exists => result is invalid
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar invert3x3SymMatrix (const Matrix &matrix, Matrix &inverse);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the inverse of a general 3x3 matrix.
+#   * \param[in] matrix matrix to be inverted
+#   * \param[out] inverse the resultant inverted matrix
+#   * \return determinant of the original matrix => if 0 no inverse exists => result is invalid
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar
+# invert3x3Matrix (const Matrix &matrix, Matrix &inverse);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the determinant of a 3x3 matrix.
+#   * \param[in] matrix matrix
+#   * \return determinant of the matrix
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar determinant3x3Matrix (const Matrix &matrix);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] z_axis the z-axis
+#   * \param[in] y_direction the y direction
+#   * \param[out] transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline void getTransFromUnitVectorsZY (const Eigen::Vector3f& z_axis, const Eigen::Vector3f& y_direction, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] z_axis the z-axis
+#   * \param[in] y_direction the y direction
+#   * \return the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransFromUnitVectorsZY (const Eigen::Vector3f& z_axis, const Eigen::Vector3f& y_direction);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a x_axis into (1,0,0) and \a y_direction into a vector
+#   * with z=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] x_axis the x-axis
+#   * \param[in] y_direction the y direction
+#   * \param[out] transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline void getTransFromUnitVectorsXY (const Eigen::Vector3f& x_axis, const Eigen::Vector3f& y_direction, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a x_axis into (1,0,0) and \a y_direction into a vector
+#   * with z=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] x_axis the x-axis
+#   * \param[in] y_direction the y direction
+#   * \return the resulting 3D rotation
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransFromUnitVectorsXY (const Eigen::Vector3f& x_axis, const Eigen::Vector3f& y_direction);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] y_direction the y direction
+#   * \param[in] z_axis the z-axis
+#   * \param[out] transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline void getTransformationFromTwoUnitVectors (const Eigen::Vector3f& y_direction, const Eigen::Vector3f& z_axis, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] y_direction the y direction
+#   * \param[in] z_axis the z-axis
+#   * \return transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransformationFromTwoUnitVectors (const Eigen::Vector3f& y_direction, const Eigen::Vector3f& z_axis);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the transformation that will translate \a orign to (0,0,0) and rotate \a z_axis into (0,0,1)
+#   * and \a y_direction into a vector with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] y_direction the y direction
+#   * \param[in] z_axis the z-axis
+#   * \param[in] origin the origin
+#   * \param[in] transformation the resultant transformation matrix
+#   * \ingroup common
+#   */
+# inline void
+# getTransformationFromTwoUnitVectorsAndOrigin (const Eigen::Vector3f& y_direction, const Eigen::Vector3f& z_axis, const Eigen::Vector3f& origin, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Extract the Euler angles (XYZ-convention) from the given transformation
+#   * \param[in] t the input transformation matrix
+#   * \param[in] roll the resulting roll angle
+#   * \param[in] pitch the resulting pitch angle
+#   * \param[in] yaw the resulting yaw angle
+#   * \ingroup common
+#   */
+# template <typename Scalar> void
+# getEulerAngles (const Eigen::Transform<Scalar, 3, Eigen::Affine> &t, Scalar &roll, Scalar &pitch, Scalar &yaw);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void getEulerAngles (const Eigen::Affine3f &t, float &roll, float &pitch, float &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# getEulerAngles (const Eigen::Affine3d &t, double &roll, double &pitch, double &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** Extract x,y,z and the Euler angles (XYZ-convention) from the given transformation
+#   * \param[in] t the input transformation matrix
+#   * \param[out] x the resulting x translation
+#   * \param[out] y the resulting y translation
+#   * \param[out] z the resulting z translation
+#   * \param[out] roll the resulting roll angle
+#   * \param[out] pitch the resulting pitch angle
+#   * \param[out] yaw the resulting yaw angle
+#   * \ingroup common
+#   */
+# template <typename Scalar> void
+# getTranslationAndEulerAngles (const Eigen::Transform<Scalar, 3, Eigen::Affine> &t, Scalar &x, Scalar &y, Scalar &z, Scalar &roll, Scalar &pitch, Scalar &yaw);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# getTranslationAndEulerAngles (const Eigen::Affine3f &t, float &x, float &y, float &z, float &roll, float &pitch, float &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# getTranslationAndEulerAngles (const Eigen::Affine3d &t, double &x, double &y, double &z, double &roll, double &pitch, double &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Create a transformation from the given translation and Euler angles (XYZ-convention)
+#   * \param[in] x the input x translation
+#   * \param[in] y the input y translation
+#   * \param[in] z the input z translation
+#   * \param[in] roll the input roll angle
+#   * \param[in] pitch the input pitch angle
+#   * \param[in] yaw the input yaw angle
+#   * \param[out] t the resulting transformation matrix
+#   * \ingroup common
+#   */
+# template <typename Scalar> void getTransformation (Scalar x, Scalar y, Scalar z, Scalar roll, Scalar pitch, Scalar yaw,  Eigen::Transform<Scalar, 3, Eigen::Affine> &t);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void getTransformation (float x, float y, float z, float roll, float pitch, float yaw, Eigen::Affine3f &t)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void getTransformation (double x, double y, double z, double roll, double pitch, double yaw, Eigen::Affine3d &t)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Create a transformation from the given translation and Euler angles (XYZ-convention)
+#   * \param[in] x the input x translation
+#   * \param[in] y the input y translation
+#   * \param[in] z the input z translation
+#   * \param[in] roll the input roll angle
+#   * \param[in] pitch the input pitch angle
+#   * \param[in] yaw the input yaw angle
+#   * \return the resulting transformation matrix
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransformation (float x, float y, float z, float roll, float pitch, float yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Write a matrix to an output stream
+#   * \param[in] matrix the matrix to output
+#   * \param[out] file the output stream
+#   * \ingroup common
+#   */
+# template <typename Derived> void saveBinary (const Eigen::MatrixBase<Derived>& matrix, std::ostream& file);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Read a matrix from an input stream
+#   * \param[out] matrix the resulting matrix, read from the input stream
+#   * \param[in,out] file the input stream
+#   * \ingroup common
+#   */
+# template <typename Derived> void
+# loadBinary (Eigen::MatrixBase<Derived> const& matrix, std::istream& file);
+###
+
+# // PCL_EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1,
+# // followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over
+# // finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3.
+# #define PCL_EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) ((int (a) == 0 || int (b) == 0) ? 0 \
+#                            : (int (a) == 1 || int (b) == 1) ? 1 \
+#                            : (int (a) == Eigen::Dynamic || int (b) == Eigen::Dynamic) ? Eigen::Dynamic \
+#                            : (int (a) <= int (b)) ? int (a) : int (b))
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Returns the transformation between two point sets. 
+#   * The algorithm is based on: 
+#   * "Least-squares estimation of transformation parameters between two point patterns",
+#   * Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
+#   *
+#   * It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
+#   * \f{align*}
+#   *   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
+#   * \f}
+#   * is minimized.
+#   *
+#   * The algorithm is based on the analysis of the covariance matrix
+#   * \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
+#   * of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where
+#   * \f$d\f$ is corresponding to the dimension (which is typically small).
+#   * The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
+#   * though the actual computational effort lies in the covariance
+#   * matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when
+#   * the input point sets have dimension \f$d \times m\f$.
+#   *
+#   * \param[in] src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$
+#   * \param[in] dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
+#   * \param[in] with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed. (default: false)
+#   * \return The homogeneous transformation 
+#   * \f{align*}
+#   *   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
+#   * \f}
+#   * minimizing the resudiual above. This transformation is always returned as an
+#   * Eigen::Matrix.
+#   */
+# template <typename Derived, typename OtherDerived> 
+# typename Eigen::internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type
+# umeyama (const Eigen::MatrixBase<Derived>& src, const Eigen::MatrixBase<OtherDerived>& dst, bool with_scaling = false);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform a point using an affine matrix
+#   * \param[in] point_in the vector to be transformed
+#   * \param[out] point_out the transformed vector
+#   * \param[in] transformation the transformation matrix
+#   *
+#   * \note Can be used with \c point_in = \c point_out
+#   */
+# template<typename Scalar> inline void transformPoint (const Eigen::Matrix<Scalar, 3, 1> &point_in, Eigen::Matrix<Scalar, 3, 1> &point_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void transformPoint (const Eigen::Vector3f &point_in, Eigen::Vector3f &point_out, const Eigen::Affine3f &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPoint (const Eigen::Vector3d &point_in, Eigen::Vector3d &point_out, const Eigen::Affine3d &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform a vector using an affine matrix
+#   * \param[in] vector_in the vector to be transformed
+#   * \param[out] vector_out the transformed vector
+#   * \param[in] transformation the transformation matrix
+#   * \note Can be used with \c vector_in = \c vector_out
+#   */
+# template <typename Scalar> inline void
+# transformVector (const Eigen::Matrix<Scalar, 3, 1> &vector_in, Eigen::Matrix<Scalar, 3, 1> &vector_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformVector (const Eigen::Vector3f &vector_in, Eigen::Vector3f &vector_out, const Eigen::Affine3f &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformVector (const Eigen::Vector3d &vector_in, Eigen::Vector3d &vector_out, const Eigen::Affine3d &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform a line using an affine matrix
+#   * \param[in] line_in the line to be transformed
+#   * \param[out] line_out the transformed line
+#   * \param[in] transformation the transformation matrix
+#   * Lines must be filled in this form:\n
+#   * line[0-2] = Origin coordinates of the vector\n
+#   * line[3-5] = Direction vector
+#   * \note Can be used with \c line_in = \c line_out
+#   */
+# template <typename Scalar> bool
+# transformLine (const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_in, Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformLine (const Eigen::VectorXf &line_in, Eigen::VectorXf &line_out, const Eigen::Affine3f &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformLine (const Eigen::VectorXd &line_in, Eigen::VectorXd &line_out, const Eigen::Affine3d &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform plane vectors using an affine matrix
+#   * \param[in] plane_in the plane coefficients to be transformed
+#   * \param[out] plane_out the transformed plane coefficients to fill
+#   * \param[in] transformation the transformation matrix
+#   * The plane vectors are filled in the form ax+by+cz+d=0
+#   * Can be used with non Hessian form planes coefficients
+#   * Can be used with \c plane_in = \c plane_out
+#   */
+# template <typename Scalar> void
+# transformPlane (const Eigen::Matrix<Scalar, 4, 1> &plane_in, Eigen::Matrix<Scalar, 4, 1> &plane_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPlane (const Eigen::Matrix<double, 4, 1> &plane_in, Eigen::Matrix<double, 4, 1> &plane_out, const Eigen::Transform<double, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPlane (const Eigen::Matrix<float, 4, 1> &plane_in, Eigen::Matrix<float, 4, 1> &plane_out,const Eigen::Transform<float, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform plane vectors using an affine matrix
+#   * \param[in] plane_in the plane coefficients to be transformed
+#   * \param[out] plane_out the transformed plane coefficients to fill
+#   * \param[in] transformation the transformation matrix
+#   * The plane vectors are filled in the form ax+by+cz+d=0
+#   * Can be used with non Hessian form planes coefficients
+#   * Can be used with \c plane_in = \c plane_out
+#   * \warning ModelCoefficients stores floats only !
+#   */
+# template<typename Scalar> void
+# transformPlane (const pcl::ModelCoefficients::Ptr plane_in, pcl::ModelCoefficients::Ptr plane_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPlane (const pcl::ModelCoefficients::Ptr plane_in, pcl::ModelCoefficients::Ptr plane_out, const Eigen::Transform<double, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void transformPlane (const pcl::ModelCoefficients::Ptr plane_in, pcl::ModelCoefficients::Ptr plane_out, const Eigen::Transform<float, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Check coordinate system integrity
+#   * \param[in] line_x the first axis
+#   * \param[in] line_y the second axis
+#   * \param[in] norm_limit the limit to ignore norm rounding errors
+#   * \param[in] dot_limit the limit to ignore dot product rounding errors
+#   * \return True if the coordinate system is consistent, false otherwise.
+#   * Lines must be filled in this form:\n
+#   * line[0-2] = Origin coordinates of the vector\n
+#   * line[3-5] = Direction vector
+#   * Can be used like this :\n
+#   * line_x = X axis and line_y = Y axis\n
+#   * line_x = Z axis and line_y = X axis\n
+#   * line_x = Y axis and line_y = Z axis\n
+#   * Because X^Y = Z, Z^X = Y and Y^Z = X.
+#   * Do NOT invert line order !
+#   * Determine whether a coordinate system is consistent or not by checking :\n
+#   * Line origins: They must be the same for the 2 lines\n
+#   * Norm: The 2 lines must be normalized\n
+#   * Dot products: Must be 0 or perpendicular vectors
+#   */
+# template<typename Scalar> bool
+# checkCoordinateSystem (const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_x,
+#                        const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_y,
+#                        const Scalar norm_limit = 1e-3,
+#                        const Scalar dot_limit = 1e-3);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<double, Eigen::Dynamic, 1> &line_x,
+#                        const Eigen::Matrix<double, Eigen::Dynamic, 1> &line_y,
+#                        const double norm_limit = 1e-3,
+#                        const double dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<float, Eigen::Dynamic, 1> &line_x,
+#                        const Eigen::Matrix<float, Eigen::Dynamic, 1> &line_y,
+#                        const float norm_limit = 1e-3,
+#                        const float dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Check coordinate system integrity
+#   * \param[in] origin the origin of the coordinate system
+#   * \param[in] x_direction the first axis
+#   * \param[in] y_direction the second axis
+#   * \param[in] norm_limit the limit to ignore norm rounding errors
+#   * \param[in] dot_limit the limit to ignore dot product rounding errors
+#   * \return True if the coordinate system is consistent, false otherwise.
+#   * Read the other variant for more information
+#   */
+# template <typename Scalar> inline bool
+# checkCoordinateSystem (const Eigen::Matrix<Scalar, 3, 1> &origin,
+#                        const Eigen::Matrix<Scalar, 3, 1> &x_direction,
+#                        const Eigen::Matrix<Scalar, 3, 1> &y_direction,
+#                        const Scalar norm_limit = 1e-3,
+#                        const Scalar dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<double, 3, 1> &origin,
+#                        const Eigen::Matrix<double, 3, 1> &x_direction,
+#                        const Eigen::Matrix<double, 3, 1> &y_direction,
+#                        const double norm_limit = 1e-3,
+#                        const double dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<float, 3, 1> &origin,
+#                        const Eigen::Matrix<float, 3, 1> &x_direction,
+#                        const Eigen::Matrix<float, 3, 1> &y_direction,
+#                        const float norm_limit = 1e-3,
+#                        const float dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Compute the transformation between two coordinate systems
+#   * \param[in] from_line_x X axis from the origin coordinate system
+#   * \param[in] from_line_y Y axis from the origin coordinate system
+#   * \param[in] to_line_x X axis from the destination coordinate system
+#   * \param[in] to_line_y Y axis from the destination coordinate system
+#   * \param[out] transformation the transformation matrix to fill
+#   * \return true if transformation was filled, false otherwise.
+#   * Line must be filled in this form:\n
+#   * line[0-2] = Coordinate system origin coordinates \n
+#   * line[3-5] = Direction vector (norm doesn't matter)
+#   */
+# template <typename Scalar> bool
+# transformBetween2CoordinateSystems (const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> from_line_x,
+#                                     const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> from_line_y,
+#                                     const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> to_line_x,
+#                                     const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> to_line_y,
+#                                     Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformBetween2CoordinateSystems (const Eigen::Matrix<double, Eigen::Dynamic, 1> from_line_x,
+#                                     const Eigen::Matrix<double, Eigen::Dynamic, 1> from_line_y,
+#                                     const Eigen::Matrix<double, Eigen::Dynamic, 1> to_line_x,
+#                                     const Eigen::Matrix<double, Eigen::Dynamic, 1> to_line_y,
+#                                     Eigen::Transform<double, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformBetween2CoordinateSystems (const Eigen::Matrix<float, Eigen::Dynamic, 1> from_line_x,
+#                                     const Eigen::Matrix<float, Eigen::Dynamic, 1> from_line_y,
+#                                     const Eigen::Matrix<float, Eigen::Dynamic, 1> to_line_x,
+#                                     const Eigen::Matrix<float, Eigen::Dynamic, 1> to_line_y,
+#                                     Eigen::Transform<float, 3, Eigen::Affine> &transformation)
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Find all *.pcd files in the directory and return them sorted
+#   * \param directory the directory to be searched
+#   * \param file_names the resulting (sorted) list of .pcd files
+#   */
+# inline void getAllPcdFilesInDirectory (const std::string& directory, std::vector<std::string>& file_names);
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Remove the path from the given string and return only the filename (the remaining string after the 
+#   * last '/')
+#   * \param input the input filename (with full path)
+#   * \return the resulting filename, stripped of the path
+#   */
+# inline std::string  getFilenameWithoutPath (const std::string& input);
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Remove the extension from the given string and return only the filename (everything before the last '.')
+#   * \param input the input filename (with the file extension)
+#   * \return the resulting filename, stripped of its extension
+#   */
+# inline std::string getFilenameWithoutExtension (const std::string& input);
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Get the file extension from the given string (the remaining string after the last '.')
+#   * \param input the input filename
+#   * \return \a input 's file extension
+#   */
+# inline std::string getFileExtension (const std::string& input)
+###
+
+# gaussian.h
+# namespace pcl
+# cdef extern from "pcl/common/gaussian.h" namespace "pcl":
+# /** Class GaussianKernel assembles all the method for computing, 
+#   * convolving, smoothing, gradients computing an image using
+#   * a gaussian kernel. The image is stored in point cloud elements 
+#   * intensity member or rgb or...
+#   * \author Nizar Sallem
+#   * \ingroup common
+#   */
+# class PCL_EXPORTS GaussianKernel
+# 		public:
+#       GaussianKernel () {}
+# 
+#       static const unsigned MAX_KERNEL_WIDTH = 71;
+#       /** Computes the gaussian kernel and dervative assiociated to sigma.
+#         * The kernel and derivative width are adjusted according.
+#         * \param[in] sigma
+#         * \param[out] kernel the computed gaussian kernel
+#         * \param[in] kernel_width the desired kernel width upper bond
+#         * \throws pcl::KernelWidthTooSmallException
+#         */
+#       void compute (float sigma, 
+#                Eigen::VectorXf &kernel,
+#                unsigned kernel_width = MAX_KERNEL_WIDTH) const;
+# 
+#       /** Computes the gaussian kernel and dervative assiociated to sigma.
+#         * The kernel and derivative width are adjusted according.
+#         * \param[in] sigma
+#         * \param[out] kernel the computed gaussian kernel
+#         * \param[out] derivative the computed kernel derivative
+#         * \param[in] kernel_width the desired kernel width upper bond
+#         * \throws pcl::KernelWidthTooSmallException
+#         */
+#       void compute (float sigma, 
+#                Eigen::VectorXf &kernel, Eigen::VectorXf &derivative, 
+#                unsigned kernel_width = MAX_KERNEL_WIDTH) const;
+# 
+#       /** Convolve a float image rows by a given kernel.
+#         * \param[in] kernel convolution kernel
+#         * \param[in] input the image to convolve
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       void convolveRows (const pcl::PointCloud<float> &input, const Eigen::VectorXf &kernel, pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image rows by a given kernel.
+#         * \param[in] input the image to convolve
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] kernel convolution kernel
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#      template <typename PointT> void
+#      convolveRows (const pcl::PointCloud<PointT> &input,
+#                    boost::function <float (const PointT& p)> field_accessor, const Eigen::VectorXf &kernel,
+#                    pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image columns by a given kernel.
+#         * \param[in] input the image to convolve
+#         * \param[in] kernel convolution kernel
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       void convolveCols (const pcl::PointCloud<float> &input, const Eigen::VectorXf &kernel, pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image columns by a given kernel.
+#         * \param[in] input the image to convolve
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] kernel convolution kernel
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> void
+#       convolveCols (const pcl::PointCloud<PointT> &input,
+#                     boost::function <float (const PointT& p)> field_accessor, const Eigen::VectorXf &kernel, pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image in the 2 directions
+#         * \param[in] horiz_kernel kernel for convolving rows
+#         * \param[in] vert_kernel kernel for convolving columns
+#         * \param[in] input image to convolve
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       inline void
+#       convolve (const pcl::PointCloud<float> &input,
+#                 const Eigen::VectorXf &horiz_kernel, const Eigen::VectorXf &vert_kernel, pcl::PointCloud<float> &output) const
+# 
+#       /** Convolve a float image in the 2 directions
+#         * \param[in] input image to convolve
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] horiz_kernel kernel for convolving rows
+#         * \param[in] vert_kernel kernel for convolving columns
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> inline void
+#       convolve (const pcl::PointCloud<PointT> &input,
+#                 boost::function <float (const PointT& p)> field_accessor,
+#                 const Eigen::VectorXf &horiz_kernel, const Eigen::VectorXf &vert_kernel, pcl::PointCloud<float> &output) const
+#       
+#       /** Computes float image gradients using a gaussian kernel and gaussian kernel
+#         * derivative.
+#         * \param[in] input image to compute gardients for
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[in] gaussian_kernel_derivative the associated derivative
+#         * \param[out] grad_x gradient along X direction
+#         * \param[out] grad_y gradient along Y direction
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       inline void
+#       computeGradients (const pcl::PointCloud<float> &input,
+#                         const Eigen::VectorXf &gaussian_kernel, const Eigen::VectorXf &gaussian_kernel_derivative,
+#                         pcl::PointCloud<float> &grad_x, pcl::PointCloud<float> &grad_y) const
+# 
+#       /** Computes float image gradients using a gaussian kernel and gaussian kernel
+#         * derivative.
+#         * \param[in] input image to compute gardients for
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[in] gaussian_kernel_derivative the associated derivative
+#         * \param[out] grad_x gradient along X direction
+#         * \param[out] grad_y gradient along Y direction
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> inline void
+#       computeGradients (const pcl::PointCloud<PointT> &input, boost::function <float (const PointT& p)> field_accessor,
+#                         const Eigen::VectorXf &gaussian_kernel, const Eigen::VectorXf &gaussian_kernel_derivative,
+#                         pcl::PointCloud<float> &grad_x, pcl::PointCloud<float> &grad_y) const
+#       
+#       /** Smooth image using a gaussian kernel.
+#         * \param[in] input image
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[out] output the smoothed image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       inline void smooth (const pcl::PointCloud<float> &input,
+#               const Eigen::VectorXf &gaussian_kernel, pcl::PointCloud<float> &output) const
+# 
+#       /** Smooth image using a gaussian kernel.
+#         * \param[in] input image
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[out] output the smoothed image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> inline void
+#       smooth (const pcl::PointCloud<PointT> &input, boost::function <float (const PointT& p)> field_accessor,
+#               const Eigen::VectorXf &gaussian_kernel, pcl::PointCloud<float> &output) const
+#   };
+# }
+# 
+###
+
+# generate.h
+# namespace pcl
+# namespace common
+# cdef extern from "pcl/common/generate.h" namespace "pcl::common":
+# /** \brief CloudGenerator class generates a point cloud using some randoom number generator.
+#   * Generators can be found in \file common/random.h and easily extensible.
+#   * \ingroup common
+#   * \author Nizar Sallem
+#   */
+# template <typename PointT, typename GeneratorT>
+# class CloudGenerator
+# {
+#     public:
+#     typedef typename GeneratorT::Parameters GeneratorParameters;
+# 
+#     /// Default constructor
+#     CloudGenerator ();
+# 
+#     /** Consttructor with single generator to ensure all X, Y and Z values are within same range
+#       * \param params paramteres for X, Y and Z values generation. Uniqueness is ensured through
+#       * seed incrementation
+#       */
+#     CloudGenerator (const GeneratorParameters& params);
+# 
+#     /** Constructor with independant generators per axis
+#       * \param x_params parameters for x values generation
+#       * \param y_params parameters for y values generation
+#       * \param z_params parameters for z values generation
+#       */
+#     CloudGenerator (const GeneratorParameters& x_params,
+#                     const GeneratorParameters& y_params,
+#                     const GeneratorParameters& z_params);
+# 
+#     /** Set parameters for x, y and z values. Uniqueness is ensured through seed incrementation.
+#       * \param params parameteres for X, Y and Z values generation. 
+#       */
+#     void setParameters (const GeneratorParameters& params);
+# 
+#     /** Set parameters for x values generation
+#       * \param x_params paramters for x values generation
+#       */
+#     void setParametersForX (const GeneratorParameters& x_params);
+# 
+#     /** Set parameters for y values generation
+#       * \param y_params paramters for y values generation
+#       */
+#     void setParametersForY (const GeneratorParameters& y_params);
+# 
+#     /** Set parameters for z values generation
+#       * \param z_params paramters for z values generation
+#       */
+#     void setParametersForZ (const GeneratorParameters& z_params);
+# 
+#     /// \return x values generation parameters
+#     const GeneratorParameters& getParametersForX () const;
+# 
+#     /// \return y values generation parameters
+#     const GeneratorParameters& getParametersForY () const;
+# 
+#     /// \return z values generation parameters
+#     const GeneratorParameters& getParametersForZ () const;
+# 
+#     /// \return a single random generated point 
+#     PointT get ();
+# 
+#     /** Generates a cloud with X Y Z picked within given ranges. This function assumes that
+#       * cloud is properly defined else it raises errors and does nothing.
+#       * \param[out] cloud cloud to generate coordinates for
+#       * \return 0 if generation went well else -1.
+#       */
+#     int fill (pcl::PointCloud<PointT>& cloud);
+# 
+#     /** Generates a cloud of specified dimensions with X Y Z picked within given ranges. 
+#       * \param[in] width width of generated cloud
+#       * \param[in] height height of generated cloud
+#       * \param[out] cloud output cloud
+#       * \return 0 if generation went well else -1.
+#       */
+#     int fill (int width, int height, pcl::PointCloud<PointT>& cloud);
+#   };
+# 
+#     template <typename GeneratorT>
+#     class CloudGenerator<pcl::PointXY, GeneratorT>
+#     {
+#       public:
+#       typedef typename GeneratorT::Parameters GeneratorParameters;
+#       
+#       CloudGenerator ();
+#       
+#       CloudGenerator (const GeneratorParameters& params);
+# 
+#       CloudGenerator (const GeneratorParameters& x_params, const GeneratorParameters& y_params);
+#       
+#       void setParameters (const GeneratorParameters& params);
+# 
+#       void setParametersForX (const GeneratorParameters& x_params);
+# 
+#       void setParametersForY (const GeneratorParameters& y_params);
+# 
+#       const GeneratorParameters& getParametersForX () const;
+# 
+#       const GeneratorParameters& getParametersForY () const;
+# 
+#       pcl::PointXYget ();
+# 
+#       int fill (pcl::PointCloud<pcl::PointXY>& cloud);
+# 
+#       int fill (int width, int height, pcl::PointCloud<pcl::PointXY>& cloud);
+#       
+#     };
+#   }
+# }
+###
+
+# geometry.h
+# namespace pcl
+# namespace geometry
+#     /** @return the euclidean distance between 2 points */
+#     template <typename PointT> inline float distance (const PointT& p1, const PointT& p2)
+# 
+#     /** @return the squared euclidean distance between 2 points */
+#     template<typename PointT> inline float squaredDistance (const PointT& p1, const PointT& p2)
+# 
+#     /** @return the point projection on a plane defined by its origin and normal vector 
+#       * \param[in] point Point to be projected
+#       * \param[in] plane_origin The plane origin
+#       * \param[in] plane_normal The plane normal 
+#       * \param[out] projected The returned projected point
+#       */
+#     template<typename PointT, typename NormalT> inline void 
+#     project (const PointT& point, const PointT &plane_origin, const NormalT& plane_normal, PointT& projected)
+# 
+#     /** @return the point projection on a plane defined by its origin and normal vector 
+#       * \param[in] point Point to be projected
+#       * \param[in] plane_origin The plane origin
+#       * \param[in] plane_normal The plane normal 
+#       * \param[out] projected The returned projected point
+#       */
+#     inline void project (const Eigen::Vector3f& point, const Eigen::Vector3f &plane_origin, const Eigen::Vector3f& plane_normal, Eigen::Vector3f& projected)
+
+
+###
+
+# intensity.h
+# namespace pcl
+# namespace common
+#     /** \brief Intensity field accessor provides access to the inetnsity filed of a PoinT
+#       * implementation for specific types should be done in \file pcl/common/impl/intensity.hpp
+#       */
+#     template<typename PointT> struct IntensityFieldAccessor
+#     {
+#       /** \brief get intensity field
+#         * \param[in] p point
+#         * \return p.intensity
+#         */
+#       inline float operator () (const PointT &p) const
+# 
+#       /** \brief gets the intensity value of a point
+#         * \param p point for which intensity to be get
+#         * \param[in] intensity value of the intensity field
+#         */
+#       inline void get (const PointT &p, float &intensity) const
+#
+#       /** \brief sets the intensity value of a point
+#         * \param p point for which intensity to be set
+#         * \param[in] intensity value of the intensity field
+#         */
+#       inline void set (PointT &p, float intensity) const
+# 
+#       /** \brief subtract value from intensity field
+#         * \param p point for which to modify inetnsity
+#         * \param[in] value value to be subtracted from point intensity
+#         */
+#       inline void demean (PointT& p, float value) const
+# 
+#       /** \brief add value to intensity field
+#         * \param p point for which to modify inetnsity
+#         * \param[in] value value to be added to point intensity
+#         */
+#       inline void add (PointT& p, float value) const
+#     };
+#   }
+# }
+###
+
+# intersections.h
+# namespace pcl
+# {
+#   /** \brief Get the intersection of a two 3D lines in space as a 3D point
+#     * \param[in] line_a the coefficients of the first line (point, direction)
+#     * \param[in] line_b the coefficients of the second line (point, direction)
+#     * \param[out] point holder for the computed 3D point
+#     * \param[in] sqr_eps maximum allowable squared distance to the true solution
+#     * \ingroup common
+#     */
+#   PCL_EXPORTS inline bool lineWithLineIntersection (
+# 								const Eigen::VectorXf &line_a, 
+#                             	const Eigen::VectorXf &line_b, 
+#                             	Eigen::Vector4f &point,
+#                             	double sqr_eps = 1e-4);
+# 
+#   /** \brief Get the intersection of a two 3D lines in space as a 3D point
+#     * \param[in] line_a the coefficients of the first line (point, direction)
+#     * \param[in] line_b the coefficients of the second line (point, direction)
+#     * \param[out] point holder for the computed 3D point
+#     * \param[in] sqr_eps maximum allowable squared distance to the true solution
+#     * \ingroup common
+#     */
+# 
+#   PCL_EXPORTS inline bool
+#   lineWithLineIntersection (const pcl::ModelCoefficients &line_a, 
+#                             const pcl::ModelCoefficients &line_b, 
+#                             Eigen::Vector4f &point,
+#                             double sqr_eps = 1e-4);
+# 
+#   /** \brief Determine the line of intersection of two non-parallel planes using lagrange multipliers
+#     * \note Described in: "Intersection of Two Planes, John Krumm, Microsoft Research, Redmond, WA, USA"
+#     * \param[in] plane_a coefficients of plane A and plane B in the form ax + by + cz + d = 0
+#     * \param[in] plane_b coefficients of line where line.tail<3>() = direction vector and
+#     * line.head<3>() the point on the line clossest to (0, 0, 0)
+#     * \param[out] line the intersected line to be filled
+#     * \param[in] angular_tolerance tolerance in radians
+#     * \return true if succeeded/planes aren't parallel
+#     */
+#   PCL_EXPORTS template <typename Scalar> bool
+#   planeWithPlaneIntersection (const Eigen::Matrix<Scalar, 4, 1> &plane_a,
+#                               const Eigen::Matrix<Scalar, 4, 1> &plane_b,
+#                               Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line,
+#                               double angular_tolerance = 0.1);
+# 
+#   PCL_EXPORTS inline bool
+#   planeWithPlaneIntersection (const Eigen::Vector4f &plane_a,
+#                               const Eigen::Vector4f &plane_b,
+#                               Eigen::VectorXf &line,
+#                               double angular_tolerance = 0.1)
+#   {
+#     return (planeWithPlaneIntersection<float> (plane_a, plane_b, line, angular_tolerance));
+#   }
+# 
+#   PCL_EXPORTS inline bool
+#   planeWithPlaneIntersection (const Eigen::Vector4d &plane_a,
+#                               const Eigen::Vector4d &plane_b,
+#                               Eigen::VectorXd &line,
+#                               double angular_tolerance = 0.1)
+#   {
+#     return (planeWithPlaneIntersection<double> (plane_a, plane_b, line, angular_tolerance));
+#   }
+# 
+#   /** \brief Determine the point of intersection of three non-parallel planes by solving the equations.
+#     * \note If using nearly parralel planes you can lower the determinant_tolerance value. This can
+#     * lead to inconsistent results.
+#     * If the three planes intersects in a line the point will be anywhere on the line.
+#     * \param[in] plane_a are the coefficients of the first plane in the form ax + by + cz + d = 0
+#     * \param[in] plane_b are the coefficients of the second plane
+#     * \param[in] plane_c are the coefficients of the third plane
+#     * \param[in] determinant_tolerance is a limit to determine whether planes are parallel or not
+#     * \param[out] intersection_point the three coordinates x, y, z of the intersection point
+#     * \return true if succeeded/planes aren't parallel
+#     */
+#   PCL_EXPORTS template <typename Scalar> bool
+#   threePlanesIntersection (const Eigen::Matrix<Scalar, 4, 1> &plane_a,
+#                            const Eigen::Matrix<Scalar, 4, 1> &plane_b,
+#                            const Eigen::Matrix<Scalar, 4, 1> &plane_c,
+#                            Eigen::Matrix<Scalar, 3, 1> &intersection_point,
+#                            double determinant_tolerance = 1e-6);
+# 
+# 
+#   PCL_EXPORTS inline bool
+#   threePlanesIntersection (const Eigen::Vector4f &plane_a,
+#                            const Eigen::Vector4f &plane_b,
+#                            const Eigen::Vector4f &plane_c,
+#                            Eigen::Vector3f &intersection_point,
+#                            double determinant_tolerance = 1e-6)
+#   {
+#     return (threePlanesIntersection<float> (plane_a, plane_b, plane_c,
+#                                             intersection_point, determinant_tolerance));
+#   }
+# 
+#   PCL_EXPORTS inline bool
+#   threePlanesIntersection (const Eigen::Vector4d &plane_a,
+#                            const Eigen::Vector4d &plane_b,
+#                            const Eigen::Vector4d &plane_c,
+#                            Eigen::Vector3d &intersection_point,
+#                            double determinant_tolerance = 1e-6)
+#   {
+#     return (threePlanesIntersection<double> (plane_a, plane_b, plane_c, intersection_point, determinant_tolerance));
+#   }
+# 
+# }
+###
+
+# io.h
+# namespace pcl
+# /** \brief Get the index of a specified field (i.e., dimension/channel)
+#   * \param[in] cloud the the point cloud message
+#   * \param[in] field_name the string defining the field name
+#   * \ingroup common
+#   */
+# inline int getFieldIndex (const pcl::PCLPointCloud2 &cloud, const std::string &field_name)
+# 
+# /** \brief Get the index of a specified field (i.e., dimension/channel)
+#   * \param[in] cloud the the point cloud message
+#   * \param[in] field_name the string defining the field name
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline int getFieldIndex (const pcl::PointCloud<PointT> &cloud, const std::string &field_name, std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the index of a specified field (i.e., dimension/channel)
+#   * \param[in] field_name the string defining the field name
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline int getFieldIndex (const std::string &field_name, std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the list of available fields (i.e., dimension/channel)
+#   * \param[in] cloud the point cloud message
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void getFields (const pcl::PointCloud<PointT> &cloud, std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the list of available fields (i.e., dimension/channel)
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void getFields (std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the list of all fields available in a given cloud
+#   * \param[in] cloud the the point cloud message
+#   * \ingroup common
+#   */
+# template <typename PointT> inline std::string  getFieldsList (const pcl::PointCloud<PointT> &cloud);
+# 
+# /** \brief Get the available point cloud fields as a space separated string
+#   * \param[in] cloud a pointer to the PointCloud message
+#   * \ingroup common
+#   */
+# inline std::string getFieldsList (const pcl::PCLPointCloud2 &cloud)
+# 
+# /** \brief Obtains the size of a specific field data type in bytes
+#   * \param[in] datatype the field data type (see PCLPointField.h)
+#   * \ingroup common
+#   */
+# inline int getFieldSize (const int datatype)
+# 
+# /** \brief Obtain a vector with the sizes of all valid fields (e.g., not "_")
+#   * \param[in] fields the input vector containing the fields
+#   * \param[out] field_sizes the resultant field sizes in bytes
+#   */
+# PCL_EXPORTS void getFieldsSizes (const std::vector<pcl::PCLPointField> &fields,std::vector<int> &field_sizes);
+# 
+# /** \brief Obtains the type of the PCLPointField from a specific size and type
+#   * \param[in] size the size in bytes of the data field
+#   * \param[in] type a char describing the type of the field  ('F' = float, 'I' = signed, 'U' = unsigned)
+#   * \ingroup common
+#   */
+# inline int getFieldType (const int size, char type)
+# 
+# /** \brief Obtains the type of the PCLPointField from a specific PCLPointField as a char
+#   * \param[in] type the PCLPointField field type
+#   * \ingroup common
+#   */
+# inline char getFieldType (const int type)
+# {
+#   switch (type)
+#   {
+#     case pcl::PCLPointField::INT8:
+#     case pcl::PCLPointField::INT16:
+#     case pcl::PCLPointField::INT32:
+#       return ('I');
+# 
+#     case pcl::PCLPointField::UINT8:
+#     case pcl::PCLPointField::UINT16:
+#     case pcl::PCLPointField::UINT32:
+#       return ('U');
+# 
+#     case pcl::PCLPointField::FLOAT32:
+#     case pcl::PCLPointField::FLOAT64:
+#       return ('F');
+#     default:
+#       return ('?');
+#   }
+# }
+# 
+# typedef enum
+# {
+#   BORDER_CONSTANT = 0, BORDER_REPLICATE = 1,
+#   BORDER_REFLECT = 2, BORDER_WRAP = 3,
+#   BORDER_REFLECT_101 = 4, BORDER_TRANSPARENT = 5,
+#   BORDER_DEFAULT = BORDER_REFLECT_101
+# } InterpolationType;
+###
+
+# /** \brief \return the right index according to the interpolation type.
+#   * \note this is adapted from OpenCV
+#   * \param p the index of point to interpolate
+#   * \param length the top/bottom row or left/right column index
+#   * \param type the requested interpolation
+#   * \throws pcl::BadArgumentException if type is unknown
+#   */
+# PCL_EXPORTS int interpolatePointIndex (int p, int length, InterpolationType type);
+###
+
+# /** \brief Concatenate two pcl::PCLPointCloud2.
+#   * \param[in] cloud1 the first input point cloud dataset
+#   * \param[in] cloud2 the second input point cloud dataset
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \return true if successful, false if failed (e.g., name/number of fields differs)
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool concatenatePointCloud (const pcl::PCLPointCloud2 &cloud1, const pcl::PCLPointCloud2 &cloud2, pcl::PCLPointCloud2 &cloud_out);
+###
+
+# pcl1.6.0 NG
+# pcl1.7.2
+# copy_point.h
+# namespace pcl
+# \brief Copy the fields of a source point into a target point.
+#  If the source and the target point types are the same, then a complete
+#  copy is made. Otherwise only those fields that the two point types share
+#  in common are copied.
+# \param[in]  point_in the source point
+# \param[out] point_out the target point
+# \ingroup common
+# template <typename PointInT, typename PointOutT> void copyPoint (const PointInT& point_in, PointOutT& point_out);
+# PCL 1.7.2
+# cdef extern from "pcl/common/copy_point.h" namespace "pcl":
+# PCL 1.6.0
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    void copyPointCloud [PointInT, PointOutT](const PointInT &cloud_in, const PointOutT &cloud_out)
+
+# void copyPointCloud [shared_ptr[cpp.PointCloud[cpp.PointXYZ]], shared_ptr[cpp.PointCloud[cpp.PointXYZ]] (hogehoge)
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# PCL_EXPORTS void copyPointCloud (const pcl::PCLPointCloud2 &cloud_in, const std::vector<int> &indices, pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# PCL_EXPORTS void copyPointCloud (const pcl::PCLPointCloud2 &cloud_in, const std::vector<int, Eigen::aligned_allocator<int> > &indices,  pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Copy fields and point cloud data from \a cloud_in to \a cloud_out
+# \param[in] cloud_in the input point cloud dataset
+# \param[out] cloud_out the resultant output point cloud dataset
+# \ingroup common
+# PCL_EXPORTS void copyPointCloud (const pcl::PCLPointCloud2 &cloud_in, pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Check if two given point types are the same or not. */
+# template <typename Point1T, typename Point2T> inline bool isSamePointType ()
+###
+
+# common/io.h
+# namespace pcl
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const std::vector<int> &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    # cdef void copyPointCloud [PointT](shared_ptr[cpp.PointCloud[PointT]] &cloud_in, const vector[int] &indices, shared_ptr[cpp.PointCloud[PointT]] &cloud_out)
+    # NG
+    # cdef void copyPointCloud_Indices "copyPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud_in, const vector[int] &indices, shared_ptr[cpp.PointCloud[PointT]] &cloud_out)
+    # cdef void copyPointCloud_Indices "pcl::copyPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud_in, const vector[int] &indices, shared_ptr[cpp.PointCloud[PointT]] &cloud_out)
+    void copyPointCloud_Indices "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const vector[int] &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const std::vector<int, Eigen::aligned_allocator<int> > &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    cdef void copyPointCloud_Indices2 "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const vector[int, eigen3.aligned_allocator_t] &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Extract the indices of a given point cloud as a new point cloud
+#   * \param[in] cloud_in the input point cloud dataset
+#   * \param[in] indices the PointIndices structure representing the points to be copied from cloud_in
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \note Assumes unique indices.
+#   * \ingroup common
+#   */
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const PointIndices &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    cdef void copyPointCloud_Indices3 "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const cpp.PointIndices &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Extract the indices of a given point cloud as a new point cloud
+#   * \param[in] cloud_in the input point cloud dataset
+#   * \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \note Assumes unique indices.
+#   * \ingroup common
+#   */
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const std::vector<pcl::PointIndices> &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    cdef void copyPointCloud_Indices4 "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const vector[cpp.PointIndices] &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Copy a point cloud inside a larger one interpolating borders.
+#   * \param[in] cloud_in the input point cloud dataset
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \param top
+#   * \param bottom
+#   * \param left
+#   * \param right
+#   * Position of cloud_in inside cloud_out is given by \a top, \a left, \a bottom \a right.
+#   * \param[in] border_type the interpolating method (pcl::BORDER_XXX)
+#   *  BORDER_REPLICATE:     aaaaaa|abcdefgh|hhhhhhh
+#   *  BORDER_REFLECT:       fedcba|abcdefgh|hgfedcb
+#   *  BORDER_REFLECT_101:   gfedcb|abcdefgh|gfedcba
+#   *  BORDER_WRAP:          cdefgh|abcdefgh|abcdefg
+#   *  BORDER_CONSTANT:      iiiiii|abcdefgh|iiiiiii  with some specified 'i'
+#   *  BORDER_TRANSPARENT:   mnopqr|abcdefgh|tuvwxyz  where m-r and t-z are orignal values of cloud_out
+#   * \param value
+#   * \throw pcl::BadArgumentException if any of top, bottom, left or right is negative.
+#   * \ingroup common
+#   */
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, int top, int bottom, int left, int right, pcl::InterpolationType border_type, const PointT& value);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Concatenate two datasets representing different fields.
+#   * \note If the input datasets have overlapping fields (i.e., both contain
+#   * the same fields), then the data in the second cloud (cloud2_in) will
+#   * overwrite the data in the first (cloud1_in).
+#   * \param[in] cloud1_in the first input dataset
+#   * \param[in] cloud2_in the second input dataset (overwrites the fields of the first dataset for those that are shared)
+#   * \param[out] cloud_out the resultant output dataset created by the concatenation of all the fields in the input datasets
+#   * \ingroup common
+#   */
+# template <typename PointIn1T, typename PointIn2T, typename PointOutT> void concatenateFields (const pcl::PointCloud<PointIn1T> &cloud1_in, const pcl::PointCloud<PointIn2T> &cloud2_in, pcl::PointCloud<PointOutT> &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Concatenate two datasets representing different fields.
+#   * \note If the input datasets have overlapping fields (i.e., both contain
+#   * the same fields), then the data in the second cloud (cloud2_in) will
+#   * overwrite the data in the first (cloud1_in).
+#   * \param[in] cloud1_in the first input dataset
+#   * \param[in] cloud2_in the second input dataset (overwrites the fields of the first dataset for those that are shared)
+#   * \param[out] cloud_out the output dataset created by concatenating all the fields in the input datasets
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool concatenateFields (const pcl::PCLPointCloud2 &cloud1_in,const pcl::PCLPointCloud2 &cloud2_in,pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Copy the XYZ dimensions of a pcl::PCLPointCloud2 into Eigen format
+#   * \param[in] in the point cloud message
+#   * \param[out] out the resultant Eigen MatrixXf format containing XYZ0 / point
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool getPointCloudAsEigen (const pcl::PCLPointCloud2 &in, Eigen::MatrixXf &out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Copy the XYZ dimensions from an Eigen MatrixXf into a pcl::PCLPointCloud2 message
+#   * \param[in] in the Eigen MatrixXf format containing XYZ0 / point
+#   * \param[out] out the resultant point cloud message
+#   * \note the method assumes that the PCLPointCloud2 message already has the fields set up properly !
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool getEigenAsPointCloud (Eigen::MatrixXf &in, pcl::PCLPointCloud2 &out);
+# 
+# namespace io 
+# {
+#   /** \brief swap bytes order of a char array of length N
+#     * \param bytes char array to swap
+#     * \ingroup common
+#     */
+#   template <std::size_t N> void swapByte (char* bytes);
+# 
+#  /** \brief specialization of swapByte for dimension 1
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<1> (char* bytes) { bytes[0] = bytes[0]; }
+# 
+#  /** \brief specialization of swapByte for dimension 2
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<2> (char* bytes) { std::swap (bytes[0], bytes[1]); }
+# 
+#  /** \brief specialization of swapByte for dimension 4
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<4> (char* bytes)
+# 
+#  /** \brief specialization of swapByte for dimension 8
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<8> (char* bytes)
+# 
+#   /** \brief swaps byte of an arbitrary type T casting it to char*
+#     * \param value the data you want its bytes swapped
+#     */
+#   template <typename T> void swapByte (T& value)
+
+
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Enum that defines all the types of norms available.
+#  * \note Any new norm type should have its own enum value and its own case in the selectNorm () method
+#  * \ingroup common
+#  */
+# enum NormType {L1, L2_SQR, L2, LINF, JM, B, SUBLINEAR, CS, DIV, PF, K, KL, HIK};
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Method that calculates any norm type available, based on the norm_type variable
+#  * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#  * \ingroup common
+#  * */
+# template <typename FloatVectorT> inline float
+# selectNorm (FloatVectorT A, FloatVectorT B, int dim, NormType norm_type);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the L1 norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# L1_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the squared L2 norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# L2_Norm_SQR (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the L2 norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# L2_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the L-infinity norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */  
+# template <typename FloatVectorT> inline float
+# Linf_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the JM norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# JM_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the B norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# B_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the sublinear norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# Sublinear_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the CS norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# CS_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the div norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# Div_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the PF norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \param P1 the first parameter
+#   * \param P2 the second parameter
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# PF_Norm (FloatVectorT A, FloatVectorT B, int dim, float P1, float P2);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the K norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \param P1 the first parameter
+#   * \param P2 the second parameter
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# K_Norm (FloatVectorT A, FloatVectorT B, int dim, float P1, float P2);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the KL between two discrete probability density functions
+#   * \param A the first discrete PDF
+#   * \param B the second discrete PDF
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# KL_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the HIK norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# HIK_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# pca.h
+# namespace pcl
+# cdef extern from "pcl/common/pca.h" namespace "pcl":
+# /** Principal Component analysis (PCA) class.\n
+#   *  Principal components are extracted by singular values decomposition on the 
+#   * covariance matrix of the centered input cloud. Available data after pca computation 
+#   * are the mean of the input data, the eigenvalues (in descending order) and 
+#   * corresponding eigenvectors.\n
+#   * Other methods allow projection in the eigenspace, reconstruction from eigenspace and 
+#   *  update of the eigenspace with a new datum (according Matej Artec, Matjaz Jogan and 
+#   * Ales Leonardis: "Incremental PCA for On-line Visual Learning and Recognition").
+#   * \author Nizar Sallem
+#   * \ingroup common
+#   */
+# template <typename PointT>
+# class PCA : public pcl::PCLBase <PointT>
+# {
+#   public:
+#     typedef pcl::PCLBase <PointT> Base;
+#     typedef typename Base::PointCloud PointCloud;
+#     typedef typename Base::PointCloudPtr PointCloudPtr;
+#     typedef typename Base::PointCloudConstPtr PointCloudConstPtr;
+#     typedef typename Base::PointIndicesPtr PointIndicesPtr;
+#     typedef typename Base::PointIndicesConstPtr PointIndicesConstPtr;
+# 
+#     using Base::input_;
+#     using Base::indices_;
+#     using Base::initCompute;
+#     using Base::setInputCloud;
+# 
+#     /** Updating method flag */
+#     enum FLAG 
+#     {
+#       /** keep the new basis vectors if possible */
+#       increase, 
+#       /** preserve subspace dimension */
+#       preserve
+#     };
+# 
+#     /** \brief Default Constructor
+#       * \param basis_only flag to compute only the PCA basis
+#       */
+#     PCA (bool basis_only = false)
+#       : Base ()
+#       , compute_done_ (false)
+#       , basis_only_ (basis_only) 
+#       , eigenvectors_ ()
+#       , coefficients_ ()
+#       , mean_ ()
+#       , eigenvalues_  ()
+#     {}
+#     
+#     /** \brief Constructor with direct computation
+#       * X input m*n matrix (ie n vectors of R(m))
+#       * basis_only flag to compute only the PCA basis
+#       */
+#     PCL_DEPRECATED ("Use PCA (bool basis_only); setInputCloud (X.makeShared ()); instead")
+#     PCA (const pcl::PointCloud<PointT>& X, bool basis_only = false);
+# 
+#     /** Copy Constructor
+#       * \param[in] pca PCA object
+#       */
+#     PCA (PCA const & pca) 
+#       : Base (pca)
+#       , compute_done_ (pca.compute_done_)
+#       , basis_only_ (pca.basis_only_) 
+#       , eigenvectors_ (pca.eigenvectors_)
+#       , coefficients_ (pca.coefficients_)
+#       , mean_ (pca.mean_)
+#       , eigenvalues_  (pca.eigenvalues_)
+#     {}
+# 
+#     /** Assignment operator
+#       * \param[in] pca PCA object
+#       */
+#     inline PCA& operator= (PCA const & pca) 
+# 
+#     /** \brief Provide a pointer to the input dataset
+#       * \param cloud the const boost shared pointer to a PointCloud message
+#       */
+#     inline void setInputCloud (const PointCloudConstPtr &cloud) 
+# 
+#     /** \brief Mean accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::Vector4f& getMean () 
+# 
+#     /** Eigen Vectors accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::Matrix3f& getEigenVectors () 
+# 
+#     /** Eigen Values accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::Vector3f& getEigenValues ()
+# 
+#     /** Coefficients accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::MatrixXf& getCoefficients () 
+# 
+#     /** update PCA with a new point
+#       * \param[in] input input point 
+#       * \param[in] flag update flag
+#       * \throw InitFailedException
+#       */
+#     inline void update (const PointT& input, FLAG flag = preserve);
+# 
+#     /** Project point on the eigenspace.
+#       * \param[in] input point from original dataset
+#       * \param[out] projection the point in eigen vectors space
+#       * \throw InitFailedException
+#       */
+#     inline void project (const PointT& input, PointT& projection);
+# 
+#     /** Project cloud on the eigenspace.
+#       * \param[in] input cloud from original dataset
+#       * \param[out] projection the cloud in eigen vectors space
+#       * \throw InitFailedException
+#       */
+#     inline void project (const PointCloud& input, PointCloud& projection);
+# 
+#     /** Reconstruct point from its projection
+#       * \param[in] projection point from eigenvector space
+#       * \param[out] input reconstructed point
+#       * \throw InitFailedException
+#       */
+#     inline void reconstruct (const PointT& projection, PointT& input);
+# 
+#     /** Reconstruct cloud from its projection
+#       * \param[in] projection cloud from eigenvector space
+#       * \param[out] input reconstructed cloud
+#       * \throw InitFailedException
+#       */
+#     inline void reconstruct (const PointCloud& projection, PointCloud& input);
+###
+
+# piecewise_linear_function.h
+# namespace pcl
+# cdef extern from "pcl/common/piecewise_linear_function.h" namespace "pcl":
+# /**
+#   * \brief This provides functionalities to efficiently return values for piecewise linear function
+#   * \ingroup common
+#   */
+# class PiecewiseLinearFunction
+#     	public:
+#       // =====CONSTRUCTOR & DESTRUCTOR=====
+#       //! Constructor
+#       PiecewiseLinearFunction (float factor, float offset);
+#       
+#       // =====PUBLIC METHODS=====
+#       //! Get the list of known data points
+#       std::vector<float>& getDataPoints () 
+#       
+#       //! Get the value of the function at the given point
+#       inline float getValue (float point) const;
+#       
+#       // =====PUBLIC MEMBER VARIABLES=====
+#       
+###
+
+# point_operators.h
+###
+
+# point_tests.h
+# namespace pcl
+# {
+#   /** Tests if the 3D components of a point are all finite
+#     * param[in] pt point to be tested
+#     */
+#   template <typename PointT> inline bool
+#   isFinite (const PointT &pt)
+#   {
+#     return (pcl_isfinite (pt.x) && pcl_isfinite (pt.y) && pcl_isfinite (pt.z));
+#   }
+# 
+# #ifdef _MSC_VER
+#   template <typename PointT> inline bool
+#   isFinite (const Eigen::internal::workaround_msvc_stl_support<PointT> &pt)
+#   {
+#     return isFinite<PointT> (static_cast<const PointT&> (pt));
+#   }
+# #endif
+# 
+#   template<> inline bool isFinite<pcl::RGB> (const pcl::RGB&) { return (true); }
+#   template<> inline bool isFinite<pcl::Label> (const pcl::Label&) { return (true); }
+#   template<> inline bool isFinite<pcl::Axis> (const pcl::Axis&) { return (true); }
+#   template<> inline bool isFinite<pcl::Intensity> (const pcl::Intensity&) { return (true); }
+#   template<> inline bool isFinite<pcl::MomentInvariants> (const pcl::MomentInvariants&) { return (true); }
+#   template<> inline bool isFinite<pcl::PrincipalRadiiRSD> (const pcl::PrincipalRadiiRSD&) { return (true); }
+#   template<> inline bool isFinite<pcl::Boundary> (const pcl::Boundary&) { return (true); }
+#   template<> inline bool isFinite<pcl::PrincipalCurvatures> (const pcl::PrincipalCurvatures&) { return (true); }
+#   template<> inline bool isFinite<pcl::SHOT352> (const pcl::SHOT352&) { return (true); }
+#   template<> inline bool isFinite<pcl::SHOT1344> (const pcl::SHOT1344&) { return (true); }
+#   template<> inline bool isFinite<pcl::ReferenceFrame> (const pcl::ReferenceFrame&) { return (true); }
+#   template<> inline bool isFinite<pcl::ShapeContext1980> (const pcl::ShapeContext1980&) { return (true); }
+#   template<> inline bool isFinite<pcl::PFHSignature125> (const pcl::PFHSignature125&) { return (true); }
+#   template<> inline bool isFinite<pcl::PFHRGBSignature250> (const pcl::PFHRGBSignature250&) { return (true); }
+#   template<> inline bool isFinite<pcl::PPFSignature> (const pcl::PPFSignature&) { return (true); }
+#   template<> inline bool isFinite<pcl::PPFRGBSignature> (const pcl::PPFRGBSignature&) { return (true); }
+#   template<> inline bool isFinite<pcl::NormalBasedSignature12> (const pcl::NormalBasedSignature12&) { return (true); }
+#   template<> inline bool isFinite<pcl::FPFHSignature33> (const pcl::FPFHSignature33&) { return (true); }
+#   template<> inline bool isFinite<pcl::VFHSignature308> (const pcl::VFHSignature308&) { return (true); }
+#   template<> inline bool isFinite<pcl::ESFSignature640> (const pcl::ESFSignature640&) { return (true); }
+#   template<> inline bool isFinite<pcl::IntensityGradient> (const pcl::IntensityGradient&) { return (true); }
+# 
+#   // specification for pcl::PointXY
+#   template <> inline bool
+#   isFinite<pcl::PointXY> (const pcl::PointXY &p)
+#   {
+#     return (pcl_isfinite (p.x) && pcl_isfinite (p.y));
+#   }
+# 
+#   // specification for pcl::BorderDescription
+#   template <> inline bool
+#   isFinite<pcl::BorderDescription> (const pcl::BorderDescription &p)
+#   {
+#     return (pcl_isfinite (p.x) && pcl_isfinite (p.y));
+#   }
+# 
+#   // specification for pcl::Normal
+#   template <> inline bool
+#   isFinite<pcl::Normal> (const pcl::Normal &n)
+#   {
+#     return (pcl_isfinite (n.normal_x) && pcl_isfinite (n.normal_y) && pcl_isfinite (n.normal_z));
+#   }
+# }
+###
+
+# polynomial_calculations.h
+# namespace pcl 
+# {
+#   /** \brief This provides some functionality for polynomials,
+#     *         like finding roots or approximating bivariate polynomials
+#     *  \author Bastian Steder 
+#     *  \ingroup common
+#     */
+#   template <typename real>
+#   class PolynomialCalculationsT 
+#   {
+#     public:
+#       // =====CONSTRUCTOR & DESTRUCTOR=====
+#       PolynomialCalculationsT ();
+#       ~PolynomialCalculationsT ();
+#       
+#       // =====PUBLIC STRUCTS=====
+#       //! Parameters used in this class
+#       struct Parameters
+#       {
+#         Parameters () : zero_value (), sqr_zero_value () { setZeroValue (1e-6);}
+#         //! Set zero_value
+#         void
+#         setZeroValue (real new_zero_value);
+# 
+#         real zero_value;       //!< Every value below this is considered to be zero
+#         real sqr_zero_value;   //!< sqr of the above
+#       };
+#       
+#       // =====PUBLIC METHODS=====
+#       /** Solves an equation of the form ax^4 + bx^3 + cx^2 +dx + e = 0
+#        *  See http://en.wikipedia.org/wiki/Quartic_equation#Summary_of_Ferrari.27s_method */
+#       inline void
+#       solveQuarticEquation (real a, real b, real c, real d, real e, std::vector<real>& roots) const;
+# 
+#       /** Solves an equation of the form ax^3 + bx^2 + cx + d = 0
+#        *  See http://en.wikipedia.org/wiki/Cubic_equation */
+#       inline void
+#       solveCubicEquation (real a, real b, real c, real d, std::vector<real>& roots) const;
+# 
+#       /** Solves an equation of the form ax^2 + bx + c = 0
+#        *  See http://en.wikipedia.org/wiki/Quadratic_equation */
+#       inline void
+#       solveQuadraticEquation (real a, real b, real c, std::vector<real>& roots) const;
+# 
+#       /** Solves an equation of the form ax + b = 0 */
+#       inline void
+#       solveLinearEquation (real a, real b, std::vector<real>& roots) const;
+#       
+#       /** Get the bivariate polynomial approximation for Z(X,Y) from the given sample points.
+#        *  The parameters a,b,c,... for the polynom are returned.
+#        *  The order is, e.g., for degree 1: ax+by+c and for degree 2: ax2+bxy+cx+dy2+ey+f.
+#        *  error is set to true if the approximation did not work for any reason
+#        *  (not enough points, matrix not invertible, etc.) */
+#       inline BivariatePolynomialT<real>
+#       bivariatePolynomialApproximation (std::vector<Eigen::Matrix<real, 3, 1> >& samplePoints,
+#                                         unsigned int polynomial_degree, bool& error) const;
+#       
+#       //! Same as above, using a reference for the return value
+#       inline bool
+#       bivariatePolynomialApproximation (std::vector<Eigen::Matrix<real, 3, 1> >& samplePoints,
+#                                         unsigned int polynomial_degree, BivariatePolynomialT<real>& ret) const;
+# 
+#       //! Set the minimum value under which values are considered zero
+#       inline void
+#       setZeroValue (real new_zero_value) { parameters_.setZeroValue(new_zero_value); }
+#       
+#     protected:  
+#       // =====PROTECTED METHODS=====
+#       //! check if fabs(d)<zeroValue
+#       inline bool
+#       isNearlyZero (real d) const 
+#       { 
+#         return (fabs (d) < parameters_.zero_value);
+#       }
+#       
+#       //! check if sqrt(fabs(d))<zeroValue
+#       inline bool
+#       sqrtIsNearlyZero (real d) const 
+#       { 
+#         return (fabs (d) < parameters_.sqr_zero_value);
+#       }
+#       
+#       // =====PROTECTED MEMBERS=====
+#       Parameters parameters_;
+#   };
+# 
+#   typedef PolynomialCalculationsT<double> PolynomialCalculationsd;
+#   typedef PolynomialCalculationsT<float>  PolynomialCalculations;
+# 
+# }  // end namespace
+###
+
+# poses_from_matches.h
+# namespace pcl
+# {
+#   /**
+#     * \brief calculate 3D transformation based on point correspondencdes
+#     * \author Bastian Steder
+#     * \ingroup common
+#     */
+#   class PCL_EXPORTS PosesFromMatches
+#   {
+#     public:
+#       // =====CONSTRUCTOR & DESTRUCTOR=====
+#       //! Constructor
+#       PosesFromMatches();
+#       //! Destructor
+#       ~PosesFromMatches();
+#       
+#       // =====STRUCTS=====
+#       //! Parameters used in this class
+#       struct PCL_EXPORTS Parameters
+#       {
+#         Parameters() : max_correspondence_distance_error(0.2f) {}
+#         float max_correspondence_distance_error;  // As a fraction
+#       };
+# 
+#       //! A result of the pose estimation process
+#       struct PoseEstimate
+#       {
+#         PoseEstimate () : 
+#           transformation (Eigen::Affine3f::Identity ()),
+#           score (0),
+#           correspondence_indices (0) 
+#         {}
+# 
+#         Eigen::Affine3f transformation;   //!< The estimated transformation between the two coordinate systems
+#         float score;                         //!< An estimate in [0,1], how good the estimated pose is 
+#         std::vector<int> correspondence_indices;  //!< The indices of the used correspondences
+# 
+#         struct IsBetter 
+#         {
+#           bool operator()(const PoseEstimate& pe1, const PoseEstimate& pe2) const { return pe1.score>pe2.score;}
+#         };
+#         public:
+#           EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#       };
+#       
+#       // =====TYPEDEFS=====
+#       typedef std::vector<PoseEstimate, Eigen::aligned_allocator<PoseEstimate> > PoseEstimatesVector;
+# 
+#       
+#       // =====STATIC METHODS=====
+#       
+#       // =====PUBLIC METHODS=====
+#       /** Use single 6DOF correspondences to estimate transformations between the coordinate systems.
+#        *  Use max_no_of_results=-1 to use all.
+#        *  It is assumed, that the correspondences are sorted from good to bad. */
+#       void 
+#       estimatePosesUsing1Correspondence (
+#           const PointCorrespondences6DVector& correspondences,
+#           int max_no_of_results, PoseEstimatesVector& pose_estimates) const;
+# 
+#       /** Use pairs of 6DOF correspondences to estimate transformations between the coordinate systems.
+#        *  It is assumed, that the correspondences are sorted from good to bad. */
+#       void 
+#       estimatePosesUsing2Correspondences (
+#           const PointCorrespondences6DVector& correspondences,
+#           int max_no_of_tested_combinations, int max_no_of_results,
+#           PoseEstimatesVector& pose_estimates) const;
+#       
+#       /** Use triples of 6DOF correspondences to estimate transformations between the coordinate systems.
+#        *  It is assumed, that the correspondences are sorted from good to bad. */
+#       void 
+#       estimatePosesUsing3Correspondences (
+#           const PointCorrespondences6DVector& correspondences,
+#           int max_no_of_tested_combinations, int max_no_of_results,
+#           PoseEstimatesVector& pose_estimates) const;
+# 
+#       /// Get a reference to the parameters struct
+#       Parameters& 
+#       getParameters () { return parameters_; }
+# 
+#     protected:
+#       // =====PROTECTED MEMBER VARIABLES=====
+#       Parameters parameters_;
+# 
+#   };
+# 
+# }  // end namespace pcl
+###
+
+# projection_matrix.h
+# namespace pcl
+# {
+#   template <typename T> class PointCloud;
+# 
+#   /** \brief Estimates the projection matrix P = K * (R|-R*t) from organized point clouds, with
+#     *        K = [[fx, s, cx], [0, fy, cy], [0, 0, 1]]
+#     *        R = rotation matrix and
+#     *        t = translation vector  
+#     * 
+#     * \param[in] cloud input cloud. Must be organized and from a projective device. e.g. stereo or kinect, ...
+#     * \param[out] projection_matrix output projection matrix
+#     * \param[in] indices The indices to be used to determine the projection matrix 
+#     * \return the resudial error. A high residual indicates, that the point cloud was not from a projective device.
+#     */
+#   template<typename PointT> double
+#   estimateProjectionMatrix (typename pcl::PointCloud<PointT>::ConstPtr cloud, Eigen::Matrix<float, 3, 4, Eigen::RowMajor>& projection_matrix, const std::vector<int>& indices = std::vector<int> ());
+#   
+#   /** \brief Determines the camera matrix from the given projection matrix.
+#     * \note This method does NOT use a RQ decomposition, but uses the fact that the left 3x3 matrix P' of P squared eliminates the rotational part.
+#     *       P' = K * R -> P' * P'^T = K * R * R^T * K = K * K^T
+#     * \param[in] projection_matrix
+#     * \param[out] camera_matrix
+#     */
+#   PCL_EXPORTS void
+#   getCameraMatrixFromProjectionMatrix (const Eigen::Matrix<float, 3, 4, Eigen::RowMajor>& projection_matrix, Eigen::Matrix3f& camera_matrix);  
+# }
+###
+
+# random.h
+# namespace pcl 
+# {
+#   namespace common 
+#   {
+#     /// uniform distribution dummy struct
+#     template <typename T> struct uniform_distribution;
+#     /// uniform distribution int specialized
+#     template<> 
+#     struct uniform_distribution<int> 
+#     {
+#       typedef boost::uniform_int<int> type;
+#     };
+#     /// uniform distribution float specialized
+#     template<> 
+#     struct uniform_distribution<float> 
+#     {
+#       typedef boost::uniform_real<float> type;
+#     };
+#     ///  normal distribution
+#     template<typename T> 
+#     struct normal_distribution
+#     {
+#       typedef boost::normal_distribution<T> type;
+#     };
+# 
+#     /** \brief UniformGenerator class generates a random number from range [min, max] at each run picked
+#       * according to a uniform distribution i.e eaach number within [min, max] has almost the same 
+#       * probability of being drawn.
+#       *
+#       * \author Nizar Sallem
+#       */
+#     template<typename T>
+#     class UniformGenerator 
+#     {
+#       public:
+#         struct Parameters
+#         {
+#             Parameters (T _min = 0, T _max = 1, pcl::uint32_t _seed = 1)
+#             : min (_min)
+#             , max (_max)
+#             , seed (_seed)
+#           {}
+# 
+#           T min;
+#           T max;
+#           pcl::uint32_t seed;
+#         };
+# 
+#         /** Constructor
+#           * \param min: included lower bound
+#           * \param max: included higher bound
+#           * \param seed: seeding value
+#           */
+#         UniformGenerator(T min = 0, T max = 1, pcl::uint32_t seed = -1);
+# 
+#         /** Constructor
+#           * \param parameters uniform distribution parameters and generator seed
+#           */
+#         UniformGenerator(const Parameters& parameters);
+# 
+#         /** Change seed value
+#           * \param[in] seed new generator seed value
+#           */
+#         void 
+#         setSeed (pcl::uint32_t seed);
+# 
+#         /** Set the uniform number generator parameters
+#           * \param[in] min minimum allowed value
+#           * \param[in] max maximum allowed value
+#           * \param[in] seed random number generator seed (applied if != -1)
+#           */
+#         void 
+#         setParameters (T min, T max, pcl::uint32_t seed = -1);
+# 
+#         /** Set generator parameters
+#           * \param parameters uniform distribution parameters and generator seed
+#           */
+#         void
+#         setParameters (const Parameters& parameters);
+# 
+#         /// \return uniform distribution parameters and generator seed
+#         const Parameters&
+#         getParameters () { return (parameters_); }
+# 
+#         /// \return a randomly generated number in the interval [min, max]
+#         inline T 
+#         run () { return (generator_ ()); }
+# 
+#       private:
+#         typedef boost::mt19937 EngineType;
+#         typedef typename uniform_distribution<T>::type DistributionType;
+#         /// parameters
+#         Parameters parameters_;
+#         /// uniform distribution
+#         DistributionType distribution_;
+#         /// random number generator
+#         EngineType rng_;
+#         /// generator of random number from a uniform distribution
+#         boost::variate_generator<EngineType&, DistributionType> generator_;
+#     };
+# 
+#     /** \brief NormalGenerator class generates a random number from a normal distribution specified
+#       * by (mean, sigma).
+#       *
+#       * \author Nizar Sallem
+#       */
+#     template<typename T>
+#     class NormalGenerator 
+#     {
+#       public:
+#         struct Parameters
+#         {
+#             Parameters (T _mean = 0, T _sigma = 1, pcl::uint32_t _seed = 1)
+#             : mean (_mean)
+#             , sigma (_sigma)
+#             , seed (_seed)
+#           {}
+# 
+#           T mean;
+#           T sigma;
+#           pcl::uint32_t seed;
+#         };
+# 
+#         /** Constructor
+#           * \param[in] mean normal mean
+#           * \param[in] sigma normal variation
+#           * \param[in] seed seeding value
+#           */
+#         NormalGenerator(T mean = 0, T sigma = 1, pcl::uint32_t seed = -1);
+# 
+#         /** Constructor
+#           * \param parameters normal distribution parameters and seed
+#           */
+#         NormalGenerator(const Parameters& parameters);
+# 
+#         /** Change seed value
+#           * \param[in] seed new seed value
+#           */
+#         void 
+#         setSeed (pcl::uint32_t seed);
+# 
+#         /** Set the normal number generator parameters
+#           * \param[in] mean mean of the normal distribution
+#           * \param[in] sigma standard variation of the normal distribution
+#           * \param[in] seed random number generator seed (applied if != -1)
+#           */
+#         void 
+#         setParameters (T mean, T sigma, pcl::uint32_t seed = -1);
+# 
+#         /** Set generator parameters
+#           * \param parameters normal distribution parameters and seed
+#           */
+#         void
+#         setParameters (const Parameters& parameters);
+# 
+#         /// \return normal distribution parameters and generator seed
+#         const Parameters&
+#         getParameters () { return (parameters_); }
+# 
+#         /// \return a randomly generated number in the normal distribution (mean, sigma)
+#         inline T 
+#         run () { return (generator_ ()); }
+# 
+#         typedef boost::mt19937 EngineType;
+#         typedef typename normal_distribution<T>::type DistributionType;
+#         /// parameters
+#         Parameters parameters_;
+#         /// normal distribution
+#         DistributionType distribution_;
+#         /// random number generator
+#         EngineType rng_;
+#         /// generator of random number from a normal distribution
+#         boost::variate_generator<EngineType&, DistributionType > generator_;
+#     };
+#   }
+# }
+###
+
+# register_point_struct.h
+# #include <pcl/pcl_macros.h>
+# #include <pcl/point_traits.h>
+# #include <boost/mpl/vector.hpp>
+# #include <boost/preprocessor/seq/enum.hpp>
+# #include <boost/preprocessor/seq/for_each.hpp>
+# #include <boost/preprocessor/seq/transform.hpp>
+# #include <boost/preprocessor/cat.hpp>
+# #include <boost/preprocessor/comparison.hpp>
+# #include <boost/utility.hpp>
+# //https://bugreports.qt-project.org/browse/QTBUG-22829
+# #ifndef Q_MOC_RUN
+# #include <boost/type_traits.hpp>
+# #endif
+# #include <stddef.h> //offsetof
+# 
+# // Must be used in global namespace with name fully qualified
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT(name, fseq)               \
+#   POINT_CLOUD_REGISTER_POINT_STRUCT_I(name,                         \
+#     BOOST_PP_CAT(POINT_CLOUD_REGISTER_POINT_STRUCT_X fseq, 0))      \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_POINT_WRAPPER(wrapper, pod)    \
+#   BOOST_MPL_ASSERT_MSG(sizeof(wrapper) == sizeof(pod), POINT_WRAPPER_AND_POD_TYPES_HAVE_DIFFERENT_SIZES, (wrapper&, pod&)); \
+#   namespace pcl {                                           \
+#     namespace traits {                                      \
+#       template<> struct POD<wrapper> { typedef pod type; }; \
+#     }                                                       \
+#   }                                                         \
+#   /***/
+# 
+# // These macros help transform the unusual data structure (type, name, tag)(type, name, tag)...
+# // into a proper preprocessor sequence of 3-tuples ((type, name, tag))((type, name, tag))...
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_X(type, name, tag)            \
+#   ((type, name, tag)) POINT_CLOUD_REGISTER_POINT_STRUCT_Y
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_Y(type, name, tag)            \
+#   ((type, name, tag)) POINT_CLOUD_REGISTER_POINT_STRUCT_X
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_X0
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_Y0
+# 
+# namespace pcl
+# {
+#   namespace traits
+#   {
+#     template<typename T> inline
+#     typename boost::disable_if_c<boost::is_array<T>::value>::type
+#     plus (T &l, const T &r)
+#     {
+#       l += r;
+#     }
+# 
+#     template<typename T> inline
+#     typename boost::enable_if_c<boost::is_array<T>::value>::type
+#     plus (typename boost::remove_const<T>::type &l, const T &r)
+#     {
+#       typedef typename boost::remove_all_extents<T>::type type;
+#       static const uint32_t count = sizeof (T) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         l[i] += r[i];
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     plusscalar (T1 &p, const T2 &scalar)
+#     {
+#       p += scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     plusscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] += scalar;
+#     }
+# 
+#     template<typename T> inline
+#     typename boost::disable_if_c<boost::is_array<T>::value>::type
+#     minus (T &l, const T &r)
+#     {
+#       l -= r;
+#     }
+# 
+#     template<typename T> inline
+#     typename boost::enable_if_c<boost::is_array<T>::value>::type
+#     minus (typename boost::remove_const<T>::type &l, const T &r)
+#     {
+#       typedef typename boost::remove_all_extents<T>::type type;
+#       static const uint32_t count = sizeof (T) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         l[i] -= r[i];
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     minusscalar (T1 &p, const T2 &scalar)
+#     {
+#       p -= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     minusscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] -= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     mulscalar (T1 &p, const T2 &scalar)
+#     {
+#       p *= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     mulscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] *= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     divscalar (T1 &p, const T2 &scalar)
+#     {
+#       p /= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     divscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] /= scalar;
+#     }
+#   }
+# }
+# 
+# // Point operators
+# #define PCL_PLUSEQ_POINT_TAG(r, data, elem)                \
+#   pcl::traits::plus (lhs.BOOST_PP_TUPLE_ELEM(3, 1, elem),  \
+#                      rhs.BOOST_PP_TUPLE_ELEM(3, 1, elem)); \
+#   /***/
+# 
+# #define PCL_PLUSEQSC_POINT_TAG(r, data, elem)                 \
+#   pcl::traits::plusscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                            scalar);                           \
+#   /***/
+#    //p.BOOST_PP_TUPLE_ELEM(3, 1, elem) += scalar;  \
+# 
+# #define PCL_MINUSEQ_POINT_TAG(r, data, elem)                \
+#   pcl::traits::minus (lhs.BOOST_PP_TUPLE_ELEM(3, 1, elem),  \
+#                       rhs.BOOST_PP_TUPLE_ELEM(3, 1, elem)); \
+#   /***/
+# 
+# #define PCL_MINUSEQSC_POINT_TAG(r, data, elem)                 \
+#   pcl::traits::minusscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                             scalar);                           \
+#   /***/
+#    //p.BOOST_PP_TUPLE_ELEM(3, 1, elem) -= scalar;   \
+# 
+# #define PCL_MULEQSC_POINT_TAG(r, data, elem)                 \
+#   pcl::traits::mulscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                             scalar);                         \
+#   /***/
+# 
+# #define PCL_DIVEQSC_POINT_TAG(r, data, elem)   \
+#   pcl::traits::divscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                             scalar);                         \
+#   /***/
+# 
+# // Construct type traits given full sequence of (type, name, tag) triples
+# //  BOOST_MPL_ASSERT_MSG(boost::is_pod<name>::value,
+# //                       REGISTERED_POINT_TYPE_MUST_BE_PLAIN_OLD_DATA, (name));
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_I(name, seq)                           \
+#   namespace pcl                                                                  \
+#   {                                                                              \
+#     namespace fields                                                             \
+#     {                                                                            \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_TAG, name, seq)           \
+#     }                                                                            \
+#     namespace traits                                                             \
+#     {                                                                            \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_NAME, name, seq)          \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_OFFSET, name, seq)        \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_DATATYPE, name, seq)      \
+#       POINT_CLOUD_REGISTER_POINT_FIELD_LIST(name, POINT_CLOUD_EXTRACT_TAGS(seq)) \
+#     }                                                                            \
+#     namespace common                                           \
+#     {                                                          \
+#       inline const name&                                       \
+#       operator+= (name& lhs, const name& rhs)                  \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_PLUSEQ_POINT_TAG, _, seq)    \
+#         return (lhs);                                          \
+#       }                                                        \
+#       inline const name&                                       \
+#       operator+= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_PLUSEQSC_POINT_TAG, _, seq)  \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator+ (const name& lhs, const name& rhs)   \
+#       { name result = lhs; result += rhs; return (result); }           \
+#       inline const name operator+ (const float& scalar, const name& p) \
+#       { name result = p; result += scalar; return (result); }          \
+#       inline const name operator+ (const name& p, const float& scalar) \
+#       { name result = p; result += scalar; return (result); }          \
+#       inline const name&                                       \
+#       operator-= (name& lhs, const name& rhs)                  \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_MINUSEQ_POINT_TAG, _, seq)   \
+#         return (lhs);                                          \
+#       }                                                        \
+#       inline const name&                                       \
+#       operator-= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_MINUSEQSC_POINT_TAG, _, seq) \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator- (const name& lhs, const name& rhs)   \
+#       { name result = lhs; result -= rhs; return (result); }           \
+#       inline const name operator- (const float& scalar, const name& p) \
+#       { name result = p; result -= scalar; return (result); }          \
+#       inline const name operator- (const name& p, const float& scalar) \
+#       { name result = p; result -= scalar; return (result); }          \
+#       inline const name&                                       \
+#       operator*= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_MULEQSC_POINT_TAG, _, seq)   \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator* (const float& scalar, const name& p) \
+#       { name result = p; result *= scalar; return (result); }          \
+#       inline const name operator* (const name& p, const float& scalar) \
+#       { name result = p; result *= scalar; return (result); }          \
+#       inline const name&                                       \
+#       operator/= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_DIVEQSC_POINT_TAG, _, seq)   \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator/ (const float& scalar, const name& p) \
+#       { name result = p; result /= scalar; return (result); }          \
+#       inline const name operator/ (const name& p, const float& scalar) \
+#       { name result = p; result /= scalar; return (result); }          \
+#     }                                                          \
+#   }                                                            \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_TAG(r, name, elem)   \
+#   struct BOOST_PP_TUPLE_ELEM(3, 2, elem);               \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_NAME(r, point, elem)                 \
+#   template<int dummy>                                                   \
+#   struct name<point, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem), dummy> \
+#   {                                                                     \
+#     static const char value[];                                          \
+#   };                                                                    \
+#                                                                         \
+#   template<int dummy>                                                   \
+#   const char name<point,                                                \
+#                   pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem),         \
+#                   dummy>::value[] =                                     \
+#     BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(3, 2, elem));                \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_OFFSET(r, name, elem)                \
+#   template<> struct offset<name, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)> \
+#   {                                                                     \
+#     static const size_t value = offsetof(name, BOOST_PP_TUPLE_ELEM(3, 1, elem)); \
+#   };                                                                    \
+#   /***/
+# 
+# // \note: the mpl::identity weirdness is to support array types without requiring the
+# // user to wrap them. The basic problem is:
+# // typedef float[81] type; // SYNTAX ERROR!
+# // typedef float type[81]; // OK, can now use "type" as a synonym for float[81]
+# #define POINT_CLOUD_REGISTER_FIELD_DATATYPE(r, name, elem)              \
+#   template<> struct datatype<name, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)> \
+#   {                                                                     \
+#     typedef boost::mpl::identity<BOOST_PP_TUPLE_ELEM(3, 0, elem)>::type type; \
+#     typedef decomposeArray<type> decomposed;                            \
+#     static const uint8_t value = asEnum<decomposed::type>::value;       \
+#     static const uint32_t size = decomposed::value;                     \
+#   };                                                                    \
+#   /***/
+# 
+# #define POINT_CLOUD_TAG_OP(s, data, elem) pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)
+# 
+# #define POINT_CLOUD_EXTRACT_TAGS(seq) BOOST_PP_SEQ_TRANSFORM(POINT_CLOUD_TAG_OP, _, seq)
+# 
+# #define POINT_CLOUD_REGISTER_POINT_FIELD_LIST(name, seq)        \
+#   template<> struct fieldList<name>                             \
+#   {                                                             \
+#     typedef boost::mpl::vector<BOOST_PP_SEQ_ENUM(seq)> type;    \
+#   };                                                            \
+#   /***/
+# 
+# #if defined _MSC_VER
+#   #pragma warning (pop)
+# #endif
+###
+
+# spring.h
+# namespace pcl
+# {
+#   namespace common
+#   {
+#     /** expand point cloud inserting \a amount rows at the 
+#      * top and the bottom of a point cloud and filling them with 
+#      * custom values.
+#      * \param[in] input the input point cloud
+#      * \param[out] output the output point cloud
+#      * \param[in] val the point value to be insterted
+#      * \param[in] amount the amount of rows to be added
+#      */
+#     template <typename PointT> void
+#     expandRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const PointT& val, const size_t& amount);
+# 
+#     /** expand point cloud inserting \a amount columns at 
+#       * the right and the left of a point cloud and filling them with 
+#       * custom values.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] val the point value to be insterted
+#       * \param[in] amount the amount of columns to be added
+#       */
+#     template <typename PointT> void
+#     expandColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                    const PointT& val, const size_t& amount);
+# 
+#     /** expand point cloud duplicating the \a amount top and bottom rows times.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     duplicateRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                    const size_t& amount);
+# 
+#     /** expand point cloud duplicating the \a amount right and left columns
+#       * times.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of cilumns to be added
+#       */
+#     template <typename PointT> void
+#     duplicateColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                       const size_t& amount);
+# 
+#     /** expand point cloud mirroring \a amount top and bottom rows. 
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     mirrorRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const size_t& amount);
+# 
+#     /** expand point cloud mirroring \a amount right and left columns.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     mirrorColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                    const size_t& amount);
+# 
+#     /** delete \a amount rows in top and bottom of point cloud 
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     deleteRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const size_t& amount);
+# 
+#     /** delete \a amount columns in top and bottom of point cloud
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     deleteCols (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const size_t& amount);
+#   };
+# }
+###
+
+# synchronizer.h
+# namespace pcl
+# {
+#   /** /brief This template class synchronizes two data streams of different types.
+#    *         The data can be added using add0 and add1 methods which expects also a timestamp of type unsigned long.
+#    *         If two matching data objects are found, registered callback functions are invoked with the objects and the time stamps.
+#    *         The only assumption of the timestamp is, that they are in the same unit, linear and strictly monotonic increasing.
+#    *         If filtering is desired, e.g. thresholding of time differences, the user can do that in the callback method.
+#    *         This class is thread safe.
+#    * /ingroup common
+#    */
+#   template <typename T1, typename T2>
+#   class Synchronizer
+#   {
+#     typedef std::pair<unsigned long, T1> T1Stamped;
+#     typedef std::pair<unsigned long, T2> T2Stamped;
+#     boost::mutex mutex1_;
+#     boost::mutex mutex2_;
+#     boost::mutex publish_mutex_;
+#     std::deque<T1Stamped> queueT1;
+#     std::deque<T2Stamped> queueT2;
+# 
+#     typedef boost::function<void(T1, T2, unsigned long, unsigned long) > CallbackFunction;
+# 
+#     std::map<int, CallbackFunction> cb_;
+#     int callback_counter;
+#   public:
+# 
+#     Synchronizer () : mutex1_ (), mutex2_ (), publish_mutex_ (), queueT1 (), queueT2 (), cb_ (), callback_counter (0) { };
+# 
+#     int
+#     addCallback (const CallbackFunction& callback)
+#     {
+#       boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+#       cb_[callback_counter] = callback;
+#       return callback_counter++;
+#     }
+# 
+#     void
+#     removeCallback (int i)
+#     {
+#       boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+#       cb_.erase (i);
+#     }
+# 
+#     void
+#     add0 (const T1& t, unsigned long time)
+#     {
+#       mutex1_.lock ();
+#       queueT1.push_back (T1Stamped (time, t));
+#       mutex1_.unlock ();
+#       publish ();
+#     }
+# 
+#     void
+#     add1 (const T2& t, unsigned long time)
+#     {
+#       mutex2_.lock ();
+#       queueT2.push_back (T2Stamped (time, t));
+#       mutex2_.unlock ();
+#       publish ();
+#     }
+# 
+#   private:
+# 
+#     void
+#     publishData ()
+#     {
+#       boost::unique_lock<boost::mutex> lock1 (mutex1_);
+#       boost::unique_lock<boost::mutex> lock2 (mutex2_);
+# 
+#       for (typename std::map<int, CallbackFunction>::iterator cb = cb_.begin (); cb != cb_.end (); ++cb)
+#       {
+#         if (!cb->second.empty ())
+#         {
+#           cb->second.operator()(queueT1.front ().second, queueT2.front ().second, queueT1.front ().first, queueT2.front ().first);
+#         }
+#       }
+# 
+#       queueT1.pop_front ();
+#       queueT2.pop_front ();
+#     }
+# 
+#     void
+#     publish ()
+#     {
+#       // only one publish call at once allowed
+#       boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+# 
+#       boost::unique_lock<boost::mutex> lock1 (mutex1_);
+#       if (queueT1.empty ())
+#         return;
+#       T1Stamped t1 = queueT1.front ();
+#       lock1.unlock ();
+# 
+#       boost::unique_lock<boost::mutex> lock2 (mutex2_);
+#       if (queueT2.empty ())
+#         return;
+#       T2Stamped t2 = queueT2.front ();
+#       lock2.unlock ();
+# 
+#       bool do_publish = false;
+# 
+#       if (t1.first <= t2.first)
+#       { // iterate over queue1
+#         lock1.lock ();
+#         while (queueT1.size () > 1 && queueT1[1].first <= t2.first)
+#           queueT1.pop_front ();
+# 
+#         if (queueT1.size () > 1)
+#         { // we have at least 2 measurements; first in past and second in future -> find out closer one!
+#           if ( (t2.first << 1) > (queueT1[0].first + queueT1[1].first) )
+#             queueT1.pop_front ();
+# 
+#           do_publish = true;
+#         }
+#         lock1.unlock ();
+#       }
+#       else
+#       { // iterate over queue2
+#         lock2.lock ();
+#         while (queueT2.size () > 1 && (queueT2[1].first <= t1.first) )
+#           queueT2.pop_front ();
+# 
+#         if (queueT2.size () > 1)
+#         { // we have at least 2 measurements; first in past and second in future -> find out closer one!
+#           if ( (t1.first << 1) > queueT2[0].first + queueT2[1].first )
+#             queueT2.pop_front ();
+# 
+#           do_publish = true;
+#         }
+#         lock2.unlock ();
+#       }
+# 
+#       if (do_publish)
+#         publishData ();
+#     }
+#   } ;
+# } // namespace
+###
+
+# time.h
+# namespace pcl
+# {
+#   /** \brief Simple stopwatch.
+#     * \ingroup common
+#     */
+#   class StopWatch
+#   {
+#     public:
+#       /** \brief Constructor. */
+#       StopWatch () : start_time_ (boost::posix_time::microsec_clock::local_time ())
+#       {
+#       }
+# 
+#       /** \brief Destructor. */
+#       virtual ~StopWatch () {}
+# 
+#       /** \brief Retrieve the time in milliseconds spent since the last call to \a reset(). */
+#       inline double
+#       getTime ()
+#       {
+#         boost::posix_time::ptime end_time = boost::posix_time::microsec_clock::local_time ();
+#         return (static_cast<double> (((end_time - start_time_).total_milliseconds ())));
+#       }
+# 
+#       /** \brief Retrieve the time in seconds spent since the last call to \a reset(). */
+#       inline double
+#       getTimeSeconds ()
+#       {
+#         return (getTime () * 0.001f);
+#       }
+# 
+#       /** \brief Reset the stopwatch to 0. */
+#       inline void
+#       reset ()
+#       {
+#         start_time_ = boost::posix_time::microsec_clock::local_time ();
+#       }
+# 
+#     protected:
+#       boost::posix_time::ptime start_time_;
+#   };
+# 
+#   /** \brief Class to measure the time spent in a scope
+#     *
+#     * To use this class, e.g. to measure the time spent in a function,
+#     * just create an instance at the beginning of the function. Example:
+#     *
+#     * \code
+#     * {
+#     *   pcl::ScopeTime t1 ("calculation");
+#     *
+#     *   // ... perform calculation here
+#     * }
+#     * \endcode
+#     *
+#     * \ingroup common
+#     */
+#   class ScopeTime : public StopWatch
+#   {
+#     public:
+#       inline ScopeTime (const char* title) : 
+#         title_ (std::string (title))
+#       {
+#         start_time_ = boost::posix_time::microsec_clock::local_time ();
+#       }
+# 
+#       inline ScopeTime () :
+#         title_ (std::string (""))
+#       {
+#         start_time_ = boost::posix_time::microsec_clock::local_time ();
+#       }
+# 
+#       inline ~ScopeTime ()
+#       {
+#         double val = this->getTime ();
+#         std::cerr << title_ << " took " << val << "ms.\n";
+#       }
+#   };
+# 
+# 
+# #ifndef MEASURE_FUNCTION_TIME
+# #define MEASURE_FUNCTION_TIME \
+#   ScopeTime scopeTime(__func__)
+# #endif
+# 
+# inline double getTime ()
+# 
+# /// Executes code, only if secs are gone since last exec.
+# #ifndef DO_EVERY_TS
+# #define DO_EVERY_TS(secs, currentTime, code) \
+# if (1) {\
+#   static double s_lastDone_ = 0.0; \
+#   double s_now_ = (currentTime); \
+#   if (s_lastDone_ > s_now_) \
+#     s_lastDone_ = s_now_; \
+#   if ((s_now_ - s_lastDone_) > (secs)) {        \
+#     code; \
+#     s_lastDone_ = s_now_; \
+#   }\
+# } else \
+#   (void)0
+# #endif
+# 
+# /// Executes code, only if secs are gone since last exec.
+# #ifndef DO_EVERY
+# #define DO_EVERY(secs, code) \
+#   DO_EVERY_TS(secs, pcl::getTime(), code)
+# #endif
+# 
+# }  // end namespace
+# /*@}*/
+###
+
+# time_trigger.h
+# namespace pcl
+# {
+#   /** \brief Timer class that invokes registered callback methods periodically.
+#     * \ingroup common
+#     */
+#   class PCL_EXPORTS TimeTrigger
+#   {
+#     public:
+#       typedef boost::function<void() > callback_type;
+# 
+#       /** \brief Timer class that calls a callback method periodically. Due to possible blocking calls, only one callback method can be registered per instance.
+#         * \param[in] interval_seconds interval in seconds
+#         * \param[in] callback callback to be invoked periodically
+#         */
+#       TimeTrigger (double interval_seconds, const callback_type& callback);
+# 
+#       /** \brief Timer class that calls a callback method periodically. Due to possible blocking calls, only one callback method can be registered per instance.
+#         * \param[in] interval_seconds interval in seconds
+#         */
+#       TimeTrigger (double interval_seconds = 1.0);
+# 
+#       /** \brief Destructor. */
+#       ~TimeTrigger ();
+# 
+#       /** \brief registeres a callback
+#         * \param[in] callback callback function to the list of callbacks. signature has to be boost::function<void()>
+#         * \return connection the connection, which can be used to disable/enable and remove callback from list
+#         */
+#       boost::signals2::connection registerCallback (const callback_type& callback);
+# 
+#       /** \brief Resets the timer interval
+#         * \param[in] interval_seconds interval in seconds
+#         */
+#       void 
+#       setInterval (double interval_seconds);
+# 
+#       /** \brief Start the Trigger. */
+#       void 
+#       start ();
+# 
+#       /** \brief Stop the Trigger. */
+#       void 
+#       stop ();
+#     private:
+#       void 
+#       thread_function ();
+#       boost::signals2::signal <void() > callbacks_;
+# 
+#       double interval_;
+# 
+#       bool quit_;
+#       bool running_;
+# 
+#       boost::thread timer_thread_;
+#       boost::condition_variable condition_;
+#       boost::mutex condition_mutex_;
+#   };
+# }
+###
+
+# transformation_from_correspondences.h
+# namespace pcl 
+# {
+#   /**
+#     * \brief Calculates a transformation based on corresponding 3D points
+#     * \author Bastian Steder
+#     * \ingroup common
+#     */
+#   class TransformationFromCorrespondences 
+#   {
+#      public:
+#         //-----CONSTRUCTOR&DESTRUCTOR-----
+#         /** Constructor - dimension gives the size of the vectors to work with. */
+#         TransformationFromCorrespondences () : 
+#           no_of_samples_ (0), accumulated_weight_ (0), 
+#           mean1_ (Eigen::Vector3f::Identity ()),
+#           mean2_ (Eigen::Vector3f::Identity ()),
+#           covariance_ (Eigen::Matrix<float, 3, 3>::Identity ())
+#         { reset (); }
+# 
+#         /** Destructor */
+#         ~TransformationFromCorrespondences () { };
+#         
+#         //-----METHODS-----
+#         /** Reset the object to work with a new data set */
+#         inline void 
+#         reset ();
+#         
+#         /** Get the summed up weight of all added vectors */
+#         inline float 
+#         getAccumulatedWeight () const { return accumulated_weight_;}
+#         
+#         /** Get the number of added vectors */
+#         inline unsigned int 
+#         getNoOfSamples () { return no_of_samples_;}
+#         
+#         /** Add a new sample */
+#         inline void 
+#         add (const Eigen::Vector3f& point, const Eigen::Vector3f& corresponding_point, float weight=1.0);
+#         
+#         /** Calculate the transformation that will best transform the points into their correspondences */
+#         inline Eigen::Affine3f 
+#         getTransformation ();
+#         
+#         //-----VARIABLES-----
+#         
+#   };
+# 
+# }  // END namespace
+###
+
+# transforms.h
+# namespace pcl
+# /** \brief Apply an affine transform defined by an Eigen Transform
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Affine3f &transform)
+# 
+# /** \brief Apply an affine transform defined by an Eigen Transform
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Affine3f &transform)
+# 
+# /** \brief Apply an affine transform defined by an Eigen Transform
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Affine3f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Affine3f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Affine3f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const pcl::PointIndices &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const pcl::PointIndices &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Affine3f &transform)
+# 
+# /** \brief Apply a rigid transform defined by a 4x4 matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform a rigid transformation 
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix4f &transform)
+# 
+# /** \brief Apply a rigid transform defined by a 4x4 matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform a rigid transformation 
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix4f &transform)
+# 
+# /** \brief Apply a rigid transform defined by a 4x4 matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform a rigid transformation 
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix4f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix4f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix4f &transform)
+###
+
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, const pcl::PointIndices &indices, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 4, 4> &transform)
+###
+
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, const pcl::PointIndices &indices, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix4f &transform)
+###
+
+# /** \brief Apply a rigid transform defined by a 3D offset and a quaternion
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] offset the translation component of the rigid transformation
+#   * \param[in] rotation the rotation component of the rigid transformation
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 3, 1> &offset, const Eigen::Quaternion<Scalar> &rotation);
+###
+
+# template <typename PointT> inline void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Vector3f &offset, const Eigen::Quaternionf &rotation)
+###
+
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] offset the translation component of the rigid transformation
+#   * \param[in] rotation the rotation component of the rigid transformation
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 3, 1> &offset, const Eigen::Quaternion<Scalar> &rotation);
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Vector3f &offset, const Eigen::Quaternionf &rotation)
+###
+
+# /** \brief Transform a point with members x,y,z
+#   * \param[in] point the point to transform
+#   * \param[out] transform the transformation to apply
+#   * \return the transformed point
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline PointT
+# transformPoint (const PointT &point, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+###
+
+# template <typename PointT> inline PointT transformPoint (const PointT &point, const Eigen::Affine3f &transform)
+###
+
+# /** \brief Calculates the principal (PCA-based) alignment of the point cloud
+#   * \param[in] cloud the input point cloud
+#   * \param[out] transform the resultant transform
+#   * \return the ratio lambda1/lambda2 or lambda2/lambda3, whatever is closer to 1.
+#   * \note If the return value is close to one then the transformation might be not unique -> two principal directions have
+#   * almost same variance (extend)
+#   */
+# template <typename PointT, typename Scalar> inline double
+# getPrincipalTransformation (const pcl::PointCloud<PointT> &cloud, Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> inline double getPrincipalTransformation (const pcl::PointCloud<PointT> &cloud, Eigen::Affine3f &transform)
+###
+
+# utils.h
+# namespace pcl
+# namespace utils
+# /** \brief Check if val1 and val2 are equals to an epsilon extent
+#   * \param[in] val1 first number to check
+#   * \param[in] val2 second number to check
+#   * \param[in] eps epsilon
+#   * \return true if val1 is equal to val2, false otherwise.
+#   */
+# template<typename T> bool equal (T val1, T val2, T eps = std::numeric_limits<T>::min ())
+###
+
+# vector_average.h
+# namespace pcl 
+# /** \brief Calculates the weighted average and the covariance matrix
+#   *
+#   * A class to calculate the weighted average and the covariance matrix of a set of vectors with given weights.
+#   * The original data is not saved. Mean and covariance are calculated iteratively.
+#   * \author Bastian Steder
+#   * \ingroup common
+#   */
+# template <typename real, int dimension>
+# class VectorAverage 
+#      public:
+#         //-----CONSTRUCTOR&DESTRUCTOR-----
+#         /** Constructor - dimension gives the size of the vectors to work with. */
+#         VectorAverage ();
+#         /** Destructor */
+#         ~VectorAverage () {}
+#         
+#         //-----METHODS-----
+#         /** Reset the object to work with a new data set */
+#         inline void 
+#         reset ();
+#         
+#         /** Get the mean of the added vectors */
+#         inline const
+#         Eigen::Matrix<real, dimension, 1>& getMean () const { return mean_;}
+#         
+#         /** Get the covariance matrix of the added vectors */
+#         inline const
+#         Eigen::Matrix<real, dimension, dimension>& getCovariance () const { return covariance_;}
+#         
+#         /** Get the summed up weight of all added vectors */
+#         inline real
+#         getAccumulatedWeight () const { return accumulatedWeight_;}
+#         
+#         /** Get the number of added vectors */
+#         inline unsigned int
+#         getNoOfSamples () { return noOfSamples_;}
+#         
+#         /** Add a new sample */
+#         inline void add (const Eigen::Matrix<real, dimension, 1>& sample, real weight=1.0);
+# 
+#         /** Do Principal component analysis */
+#         inline void
+#         doPCA (Eigen::Matrix<real, dimension, 1>& eigen_values, Eigen::Matrix<real, dimension, 1>& eigen_vector1,
+#                Eigen::Matrix<real, dimension, 1>& eigen_vector2, Eigen::Matrix<real, dimension, 1>& eigen_vector3) const;
+#         
+#         /** Do Principal component analysis */
+#         inline void doPCA (Eigen::Matrix<real, dimension, 1>& eigen_values) const;
+#         
+#         /** Get the eigenvector corresponding to the smallest eigenvalue */
+#         inline void getEigenVector1 (Eigen::Matrix<real, dimension, 1>& eigen_vector1) const;
+#         
+#         //-----VARIABLES-----
+#   };
+# 
+#   typedef VectorAverage<float, 2> VectorAverage2f;
+#   typedef VectorAverage<float, 3> VectorAverage3f;
+#   typedef VectorAverage<float, 4> VectorAverage4f;
+# }  // END namespace
+###
+
+
diff --git a/pcl/pcl_common_172.pxd b/pcl/pcl_common_172.pxd
new file mode 100644
index 0000000..0e4f6e9
--- /dev/null
+++ b/pcl/pcl_common_172.pxd
@@ -0,0 +1,5331 @@
+# -*- coding: utf-8 -*-
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport numpy as cnp
+
+cimport cython
+
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+
+cimport eigen as eigen3
+
+from boost_shared_ptr cimport shared_ptr
+
+
+# common/angles.h
+# namespace pcl
+cdef extern from "pcl/common/angles.h" namespace "pcl":
+    # brief Convert an angle from radians to degrees
+    # param alpha the input angle (in radians)
+    # ingroup common
+    # inline float rad2deg (float alpha);
+    cdef float rad2deg (float alpha)
+    
+    # brief Convert an angle from degrees to radians
+    # param alpha the input angle (in degrees)
+    # ingroup common
+    # inline float deg2rad (float alpha);
+    cdef float deg2rad (float alpha)
+    
+    # brief Convert an angle from radians to degrees
+    # param alpha the input angle (in radians)
+    # ingroup common
+    # inline double rad2deg (double alpha);
+    cdef double deg2rad (double alpha)
+    
+    # brief Convert an angle from degrees to radians
+    # param alpha the input angle (in degrees)
+    # ingroup common
+    # inline double deg2rad (double alpha);
+    cdef double deg2rad (double alpha)
+    
+    # brief Normalize an angle to (-PI, PI]
+    # param alpha the input angle (in radians)
+    # ingroup common
+    # inline float normAngle (float alpha);
+    cdef float normAngle (float alpha)
+
+
+###
+
+# bivariate_polynomial.h
+# namespace pcl 
+# cdef extern from "pcl/common/bivariate_polynomial.h" namespace "pcl":
+#   # /** \brief This represents a bivariate polynomial and provides some functionality for it
+#   #   * \author Bastian Steder 
+#   #   * \ingroup common
+#   #   */
+#   template<typename real> class BivariatePolynomialT 
+# cdef extern from "pcl/common/bivariate_polynomial.h" namespace "pcl":
+#     class BivariatePolynomialT[real]
+#         BivariatePolynomialT()
+#         # public:
+#         # //-----CONSTRUCTOR&DESTRUCTOR-----
+#         # /** Constructor */
+#         # BivariatePolynomialT (int new_degree=0);
+#         # /** Copy constructor */
+#         # BivariatePolynomialT (const BivariatePolynomialT& other);
+#         # /** Destructor */
+#         # ~BivariatePolynomialT ();
+#         
+#         # //-----OPERATORS-----
+#         # /** = operator */
+#         # BivariatePolynomialT& operator= (const BivariatePolynomialT& other) { deepCopy (other); return *this;}
+#         
+#         # //-----METHODS-----
+#         # /** Initialize members to default values */
+#         # void setDegree (int new_degree);
+#         void setDegree (int new_degree)
+#         
+#         # /** How many parametes has a bivariate polynomial with this degree */
+#         # unsigned int getNoOfParameters () const { return getNoOfParametersFromDegree (degree);}
+#         int getNoOfParameters ()
+#         
+#         # /** Calculate the value of the polynomial at the given point */
+#         # real getValue (real x, real y) const;  
+#         # real getValue (real x, real y)
+#         
+#         # /** Calculate the gradient of this polynomial
+#         #  *  If forceRecalc is false, it will do nothing when the gradient already exists */
+#         # void calculateGradient (bool forceRecalc=false);
+#         void calculateGradient (bool forceRecalc)
+#         
+#         # /** Calculate the value of the gradient at the given point */
+#         # void getValueOfGradient (real x, real y, real& gradX, real& gradY);
+#         # void getValueOfGradient (real x, real y, real& gradX, real& gradY);
+#         
+#         # /** Returns critical points of the polynomial. type can be 0=maximum, 1=minimum, or 2=saddle point
+#         #  *  !!Currently only implemented for degree 2!! */
+#         # void findCriticalPoints (std::vector<real>& x_values, std::vector<real>& y_values, std::vector<int>& types) const;
+#         
+#         # /** write as binary to a stream */
+#         # void writeBinary (std::ostream& os) const;
+#         
+#         # /** write as binary into a file */
+#         # void writeBinary (const char* filename) const;
+#         
+#         # /** read binary from a stream */
+#         # void readBinary (std::istream& os);
+#         
+#         # /** read binary from a file */
+#         # void readBinary (const char* filename);
+#         
+#         # /** How many parametes has a bivariate polynomial of the given degree */
+#         # static unsigned int getNoOfParametersFromDegree (int n) { return ((n+2)* (n+1))/2;}
+#         
+#     # template<typename real> std::ostream& operator<< (std::ostream& os, const BivariatePolynomialT<real>& p);
+#     # typedef BivariatePolynomialT<double> BivariatePolynomiald;
+#     # typedef BivariatePolynomialT<float>  BivariatePolynomial;
+
+
+###
+
+# boost.h
+# // Marking all Boost headers as system headers to remove warnings
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# \brief Compute the 3D (X-Y-Z) centroid of a set of points and return it as a 3D vector.
+# \param[in] cloud_iterator an iterator over the input point cloud
+# \param[out] centroid the output centroid
+# \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+# \note if return value is 0, the centroid is not changed, thus not valid.
+#  The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+# \ingroup common
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Matrix<Scalar, 4, 1> &centroid);
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#     unsigned int compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (ConstCloudIterator<PointT> &cloud_iterator, Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3D (X-Y-Z) centroid of a set of points and return it as a 3D vector.
+#   * \param[in] cloud the input point cloud
+#   * \param[out] centroid the output centroid
+#   * \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the centroid is not changed, thus not valid.
+#   * The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, Eigen::Vector4f &centroid)
+###
+
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, Eigen::Vector4d &centroid)
+###
+
+# /** \brief Compute the 3D (X-Y-Z) centroid of a set of points using their indices and
+#   * return it as a 3D vector.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[out] centroid the output centroid
+#   * \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the centroid is not changed, thus not valid.
+#   * The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, Eigen::Vector4d &centroid)
+###
+
+# /** \brief Compute the 3D (X-Y-Z) centroid of a set of points using their indices and
+#   * return it as a 3D vector.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[out] centroid the output centroid
+#   * \return number of valid point used to determine the centroid. In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the centroid is not changed, thus not valid.
+#   * The last compononent of the vector is set to 1, this allow to transform the centroid vector with 4x4 matrices.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# compute3DCentroid (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3x3 covariance matrix of a given set of points.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Note: the covariance matrix is not normalized with the number of
+#   * points. For a normalized covariance, please use
+#   * computeNormalizedCovarianceMatrix.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \note if return value is 0, the covariance matrix is not changed, thus not valid.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud, const Eigen::Matrix<Scalar, 4, 1> &centroid, Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const Eigen::Vector4f &centroid,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const Eigen::Vector4d &centroid,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute normalized the 3x3 covariance matrix of a given set of points.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Normalized means that every entry has been divided by the number of points in the point cloud.
+#   * For small number of points, or if you want explicitely the sample-variance, use computeCovarianceMatrix
+#   * and scale the covariance matrix with 1 / (n-1), where n is the number of points used to calculate
+#   * the covariance matrix and is returned by the computeCovarianceMatrix function.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                                    Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const Eigen::Vector4f &centroid,
+#                                    Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const Eigen::Vector4d &centroid,
+#                                    Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3x3 covariance matrix of a given set of points using their indices.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Note: the covariance matrix is not normalized with the number of
+#   * points. For a normalized covariance, please use
+#   * computeNormalizedCovarianceMatrix.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          const Eigen::Vector4f &centroid,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          const Eigen::Vector4d &centroid,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the 3x3 covariance matrix of a given set of points using their indices.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Note: the covariance matrix is not normalized with the number of
+#   * points. For a normalized covariance, please use
+#   * computeNormalizedCovarianceMatrix.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          const Eigen::Vector4f &centroid,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          const Eigen::Vector4d &centroid,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix of a given set of points using
+#   * their indices.
+#   * The result is returned as a Eigen::Matrix3f.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, use computeCovarianceMatrix
+#   * and scale the covariance matrix with 1 / (n-1), where n is the number of points used to calculate
+#   * the covariance matrix and is returned by the computeCovarianceMatrix function.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const std::vector<int> &indices,
+#                                    const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                                    Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const std::vector<int> &indices,
+#                                    const Eigen::Vector4f &centroid,
+#                                    Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const std::vector<int> &indices,
+#                                    const Eigen::Vector4d &centroid,
+#                                    Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix of a given set of points using
+#   * their indices. The result is returned as a Eigen::Matrix3f.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, use computeCovarianceMatrix
+#   * and scale the covariance matrix with 1 / (n-1), where n is the number of points used to calculate
+#   * the covariance matrix and is returned by the computeCovarianceMatrix function.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices the point cloud indices that need to be used
+#   * \param[in] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const pcl::PointIndices &indices,
+#                                    const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                                    Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const pcl::PointIndices &indices,
+#                                    const Eigen::Vector4f &centroid,
+#                                    Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrixNormalized (const pcl::PointCloud<PointT> &cloud,
+#                                    const pcl::PointIndices &indices,
+#                                    const Eigen::Vector4d &centroid,
+#                                    Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix and the centroid of a given set of points in a single loop.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \param[out] centroid the centroid of the set of points in the cloud
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 Eigen::Matrix<Scalar, 3, 3> &covariance_matrix,
+#                                 Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 Eigen::Matrix3f &covariance_matrix,
+#                                 Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 Eigen::Matrix3d &covariance_matrix,
+#                                 Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix and the centroid of a given set of points in a single loop.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \param[out] centroid the centroid of the set of points in the cloud
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const std::vector<int> &indices,
+#                                 Eigen::Matrix<Scalar, 3, 3> &covariance_matrix,
+#                                 Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const std::vector<int> &indices,
+#                                 Eigen::Matrix3f &covariance_matrix,
+#                                 Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const std::vector<int> &indices,
+#                                 Eigen::Matrix3d &covariance_matrix,
+#                                 Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix and the centroid of a given set of points in a single loop.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] centroid the centroid of the set of points in the cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const pcl::PointIndices &indices,
+#                                 Eigen::Matrix<Scalar, 3, 3> &covariance_matrix,
+#                                 Eigen::Matrix<Scalar, 4, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const pcl::PointIndices &indices,
+#                                 Eigen::Matrix3f &covariance_matrix,
+#                                 Eigen::Vector4f &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeMeanAndCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                                 const pcl::PointIndices &indices,
+#                                 Eigen::Matrix3d &covariance_matrix,
+#                                 Eigen::Vector4d &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix for a already demeaned point cloud.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix for a already demeaned point cloud.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const std::vector<int> &indices,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Compute the normalized 3x3 covariance matrix for a already demeaned point cloud.
+#   * Normalized means that every entry has been divided by the number of entries in indices.
+#   * For small number of points, or if you want explicitely the sample-variance, scale the covariance matrix
+#   * with n / (n-1), where n is the number of points used to calculate the covariance matrix and is returned by this function.
+#   * \note This method is theoretically exact. However using float for internal calculations reduces the accuracy but increases the efficiency.
+#   * \param[in] cloud the input point cloud
+#   * \param[in] indices subset of points given by their indices
+#   * \param[out] covariance_matrix the resultant 3x3 covariance matrix
+#   * \return number of valid point used to determine the covariance matrix.
+#   * In case of dense point clouds, this is the same as the size of input cloud.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          Eigen::Matrix<Scalar, 3, 3> &covariance_matrix);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          Eigen::Matrix3f &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> inline unsigned int
+# computeCovarianceMatrix (const pcl::PointCloud<PointT> &cloud,
+#                          const pcl::PointIndices &indices,
+#                          Eigen::Matrix3d &covariance_matrix)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_iterator an iterator over the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] npts the number of samples guaranteed to be left in the input cloud, accessible by the iterator. If not given, it will be calculated.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out,
+#                   int npts = 0);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] centroid the centroid of the point cloud
+#   * \param cloud_out the resultant output point cloud
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned representation
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] centroid the centroid of the point cloud
+#   * \param cloud_out the resultant output point cloud
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const pcl::PointIndices& indices,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const pcl::PointIndices& indices,
+#                   const Eigen::Vector4f &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const pcl::PointIndices& indices,
+#                   const Eigen::Vector4d &centroid,
+#                   pcl::PointCloud<PointT> &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#   * representation as an Eigen matrix
+#   * \param[in] cloud_iterator an iterator over the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#   * an Eigen matrix (4 rows, N pts columns)
+#   * \param[in] npts the number of samples guaranteed to be left in the input cloud, accessible by the iterator. If not given, it will be calculated.
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out,
+#                   int npts = 0);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4f &centroid,
+#                   Eigen::MatrixXf &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (ConstCloudIterator<PointT> &cloud_iterator,
+#                   const Eigen::Vector4d &centroid,
+#                   Eigen::MatrixXd &cloud_out,
+#                   int npts = 0)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#   * representation as an Eigen matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#   * an Eigen matrix (4 rows, N pts columns)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Vector4f &centroid,
+#                   Eigen::MatrixXf &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# template <typename PointT> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const Eigen::Vector4d &centroid,
+#                   Eigen::MatrixXd &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+# /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#   * representation as an Eigen matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[in] centroid the centroid of the point cloud
+#   * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#   * an Eigen matrix (4 rows, N pts columns)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void
+# demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                   const std::vector<int> &indices,
+#                   const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                   Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const std::vector<int> &indices,
+#                     const Eigen::Vector4f &centroid,
+#                     Eigen::MatrixXf &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const std::vector<int> &indices,
+#                     const Eigen::Vector4d &centroid,
+#                     Eigen::MatrixXd &cloud_out)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief Subtract a centroid from a point cloud and return the de-meaned
+#     * representation as an Eigen matrix
+#     * \param[in] cloud_in the input point cloud
+#     * \param[in] indices the set of point indices to use from the input point cloud
+#     * \param[in] centroid the centroid of the point cloud
+#     * \param[out] cloud_out the resultant output XYZ0 dimensions of \a cloud_in as
+#     * an Eigen matrix (4 rows, N pts columns)
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const pcl::PointIndices& indices,
+#                     const Eigen::Matrix<Scalar, 4, 1> &centroid,
+#                     Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> &cloud_out);
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const pcl::PointIndices& indices,
+#                     const Eigen::Vector4f &centroid,
+#                     Eigen::MatrixXf &cloud_out)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> void
+#   demeanPointCloud (const pcl::PointCloud<PointT> &cloud_in,
+#                     const pcl::PointIndices& indices,
+#                     const Eigen::Vector4d &centroid,
+#                     Eigen::MatrixXd &cloud_out)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief Helper functor structure for n-D centroid estimation. */
+#   template<typename PointT, typename Scalar>
+#   struct NdCentroidFunctor
+#   {
+#     typedef typename traits::POD<PointT>::type Pod;
+# 
+#     NdCentroidFunctor (const PointT &p, Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid)
+#       : f_idx_ (0),
+#         centroid_ (centroid),
+#         p_ (reinterpret_cast<const Pod&>(p)) { }
+# 
+#     template<typename Key> inline void operator() ()
+# 
+#   };
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief General, all purpose nD centroid estimation for a set of points using their
+#     * indices.
+#     * \param cloud the input point cloud
+#     * \param centroid the output centroid
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid);
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      Eigen::VectorXf &centroid)
+#   {
+#     return (computeNDCentroid<PointT, float> (cloud, centroid));
+#   }
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      Eigen::VectorXd &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief General, all purpose nD centroid estimation for a set of points using their
+#     * indices.
+#     * \param cloud the input point cloud
+#     * \param indices the point cloud indices that need to be used
+#     * \param centroid the output centroid
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud,
+#                      const std::vector<int> &indices, 
+#                      Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const std::vector<int> &indices, 
+#                      Eigen::VectorXf &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const std::vector<int> &indices, 
+#                      Eigen::VectorXd &centroid)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** \brief General, all purpose nD centroid estimation for a set of points using their
+#     * indices.
+#     * \param cloud the input point cloud
+#     * \param indices the point cloud indices that need to be used
+#     * \param centroid the output centroid
+#     * \ingroup common
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud,
+#                      const pcl::PointIndices &indices, 
+#                      Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &centroid);
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const pcl::PointIndices &indices, 
+#                      Eigen::VectorXf &centroid)
+### 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   template <typename PointT> inline void
+#   computeNDCentroid (const pcl::PointCloud<PointT> &cloud, 
+#                      const pcl::PointIndices &indices, 
+#                      Eigen::VectorXd &centroid)
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** A generic class that computes the centroid of points fed to it.
+#     * Here by "centroid" we denote not just the mean of 3D point coordinates,
+#     * but also mean of values in the other data fields. The general-purpose
+#     * \ref computeNDCentroid() function also implements this sort of
+#     * functionality, however it does it in a "dumb" way, i.e. regardless of the
+#     * semantics of the data inside a field it simply averages the values. In
+#     * certain cases (e.g. for \c x, \c y, \c z, \c intensity fields) this
+#     * behavior is reasonable, however in other cases (e.g. \c rgb, \c rgba,
+#     * \c label fields) this does not lead to meaningful results.
+#     * This class is capable of computing the centroid in a "smart" way, i.e.
+#     * taking into account the meaning of the data inside fields. Currently the
+#     * following fields are supported:
+#     * - XYZ (\c x, \c y, \c z)
+#     *   Separate average for each field.
+#     * - Normal (\c normal_x, \c normal_y, \c normal_z)
+#     *   Separate average for each field, and the resulting vector is normalized.
+#     * - Curvature (\c curvature)
+#     *   Average.
+#     * - RGB/RGBA (\c rgb or \c rgba)
+#     *   Separate average for R, G, B, and alpha channels.
+#     * - Intensity (\c intensity)
+#     *   Average.
+#     * - Label (\c label)
+#     *   Majority vote. If several labels have the same largest support then the
+#     *   smaller label wins.
+#     *
+#     * The template parameter defines the type of points that may be accumulated
+#     * with this class. This may be an arbitrary PCL point type, and centroid
+#     * computation will happen only for the fields that are present in it and are
+#     * supported.
+#     *
+#     * Current centroid may be retrieved at any time using get(). Note that the
+#     * function is templated on point type, so it is possible to fetch the
+#     * centroid into a point type that differs from the type of points that are
+#     * being accumulated. All the "extra" fields for which the centroid is not
+#     * being calculated will be left untouched.
+#     *
+#     * Example usage:
+#     *
+#     * \code
+#     * // Create and accumulate points
+#     * CentroidPoint<pcl::PointXYZ> centroid;
+#     * centroid.add (pcl::PointXYZ (1, 2, 3);
+#     * centroid.add (pcl::PointXYZ (5, 6, 7);
+#     * // Fetch centroid using `get()`
+#     * pcl::PointXYZ c1;
+#     * centroid.get (c1);
+#     * // The expected result is: c1.x == 3, c1.y == 4, c1.z == 5
+#     * // It is also okay to use `get()` with a different point type
+#     * pcl::PointXYZRGB c2;
+#     * centroid.get (c2);
+#     * // The expected result is: c2.x == 3, c2.y == 4, c2.z == 5,
+#     * // and c2.rgb is left untouched
+#     * \endcode
+#     *
+#     * \note Assumes that the points being inserted are valid.
+#     *
+#     * \note This class template can be successfully instantiated for *any*
+#     * PCL point type. Of course, each of the field averages is computed only if
+#     * the point type has the corresponding field.
+#     *
+#     * \ingroup common
+#     * \author Sergey Alexandrov */
+# template <typename PointT>
+# class CentroidPoint
+#       
+#       public:
+#       
+#       CentroidPoint ()
+#       : num_points_ (0)
+#       {
+#       }
+# 
+#       /** Add a new point to the centroid computation.
+#         *
+#         * In this function only the accumulators and point counter are updated,
+#         * actual centroid computation does not happen until get() is called. */
+#       void
+#       add (const PointT& point)
+#       {
+#         // Invoke add point on each accumulator
+#         boost::fusion::for_each (accumulators_, detail::AddPoint<PointT> (point));
+#         ++num_points_;
+#       }
+# 
+#       /** Retrieve the current centroid.
+#         *
+#         * Computation (division of accumulated values by the number of points
+#         * and normalization where applicable) happens here. The result is not
+#         * cached, so any subsequent call to this function will trigger
+#         * re-computation.
+#         *
+#         * If the number of accumulated points is zero, then the point will be
+#         * left untouched. */
+#       template <typename PointOutT> void
+#       get (PointOutT& point) const
+#       {
+#         if (num_points_ != 0)
+#         {
+#           // Filter accumulators so that only those that are compatible with
+#           // both PointT and requested point type remain
+#           typename pcl::detail::Accumulators<PointT, PointOutT>::type ca (accumulators_);
+#           // Invoke get point on each accumulator in filtered list
+#           boost::fusion::for_each (ca, detail::GetPoint<PointOutT> (point, num_points_));
+#         }
+#       }
+# 
+#       /** Get the total number of points that were added. */
+#       size_t getSize () const
+# 
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+# 
+# 
+#   };
+# 
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** Compute the centroid of a set of points and return it as a point.
+#     *
+#     * Implementation leverages \ref CentroidPoint class and therefore behaves
+#     * differently from \ref compute3DCentroid() and \ref computeNDCentroid().
+#     * See \ref CentroidPoint documentation for explanation.
+#     *
+#     * \param[in] cloud input point cloud
+#     * \param[out] centroid output centroid
+#     *
+#     * \return number of valid points used to determine the centroid (will be the
+#     * same as the size of the cloud if it is dense)
+#     *
+#     * \note If return value is \c 0, then the centroid is not changed, thus is
+#     * not valid.
+#     *
+#     * \ingroup common */
+#   template <typename PointInT, typename PointOutT> size_t
+#   computeCentroid (const pcl::PointCloud<PointInT>& cloud,
+#                    PointOutT& centroid);
+###
+
+# centroid.h
+# namespace pcl
+# cdef extern from "pcl/common/centroid.h" namespace "pcl":
+#   /** Compute the centroid of a set of points and return it as a point.
+#     * \param[in] cloud
+#     * \param[in] indices point cloud indices that need to be used
+#     * \param[out] centroid
+#     * This is an overloaded function provided for convenience. See the
+#     * documentation for computeCentroid().
+#     *
+#     * \ingroup common */
+#   template <typename PointInT, typename PointOutT> size_t
+#   computeCentroid (const pcl::PointCloud<PointInT>& cloud,
+#                    const std::vector<int>& indices,
+#                    PointOutT& centroid);
+# 
+###
+
+### end of centroid.h file ###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute the smallest angle between two vectors in the [ 0, PI ) interval in 3D.
+#   * \param v1 the first 3D vector (represented as a \a Eigen::Vector4f)
+#   * \param v2 the second 3D vector (represented as a \a Eigen::Vector4f)
+#   * \return the angle between v1 and v2
+#   * \ingroup common
+#   */
+# inline double getAngle3D (const Eigen::Vector4f &v1, const Eigen::Vector4f &v2);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute both the mean and the standard deviation of an array of values
+#   * \param values the array of values
+#   * \param mean the resultant mean of the distribution
+#   * \param stddev the resultant standard deviation of the distribution
+#   * \ingroup common
+#   */
+# inline void getMeanStd (const std::vector<float> &values, double &mean, double &stddev);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get a set of points residing in a box given its bounds
+#   * \param cloud the point cloud data message
+#   * \param min_pt the minimum bounds
+#   * \param max_pt the maximum bounds
+#   * \param indices the resultant set of point indices residing in the box
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getPointsInBox (const pcl::PointCloud<PointT> &cloud, Eigen::Vector4f &min_pt,
+#                 Eigen::Vector4f &max_pt, std::vector<int> &indices);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the point at maximum distance from a given point and a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param pivot_pt the point from where to compute the distance
+#   * \param max_pt the point in cloud that is the farthest point away from pivot_pt
+#   * \ingroup common
+#   */
+# template<typename PointT> inline void
+# getMaxDistance (const pcl::PointCloud<PointT> &cloud, const Eigen::Vector4f &pivot_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the point at maximum distance from a given point and a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param pivot_pt the point from where to compute the distance
+#   * \param indices the vector of point indices to use from \a cloud
+#   * \param max_pt the point in cloud that is the farthest point away from pivot_pt
+#   * \ingroup common
+#   */
+# template<typename PointT> inline void
+# getMaxDistance (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, 
+#                 const Eigen::Vector4f &pivot_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, PointT &min_pt, PointT &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, 
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param indices the vector of point indices to use from \a cloud
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, 
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions in a given pointcloud
+#   * \param cloud the point cloud data message
+#   * \param indices the vector of point indices to use from \a cloud
+#   * \param min_pt the resultant minimum bounds
+#   * \param max_pt the resultant maximum bounds
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax3D (const pcl::PointCloud<PointT> &cloud, const pcl::PointIndices &indices, 
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute the radius of a circumscribed circle for a triangle formed of three points pa, pb, and pc
+#   * \param pa the first point
+#   * \param pb the second point
+#   * \param pc the third point
+#   * \return the radius of the circumscribed circle
+#   * \ingroup common
+#   */
+# template <typename PointT> inline double 
+# getCircumcircleRadius (const PointT &pa, const PointT &pb, const PointT &pc);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on a point histogram
+#   * \param histogram the point representing a multi-dimensional histogram
+#   * \param len the length of the histogram
+#   * \param min_p the resultant minimum 
+#   * \param max_p the resultant maximum 
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void 
+# getMinMax (const PointT &histogram, int len, float &min_p, float &max_p);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Calculate the area of a polygon given a point cloud that defines the polygon 
+#     * \param polygon point cloud that contains those vertices that comprises the polygon. Vertices are stored in counterclockwise.
+#     * \return the polygon area 
+#     * \ingroup common
+#     */
+# template<typename PointT> inline float
+# calculatePolygonArea (const pcl::PointCloud<PointT> &polygon);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Get the minimum and maximum values on a point histogram
+#   * \param cloud the cloud containing multi-dimensional histograms
+#   * \param idx point index representing the histogram that we need to compute min/max for
+#   * \param field_name the field name containing the multi-dimensional histogram
+#   * \param min_p the resultant minimum 
+#   * \param max_p the resultant maximum 
+#   * \ingroup common
+#   */
+# PCL_EXPORTS void 
+# getMinMax (const pcl::PCLPointCloud2 &cloud, int idx, const std::string &field_name,
+#            float &min_p, float &max_p);
+###
+
+# common.h
+# namespace pcl
+# cdef extern from "pcl/common/common.h" namespace "pcl":
+# /** \brief Compute both the mean and the standard deviation of an array of values
+#   * \param values the array of values
+#   * \param mean the resultant mean of the distribution
+#   * \param stddev the resultant standard deviation of the distribution
+#   * \ingroup common
+#   */
+# PCL_EXPORTS void
+# getMeanStdDev (const std::vector<float> &values, double &mean, double &stddev);
+# 
+###
+
+# common_headers.h
+###
+
+# concatenate.h
+# // We're doing a lot of black magic with Boost here, so disable warnings in Maintainer mode, as we will never
+# // be able to fix them anyway
+# #ifdef BUILD_Maintainer
+# #  if defined __GNUC__
+# #    if __GNUC__ == 4 && __GNUC_MINOR__ > 3
+# #      pragma GCC diagnostic ignored "-Weffc++"
+# #      pragma GCC diagnostic ignored "-pedantic"
+# #    else
+# #      pragma GCC system_header 
+# #    endif
+# #  elif defined _MSC_VER
+# #    pragma warning(push, 1)
+# #  endif
+# #endif
+###
+
+# concatenate.h
+# namespace pcl
+# cdef extern from "pcl/common/concatenate.h" namespace "pcl":
+# /** \brief Helper functor structure for concatenate. 
+#   * \ingroup common
+#   */
+# template<typename PointInT, typename PointOutT>
+# struct NdConcatenateFunctor
+# {
+#   typedef typename traits::POD<PointInT>::type PodIn;
+#   typedef typename traits::POD<PointOutT>::type PodOut;
+#   
+#   NdConcatenateFunctor (const PointInT &p1, PointOutT &p2)
+#     : p1_ (reinterpret_cast<const PodIn&> (p1))
+#     , p2_ (reinterpret_cast<PodOut&> (p2)) { }
+#      template<typename Key> inline void 
+#   operator () ()
+#   {
+#     // This sucks without Fusion :(
+#     //boost::fusion::at_key<Key> (p2_) = boost::fusion::at_key<Key> (p1_);
+#     typedef typename pcl::traits::datatype<PointInT, Key>::type InT;
+#     typedef typename pcl::traits::datatype<PointOutT, Key>::type OutT;
+#     // Note: don't currently support different types for the same field (e.g. converting double to float)
+#     BOOST_MPL_ASSERT_MSG ((boost::is_same<InT, OutT>::value),
+#                           POINT_IN_AND_POINT_OUT_HAVE_DIFFERENT_TYPES_FOR_FIELD,
+#                           (Key, PointInT&, InT, PointOutT&, OutT));
+#     memcpy (reinterpret_cast<uint8_t*>(&p2_) + pcl::traits::offset<PointOutT, Key>::value,
+#             reinterpret_cast<const uint8_t*>(&p1_) + pcl::traits::offset<PointInT, Key>::value,
+#             sizeof (InT));
+#   }
+# }
+###
+
+# concatenate.h
+# namespace pcl
+# cdef extern from "pcl/common/concatenate.h" namespace "pcl":
+#ifdef BUILD_Maintainer
+#  if defined __GNUC__
+#    if __GNUC__ == 4 && __GNUC_MINOR__ > 3
+#      pragma GCC diagnostic warning "-Weffc++"
+#      pragma GCC diagnostic warning "-pedantic"
+#    endif
+#  elif defined _MSC_VER
+#    pragma warning(pop)
+#  endif
+#endif
+###
+
+
+# conversions.h
+# namespace pcl
+# namespace detail
+# cdef extern from "pcl/common/conversions.h" namespace "pcl::detail":
+# // For converting template point cloud to message.
+# template<typename PointT>
+# struct FieldAdder
+# {
+#     FieldAdder (std::vector<pcl::PCLPointField>& fields) : fields_ (fields) {};
+# 
+#       template<typename U> void operator() ()
+#       {
+#         pcl::PCLPointField f;
+#         f.name = traits::name<PointT, U>::value;
+#         f.offset = traits::offset<PointT, U>::value;
+#         f.datatype = traits::datatype<PointT, U>::value;
+#         f.count = traits::datatype<PointT, U>::size;
+#         fields_.push_back (f);
+#       }
+# 
+#       std::vector<pcl::PCLPointField>& fields_;
+#     };
+# 
+#     // For converting message to template point cloud.
+#     template<typename PointT>
+#     struct FieldMapper
+#     {
+#       FieldMapper (const std::vector<pcl::PCLPointField>& fields,
+#                    std::vector<FieldMapping>& map)
+#         : fields_ (fields), map_ (map)
+#       {
+#       }
+# 
+#       template<typename Tag> void
+#       operator () ()
+#       {
+#         BOOST_FOREACH (const pcl::PCLPointField& field, fields_)
+#         {
+#           if (FieldMatches<PointT, Tag>()(field))
+#           {
+#             FieldMapping mapping;
+#             mapping.serialized_offset = field.offset;
+#             mapping.struct_offset = traits::offset<PointT, Tag>::value;
+#             mapping.size = sizeof (typename traits::datatype<PointT, Tag>::type);
+#             map_.push_back (mapping);
+#             return;
+#           }
+#         }
+#         // Disable thrown exception per #595: http://dev.pointclouds.org/issues/595
+#         PCL_WARN ("Failed to find match for field '%s'.\n", traits::name<PointT, Tag>::value);
+#         //throw pcl::InvalidConversionException (ss.str ());
+#       }
+# 
+#       const std::vector<pcl::PCLPointField>& fields_;
+#       std::vector<FieldMapping>& map_;
+#     };
+# 
+#     inline bool fieldOrdering (const FieldMapping& a, const FieldMapping& b)
+# 
+# } //namespace detail
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# template<typename PointT> void createMapping (const std::vector<pcl::PCLPointField>& msg_fields, MsgFieldMap& field_map)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.
+#   * \param[in] msg the PCLPointCloud2 binary blob
+#   * \param[out] cloud the resultant pcl::PointCloud<T>
+#   * \param[in] field_map a MsgFieldMap object
+#   * \note Use fromPCLPointCloud2 (PCLPointCloud2, PointCloud<T>) directly or create you
+#   * own MsgFieldMap using:
+#   * \code
+#   * MsgFieldMap field_map;
+#   * createMapping<PointT> (msg.fields, field_map);
+#   * \endcode
+#   */
+# template <typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object.
+#   * \param[in] msg the PCLPointCloud2 binary blob
+#   * \param[out] cloud the resultant pcl::PointCloud<T>
+#   */
+# template<typename PointT> void fromPCLPointCloud2 (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Convert a pcl::PointCloud<T> object to a PCLPointCloud2 binary data blob.
+#   * \param[in] cloud the input pcl::PointCloud<T>
+#   * \param[out] msg the resultant PCLPointCloud2 binary blob
+#   */
+# template<typename PointT> void toPCLPointCloud2 (const pcl::PointCloud<PointT>& cloud, pcl::PCLPointCloud2& msg)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+#  /** \brief Copy the RGB fields of a PointCloud into pcl::PCLImage format
+#    * \param[in] cloud the point cloud message
+#    * \param[out] msg the resultant pcl::PCLImage
+#    * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>
+#    * \note will throw std::runtime_error if there is a problem
+#    */
+# template<typename CloudT> void toPCLPointCloud2 (const CloudT& cloud, pcl::PCLImage& msg)
+###
+
+# conversions.h
+# namespace pcl
+# cdef extern from "pcl/common/conversions.h" namespace "pcl":
+# /** \brief Copy the RGB fields of a PCLPointCloud2 msg into pcl::PCLImage format
+#   * \param cloud the point cloud message
+#   * \param msg the resultant pcl::PCLImage
+#   * will throw std::runtime_error if there is a problem
+#   */
+# inline void toPCLPointCloud2 (const pcl::PCLPointCloud2& cloud, pcl::PCLImage& msg)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Get the shortest 3D segment between two 3D lines
+#   * \param line_a the coefficients of the first line (point, direction)
+#   * \param line_b the coefficients of the second line (point, direction)
+#   * \param pt1_seg the first point on the line segment
+#   * \param pt2_seg the second point on the line segment
+#   * \ingroup common
+#   */
+# PCL_EXPORTS void lineToLineSegment (const Eigen::VectorXf &line_a, const Eigen::VectorXf &line_b, Eigen::Vector4f &pt1_seg, Eigen::Vector4f &pt2_seg);
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Get the square distance from a point to a line (represented by a point and a direction)
+#   * \param pt a point
+#   * \param line_pt a point on the line (make sure that line_pt[3] = 0 as there are no internal checks!)
+#   * \param line_dir the line direction
+#   * \ingroup common
+#   */
+# double inline sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Get the square distance from a point to a line (represented by a point and a direction)
+#   * \note This one is useful if one has to compute many distances to a fixed line, so the vector length can be pre-computed
+#   * \param pt a point
+#   * \param line_pt a point on the line (make sure that line_pt[3] = 0 as there are no internal checks!)
+#   * \param line_dir the line direction
+#   * \param sqr_length the squared norm of the line direction
+#   * \ingroup common
+#   */
+# double inline sqrPointToLineDistance (const Eigen::Vector4f &pt, const Eigen::Vector4f &line_pt, const Eigen::Vector4f &line_dir, const double sqr_length)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Obtain the maximum segment in a given set of points, and return the minimum and maximum points.
+#   * \param[in] cloud the point cloud dataset
+#   * \param[out] pmin the coordinates of the "minimum" point in \a cloud (one end of the segment)
+#   * \param[out] pmax the coordinates of the "maximum" point in \a cloud (the other end of the segment)
+#   * \return the length of segment length
+#   * \ingroup common
+#   */
+# template <typename PointT> double inline getMaxSegment (const pcl::PointCloud<PointT> &cloud, PointT &pmin, PointT &pmax)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Obtain the maximum segment in a given set of points, and return the minimum and maximum points.
+#   * \param[in] cloud the point cloud dataset
+#   * \param[in] indices a set of point indices to use from \a cloud
+#   * \param[out] pmin the coordinates of the "minimum" point in \a cloud (one end of the segment)
+#   * \param[out] pmax the coordinates of the "maximum" point in \a cloud (the other end of the segment)
+#   * \return the length of segment length
+#   * \ingroup common
+#   */
+# template <typename PointT> double inline getMaxSegment (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices, PointT &pmin, PointT &pmax)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Calculate the squared euclidean distance between the two given points.
+#   * \param[in] p1 the first point
+#   * \param[in] p2 the second point
+#   */
+# template<typename PointType1, typename PointType2> inline float
+# squaredEuclideanDistance (const PointType1& p1, const PointType2& p2)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Calculate the squared euclidean distance between the two given points.
+#   * \param[in] p1 the first point
+#   * \param[in] p2 the second point
+#   */
+# template<> inline float
+# squaredEuclideanDistance (const PointXY& p1, const PointXY& p2)
+###
+
+# distances.h
+# namespace pcl
+# cdef extern from "pcl/common/distances.h" namespace "pcl":
+# /** \brief Calculate the euclidean distance between the two given points.
+#   * \param[in] p1 the first point
+#   * \param[in] p2 the second point
+#   */
+# template<typename PointType1, typename PointType2> inline float
+# euclideanDistance (const PointType1& p1, const PointType2& p2)
+###
+
+# eigen.h
+# #ifndef NOMINMAX
+# #define NOMINMAX
+# #endif
+# 
+# #if defined __GNUC__
+# #  pragma GCC system_header
+# #elif defined __SUNPRO_CC
+# #  pragma disable_warn
+# #endif
+# 
+# #include <cmath>
+# #include <pcl/ModelCoefficients.h>
+# 
+# #include <Eigen/StdVector>
+# #include <Eigen/Core>
+# #include <Eigen/Eigenvalues>
+# #include <Eigen/Geometry>
+# #include <Eigen/SVD>
+# #include <Eigen/LU>
+# #include <Eigen/Dense>
+# #include <Eigen/Eigenvalues>
+# 
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Compute the roots of a quadratic polynom x^2 + b*x + c = 0
+#   * \param[in] b linear parameter
+#   * \param[in] c constant parameter
+#   * \param[out] roots solutions of x^2 + b*x + c = 0
+#   */
+# template <typename Scalar, typename Roots> void computeRoots2 (const Scalar &b, const Scalar &c, Roots &roots);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief computes the roots of the characteristic polynomial of the input matrix m, which are the eigenvalues
+#   * \param[in] m input matrix
+#   * \param[out] roots roots of the characteristic polynomial of the input matrix m, which are the eigenvalues
+#   */
+# template <typename Matrix, typename Roots> void computeRoots (const Matrix &m, Roots &roots);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determine the smallest eigenvalue and its corresponding eigenvector
+#   * \param[in] mat input matrix that needs to be symmetric and positive semi definite
+#   * \param[out] eigenvalue the smallest eigenvalue of the input matrix
+#   * \param[out] eigenvector the corresponding eigenvector to the smallest eigenvalue of the input matrix
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void
+# eigen22 (const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determine the smallest eigenvalue and its corresponding eigenvector
+#   * \param[in] mat input matrix that needs to be symmetric and positive semi definite
+#   * \param[out] eigenvectors the corresponding eigenvector to the smallest eigenvalue of the input matrix
+#   * \param[out] eigenvalues the smallest eigenvalue of the input matrix
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen22 (const Matrix &mat, Matrix &eigenvectors, Vector &eigenvalues);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the corresponding eigenvector to the given eigenvalue of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[in] eigenvalue the eigenvalue which corresponding eigenvector is to be computed
+#   * \param[out] eigenvector the corresponding eigenvector for the input eigenvalue
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void computeCorrespondingEigenVector (const Matrix &mat, const typename Matrix::Scalar &eigenvalue, Vector &eigenvector);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the eigenvector and eigenvalue of the smallest eigenvalue of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[out] eigenvalue smallest eigenvalue of the input matrix
+#   * \param[out] eigenvector the corresponding eigenvector for the input eigenvalue
+#   * \note if the smallest eigenvalue is not unique, this function may return any eigenvector that is consistent to the eigenvalue.
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen33 (const Matrix &mat, typename Matrix::Scalar &eigenvalue, Vector &eigenvector);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the eigenvalues of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[out] evals resulting eigenvalues in ascending order
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen33 (const Matrix &mat, Vector &evals);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief determines the eigenvalues and corresponding eigenvectors of the symmetric positive semi definite input matrix
+#   * \param[in] mat symmetric positive semi definite input matrix
+#   * \param[out] evecs resulting eigenvalues in ascending order
+#   * \param[out] evals corresponding eigenvectors in correct order according to eigenvalues
+#   * \ingroup common
+#   */
+# template <typename Matrix, typename Vector> void eigen33 (const Matrix &mat, Matrix &evecs, Vector &evals);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the inverse of a 2x2 matrix
+#   * \param[in] matrix matrix to be inverted
+#   * \param[out] inverse the resultant inverted matrix
+#   * \note only the upper triangular part is taken into account => non symmetric matrices will give wrong results
+#   * \return determinant of the original matrix => if 0 no inverse exists => result is invalid
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar invert2x2 (const Matrix &matrix, Matrix &inverse);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the inverse of a 3x3 symmetric matrix.
+#   * \param[in] matrix matrix to be inverted
+#   * \param[out] inverse the resultant inverted matrix
+#   * \note only the upper triangular part is taken into account => non symmetric matrices will give wrong results
+#   * \return determinant of the original matrix => if 0 no inverse exists => result is invalid
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar invert3x3SymMatrix (const Matrix &matrix, Matrix &inverse);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the inverse of a general 3x3 matrix.
+#   * \param[in] matrix matrix to be inverted
+#   * \param[out] inverse the resultant inverted matrix
+#   * \return determinant of the original matrix => if 0 no inverse exists => result is invalid
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar
+# invert3x3Matrix (const Matrix &matrix, Matrix &inverse);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Calculate the determinant of a 3x3 matrix.
+#   * \param[in] matrix matrix
+#   * \return determinant of the matrix
+#   * \ingroup common
+#   */
+# template <typename Matrix> typename Matrix::Scalar determinant3x3Matrix (const Matrix &matrix);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] z_axis the z-axis
+#   * \param[in] y_direction the y direction
+#   * \param[out] transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline void getTransFromUnitVectorsZY (const Eigen::Vector3f& z_axis, const Eigen::Vector3f& y_direction, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] z_axis the z-axis
+#   * \param[in] y_direction the y direction
+#   * \return the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransFromUnitVectorsZY (const Eigen::Vector3f& z_axis, const Eigen::Vector3f& y_direction);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a x_axis into (1,0,0) and \a y_direction into a vector
+#   * with z=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] x_axis the x-axis
+#   * \param[in] y_direction the y direction
+#   * \param[out] transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline void getTransFromUnitVectorsXY (const Eigen::Vector3f& x_axis, const Eigen::Vector3f& y_direction, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a x_axis into (1,0,0) and \a y_direction into a vector
+#   * with z=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] x_axis the x-axis
+#   * \param[in] y_direction the y direction
+#   * \return the resulting 3D rotation
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransFromUnitVectorsXY (const Eigen::Vector3f& x_axis, const Eigen::Vector3f& y_direction);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] y_direction the y direction
+#   * \param[in] z_axis the z-axis
+#   * \param[out] transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline void getTransformationFromTwoUnitVectors (const Eigen::Vector3f& y_direction, const Eigen::Vector3f& z_axis, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the unique 3D rotation that will rotate \a z_axis into (0,0,1) and \a y_direction into a vector
+#   * with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] y_direction the y direction
+#   * \param[in] z_axis the z-axis
+#   * \return transformation the resultant 3D rotation
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransformationFromTwoUnitVectors (const Eigen::Vector3f& y_direction, const Eigen::Vector3f& z_axis);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Get the transformation that will translate \a orign to (0,0,0) and rotate \a z_axis into (0,0,1)
+#   * and \a y_direction into a vector with x=0 (or into (0,1,0) should \a y_direction be orthogonal to \a z_axis)
+#   * \param[in] y_direction the y direction
+#   * \param[in] z_axis the z-axis
+#   * \param[in] origin the origin
+#   * \param[in] transformation the resultant transformation matrix
+#   * \ingroup common
+#   */
+# inline void
+# getTransformationFromTwoUnitVectorsAndOrigin (const Eigen::Vector3f& y_direction, const Eigen::Vector3f& z_axis, const Eigen::Vector3f& origin, Eigen::Affine3f& transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Extract the Euler angles (XYZ-convention) from the given transformation
+#   * \param[in] t the input transformation matrix
+#   * \param[in] roll the resulting roll angle
+#   * \param[in] pitch the resulting pitch angle
+#   * \param[in] yaw the resulting yaw angle
+#   * \ingroup common
+#   */
+# template <typename Scalar> void
+# getEulerAngles (const Eigen::Transform<Scalar, 3, Eigen::Affine> &t, Scalar &roll, Scalar &pitch, Scalar &yaw);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void getEulerAngles (const Eigen::Affine3f &t, float &roll, float &pitch, float &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# getEulerAngles (const Eigen::Affine3d &t, double &roll, double &pitch, double &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** Extract x,y,z and the Euler angles (XYZ-convention) from the given transformation
+#   * \param[in] t the input transformation matrix
+#   * \param[out] x the resulting x translation
+#   * \param[out] y the resulting y translation
+#   * \param[out] z the resulting z translation
+#   * \param[out] roll the resulting roll angle
+#   * \param[out] pitch the resulting pitch angle
+#   * \param[out] yaw the resulting yaw angle
+#   * \ingroup common
+#   */
+# template <typename Scalar> void
+# getTranslationAndEulerAngles (const Eigen::Transform<Scalar, 3, Eigen::Affine> &t, Scalar &x, Scalar &y, Scalar &z, Scalar &roll, Scalar &pitch, Scalar &yaw);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# getTranslationAndEulerAngles (const Eigen::Affine3f &t, float &x, float &y, float &z, float &roll, float &pitch, float &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# getTranslationAndEulerAngles (const Eigen::Affine3d &t, double &x, double &y, double &z, double &roll, double &pitch, double &yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Create a transformation from the given translation and Euler angles (XYZ-convention)
+#   * \param[in] x the input x translation
+#   * \param[in] y the input y translation
+#   * \param[in] z the input z translation
+#   * \param[in] roll the input roll angle
+#   * \param[in] pitch the input pitch angle
+#   * \param[in] yaw the input yaw angle
+#   * \param[out] t the resulting transformation matrix
+#   * \ingroup common
+#   */
+# template <typename Scalar> void getTransformation (Scalar x, Scalar y, Scalar z, Scalar roll, Scalar pitch, Scalar yaw,  Eigen::Transform<Scalar, 3, Eigen::Affine> &t);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void getTransformation (float x, float y, float z, float roll, float pitch, float yaw, Eigen::Affine3f &t)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void getTransformation (double x, double y, double z, double roll, double pitch, double yaw, Eigen::Affine3d &t)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Create a transformation from the given translation and Euler angles (XYZ-convention)
+#   * \param[in] x the input x translation
+#   * \param[in] y the input y translation
+#   * \param[in] z the input z translation
+#   * \param[in] roll the input roll angle
+#   * \param[in] pitch the input pitch angle
+#   * \param[in] yaw the input yaw angle
+#   * \return the resulting transformation matrix
+#   * \ingroup common
+#   */
+# inline Eigen::Affine3f getTransformation (float x, float y, float z, float roll, float pitch, float yaw)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Write a matrix to an output stream
+#   * \param[in] matrix the matrix to output
+#   * \param[out] file the output stream
+#   * \ingroup common
+#   */
+# template <typename Derived> void saveBinary (const Eigen::MatrixBase<Derived>& matrix, std::ostream& file);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Read a matrix from an input stream
+#   * \param[out] matrix the resulting matrix, read from the input stream
+#   * \param[in,out] file the input stream
+#   * \ingroup common
+#   */
+# template <typename Derived> void
+# loadBinary (Eigen::MatrixBase<Derived> const& matrix, std::istream& file);
+###
+
+# // PCL_EIGEN_SIZE_MIN_PREFER_DYNAMIC gives the min between compile-time sizes. 0 has absolute priority, followed by 1,
+# // followed by Dynamic, followed by other finite values. The reason for giving Dynamic the priority over
+# // finite values is that min(3, Dynamic) should be Dynamic, since that could be anything between 0 and 3.
+# #define PCL_EIGEN_SIZE_MIN_PREFER_DYNAMIC(a,b) ((int (a) == 0 || int (b) == 0) ? 0 \
+#                            : (int (a) == 1 || int (b) == 1) ? 1 \
+#                            : (int (a) == Eigen::Dynamic || int (b) == Eigen::Dynamic) ? Eigen::Dynamic \
+#                            : (int (a) <= int (b)) ? int (a) : int (b))
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Returns the transformation between two point sets. 
+#   * The algorithm is based on: 
+#   * "Least-squares estimation of transformation parameters between two point patterns",
+#   * Shinji Umeyama, PAMI 1991, DOI: 10.1109/34.88573
+#   *
+#   * It estimates parameters \f$ c, \mathbf{R}, \f$ and \f$ \mathbf{t} \f$ such that
+#   * \f{align*}
+#   *   \frac{1}{n} \sum_{i=1}^n \vert\vert y_i - (c\mathbf{R}x_i + \mathbf{t}) \vert\vert_2^2
+#   * \f}
+#   * is minimized.
+#   *
+#   * The algorithm is based on the analysis of the covariance matrix
+#   * \f$ \Sigma_{\mathbf{x}\mathbf{y}} \in \mathbb{R}^{d \times d} \f$
+#   * of the input point sets \f$ \mathbf{x} \f$ and \f$ \mathbf{y} \f$ where
+#   * \f$d\f$ is corresponding to the dimension (which is typically small).
+#   * The analysis is involving the SVD having a complexity of \f$O(d^3)\f$
+#   * though the actual computational effort lies in the covariance
+#   * matrix computation which has an asymptotic lower bound of \f$O(dm)\f$ when
+#   * the input point sets have dimension \f$d \times m\f$.
+#   *
+#   * \param[in] src Source points \f$ \mathbf{x} = \left( x_1, \hdots, x_n \right) \f$
+#   * \param[in] dst Destination points \f$ \mathbf{y} = \left( y_1, \hdots, y_n \right) \f$.
+#   * \param[in] with_scaling Sets \f$ c=1 \f$ when <code>false</code> is passed. (default: false)
+#   * \return The homogeneous transformation 
+#   * \f{align*}
+#   *   T = \begin{bmatrix} c\mathbf{R} & \mathbf{t} \\ \mathbf{0} & 1 \end{bmatrix}
+#   * \f}
+#   * minimizing the resudiual above. This transformation is always returned as an
+#   * Eigen::Matrix.
+#   */
+# template <typename Derived, typename OtherDerived> 
+# typename Eigen::internal::umeyama_transform_matrix_type<Derived, OtherDerived>::type
+# umeyama (const Eigen::MatrixBase<Derived>& src, const Eigen::MatrixBase<OtherDerived>& dst, bool with_scaling = false);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform a point using an affine matrix
+#   * \param[in] point_in the vector to be transformed
+#   * \param[out] point_out the transformed vector
+#   * \param[in] transformation the transformation matrix
+#   *
+#   * \note Can be used with \c point_in = \c point_out
+#   */
+# template<typename Scalar> inline void transformPoint (const Eigen::Matrix<Scalar, 3, 1> &point_in, Eigen::Matrix<Scalar, 3, 1> &point_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void transformPoint (const Eigen::Vector3f &point_in, Eigen::Vector3f &point_out, const Eigen::Affine3f &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPoint (const Eigen::Vector3d &point_in, Eigen::Vector3d &point_out, const Eigen::Affine3d &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform a vector using an affine matrix
+#   * \param[in] vector_in the vector to be transformed
+#   * \param[out] vector_out the transformed vector
+#   * \param[in] transformation the transformation matrix
+#   * \note Can be used with \c vector_in = \c vector_out
+#   */
+# template <typename Scalar> inline void
+# transformVector (const Eigen::Matrix<Scalar, 3, 1> &vector_in, Eigen::Matrix<Scalar, 3, 1> &vector_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformVector (const Eigen::Vector3f &vector_in, Eigen::Vector3f &vector_out, const Eigen::Affine3f &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformVector (const Eigen::Vector3d &vector_in, Eigen::Vector3d &vector_out, const Eigen::Affine3d &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform a line using an affine matrix
+#   * \param[in] line_in the line to be transformed
+#   * \param[out] line_out the transformed line
+#   * \param[in] transformation the transformation matrix
+#   * Lines must be filled in this form:\n
+#   * line[0-2] = Origin coordinates of the vector\n
+#   * line[3-5] = Direction vector
+#   * \note Can be used with \c line_in = \c line_out
+#   */
+# template <typename Scalar> bool
+# transformLine (const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_in, Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformLine (const Eigen::VectorXf &line_in, Eigen::VectorXf &line_out, const Eigen::Affine3f &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformLine (const Eigen::VectorXd &line_in, Eigen::VectorXd &line_out, const Eigen::Affine3d &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform plane vectors using an affine matrix
+#   * \param[in] plane_in the plane coefficients to be transformed
+#   * \param[out] plane_out the transformed plane coefficients to fill
+#   * \param[in] transformation the transformation matrix
+#   * The plane vectors are filled in the form ax+by+cz+d=0
+#   * Can be used with non Hessian form planes coefficients
+#   * Can be used with \c plane_in = \c plane_out
+#   */
+# template <typename Scalar> void
+# transformPlane (const Eigen::Matrix<Scalar, 4, 1> &plane_in, Eigen::Matrix<Scalar, 4, 1> &plane_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPlane (const Eigen::Matrix<double, 4, 1> &plane_in, Eigen::Matrix<double, 4, 1> &plane_out, const Eigen::Transform<double, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPlane (const Eigen::Matrix<float, 4, 1> &plane_in, Eigen::Matrix<float, 4, 1> &plane_out,const Eigen::Transform<float, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Transform plane vectors using an affine matrix
+#   * \param[in] plane_in the plane coefficients to be transformed
+#   * \param[out] plane_out the transformed plane coefficients to fill
+#   * \param[in] transformation the transformation matrix
+#   * The plane vectors are filled in the form ax+by+cz+d=0
+#   * Can be used with non Hessian form planes coefficients
+#   * Can be used with \c plane_in = \c plane_out
+#   * \warning ModelCoefficients stores floats only !
+#   */
+# template<typename Scalar> void
+# transformPlane (const pcl::ModelCoefficients::Ptr plane_in, pcl::ModelCoefficients::Ptr plane_out, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void
+# transformPlane (const pcl::ModelCoefficients::Ptr plane_in, pcl::ModelCoefficients::Ptr plane_out, const Eigen::Transform<double, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline void transformPlane (const pcl::ModelCoefficients::Ptr plane_in, pcl::ModelCoefficients::Ptr plane_out, const Eigen::Transform<float, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Check coordinate system integrity
+#   * \param[in] line_x the first axis
+#   * \param[in] line_y the second axis
+#   * \param[in] norm_limit the limit to ignore norm rounding errors
+#   * \param[in] dot_limit the limit to ignore dot product rounding errors
+#   * \return True if the coordinate system is consistent, false otherwise.
+#   * Lines must be filled in this form:\n
+#   * line[0-2] = Origin coordinates of the vector\n
+#   * line[3-5] = Direction vector
+#   * Can be used like this :\n
+#   * line_x = X axis and line_y = Y axis\n
+#   * line_x = Z axis and line_y = X axis\n
+#   * line_x = Y axis and line_y = Z axis\n
+#   * Because X^Y = Z, Z^X = Y and Y^Z = X.
+#   * Do NOT invert line order !
+#   * Determine whether a coordinate system is consistent or not by checking :\n
+#   * Line origins: They must be the same for the 2 lines\n
+#   * Norm: The 2 lines must be normalized\n
+#   * Dot products: Must be 0 or perpendicular vectors
+#   */
+# template<typename Scalar> bool
+# checkCoordinateSystem (const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_x,
+#                        const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line_y,
+#                        const Scalar norm_limit = 1e-3,
+#                        const Scalar dot_limit = 1e-3);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<double, Eigen::Dynamic, 1> &line_x,
+#                        const Eigen::Matrix<double, Eigen::Dynamic, 1> &line_y,
+#                        const double norm_limit = 1e-3,
+#                        const double dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<float, Eigen::Dynamic, 1> &line_x,
+#                        const Eigen::Matrix<float, Eigen::Dynamic, 1> &line_y,
+#                        const float norm_limit = 1e-3,
+#                        const float dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Check coordinate system integrity
+#   * \param[in] origin the origin of the coordinate system
+#   * \param[in] x_direction the first axis
+#   * \param[in] y_direction the second axis
+#   * \param[in] norm_limit the limit to ignore norm rounding errors
+#   * \param[in] dot_limit the limit to ignore dot product rounding errors
+#   * \return True if the coordinate system is consistent, false otherwise.
+#   * Read the other variant for more information
+#   */
+# template <typename Scalar> inline bool
+# checkCoordinateSystem (const Eigen::Matrix<Scalar, 3, 1> &origin,
+#                        const Eigen::Matrix<Scalar, 3, 1> &x_direction,
+#                        const Eigen::Matrix<Scalar, 3, 1> &y_direction,
+#                        const Scalar norm_limit = 1e-3,
+#                        const Scalar dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<double, 3, 1> &origin,
+#                        const Eigen::Matrix<double, 3, 1> &x_direction,
+#                        const Eigen::Matrix<double, 3, 1> &y_direction,
+#                        const double norm_limit = 1e-3,
+#                        const double dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# checkCoordinateSystem (const Eigen::Matrix<float, 3, 1> &origin,
+#                        const Eigen::Matrix<float, 3, 1> &x_direction,
+#                        const Eigen::Matrix<float, 3, 1> &y_direction,
+#                        const float norm_limit = 1e-3,
+#                        const float dot_limit = 1e-3)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# /** \brief Compute the transformation between two coordinate systems
+#   * \param[in] from_line_x X axis from the origin coordinate system
+#   * \param[in] from_line_y Y axis from the origin coordinate system
+#   * \param[in] to_line_x X axis from the destination coordinate system
+#   * \param[in] to_line_y Y axis from the destination coordinate system
+#   * \param[out] transformation the transformation matrix to fill
+#   * \return true if transformation was filled, false otherwise.
+#   * Line must be filled in this form:\n
+#   * line[0-2] = Coordinate system origin coordinates \n
+#   * line[3-5] = Direction vector (norm doesn't matter)
+#   */
+# template <typename Scalar> bool
+# transformBetween2CoordinateSystems (const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> from_line_x,
+#                                     const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> from_line_y,
+#                                     const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> to_line_x,
+#                                     const Eigen::Matrix<Scalar, Eigen::Dynamic, 1> to_line_y,
+#                                     Eigen::Transform<Scalar, 3, Eigen::Affine> &transformation);
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformBetween2CoordinateSystems (const Eigen::Matrix<double, Eigen::Dynamic, 1> from_line_x,
+#                                     const Eigen::Matrix<double, Eigen::Dynamic, 1> from_line_y,
+#                                     const Eigen::Matrix<double, Eigen::Dynamic, 1> to_line_x,
+#                                     const Eigen::Matrix<double, Eigen::Dynamic, 1> to_line_y,
+#                                     Eigen::Transform<double, 3, Eigen::Affine> &transformation)
+###
+
+# eigen.h
+# namespace pcl
+# cdef extern from "pcl/common/eigen.h" namespace "pcl":
+# inline bool
+# transformBetween2CoordinateSystems (const Eigen::Matrix<float, Eigen::Dynamic, 1> from_line_x,
+#                                     const Eigen::Matrix<float, Eigen::Dynamic, 1> from_line_y,
+#                                     const Eigen::Matrix<float, Eigen::Dynamic, 1> to_line_x,
+#                                     const Eigen::Matrix<float, Eigen::Dynamic, 1> to_line_y,
+#                                     Eigen::Transform<float, 3, Eigen::Affine> &transformation)
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Find all *.pcd files in the directory and return them sorted
+#   * \param directory the directory to be searched
+#   * \param file_names the resulting (sorted) list of .pcd files
+#   */
+# inline void getAllPcdFilesInDirectory (const std::string& directory, std::vector<std::string>& file_names);
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Remove the path from the given string and return only the filename (the remaining string after the 
+#   * last '/')
+#   * \param input the input filename (with full path)
+#   * \return the resulting filename, stripped of the path
+#   */
+# inline std::string  getFilenameWithoutPath (const std::string& input);
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Remove the extension from the given string and return only the filename (everything before the last '.')
+#   * \param input the input filename (with the file extension)
+#   * \return the resulting filename, stripped of its extension
+#   */
+# inline std::string getFilenameWithoutExtension (const std::string& input);
+###
+
+# file_io.h
+# namespace pcl
+# cdef extern from "pcl/common/file_io.h" namespace "pcl":
+# /** \brief Get the file extension from the given string (the remaining string after the last '.')
+#   * \param input the input filename
+#   * \return \a input 's file extension
+#   */
+# inline std::string getFileExtension (const std::string& input)
+###
+
+# gaussian.h
+# namespace pcl
+# cdef extern from "pcl/common/gaussian.h" namespace "pcl":
+# /** Class GaussianKernel assembles all the method for computing, 
+#   * convolving, smoothing, gradients computing an image using
+#   * a gaussian kernel. The image is stored in point cloud elements 
+#   * intensity member or rgb or...
+#   * \author Nizar Sallem
+#   * \ingroup common
+#   */
+# class PCL_EXPORTS GaussianKernel
+# 		public:
+#       GaussianKernel () {}
+# 
+#       static const unsigned MAX_KERNEL_WIDTH = 71;
+#       /** Computes the gaussian kernel and dervative assiociated to sigma.
+#         * The kernel and derivative width are adjusted according.
+#         * \param[in] sigma
+#         * \param[out] kernel the computed gaussian kernel
+#         * \param[in] kernel_width the desired kernel width upper bond
+#         * \throws pcl::KernelWidthTooSmallException
+#         */
+#       void compute (float sigma, 
+#                Eigen::VectorXf &kernel,
+#                unsigned kernel_width = MAX_KERNEL_WIDTH) const;
+# 
+#       /** Computes the gaussian kernel and dervative assiociated to sigma.
+#         * The kernel and derivative width are adjusted according.
+#         * \param[in] sigma
+#         * \param[out] kernel the computed gaussian kernel
+#         * \param[out] derivative the computed kernel derivative
+#         * \param[in] kernel_width the desired kernel width upper bond
+#         * \throws pcl::KernelWidthTooSmallException
+#         */
+#       void compute (float sigma, 
+#                Eigen::VectorXf &kernel, Eigen::VectorXf &derivative, 
+#                unsigned kernel_width = MAX_KERNEL_WIDTH) const;
+# 
+#       /** Convolve a float image rows by a given kernel.
+#         * \param[in] kernel convolution kernel
+#         * \param[in] input the image to convolve
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       void convolveRows (const pcl::PointCloud<float> &input, const Eigen::VectorXf &kernel, pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image rows by a given kernel.
+#         * \param[in] input the image to convolve
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] kernel convolution kernel
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#      template <typename PointT> void
+#      convolveRows (const pcl::PointCloud<PointT> &input,
+#                    boost::function <float (const PointT& p)> field_accessor, const Eigen::VectorXf &kernel,
+#                    pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image columns by a given kernel.
+#         * \param[in] input the image to convolve
+#         * \param[in] kernel convolution kernel
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       void convolveCols (const pcl::PointCloud<float> &input, const Eigen::VectorXf &kernel, pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image columns by a given kernel.
+#         * \param[in] input the image to convolve
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] kernel convolution kernel
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> void
+#       convolveCols (const pcl::PointCloud<PointT> &input,
+#                     boost::function <float (const PointT& p)> field_accessor, const Eigen::VectorXf &kernel, pcl::PointCloud<float> &output) const;
+# 
+#       /** Convolve a float image in the 2 directions
+#         * \param[in] horiz_kernel kernel for convolving rows
+#         * \param[in] vert_kernel kernel for convolving columns
+#         * \param[in] input image to convolve
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       inline void
+#       convolve (const pcl::PointCloud<float> &input,
+#                 const Eigen::VectorXf &horiz_kernel, const Eigen::VectorXf &vert_kernel, pcl::PointCloud<float> &output) const
+# 
+#       /** Convolve a float image in the 2 directions
+#         * \param[in] input image to convolve
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] horiz_kernel kernel for convolving rows
+#         * \param[in] vert_kernel kernel for convolving columns
+#         * \param[out] output the convolved image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> inline void
+#       convolve (const pcl::PointCloud<PointT> &input,
+#                 boost::function <float (const PointT& p)> field_accessor,
+#                 const Eigen::VectorXf &horiz_kernel, const Eigen::VectorXf &vert_kernel, pcl::PointCloud<float> &output) const
+#       
+#       /** Computes float image gradients using a gaussian kernel and gaussian kernel
+#         * derivative.
+#         * \param[in] input image to compute gardients for
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[in] gaussian_kernel_derivative the associated derivative
+#         * \param[out] grad_x gradient along X direction
+#         * \param[out] grad_y gradient along Y direction
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       inline void
+#       computeGradients (const pcl::PointCloud<float> &input,
+#                         const Eigen::VectorXf &gaussian_kernel, const Eigen::VectorXf &gaussian_kernel_derivative,
+#                         pcl::PointCloud<float> &grad_x, pcl::PointCloud<float> &grad_y) const
+# 
+#       /** Computes float image gradients using a gaussian kernel and gaussian kernel
+#         * derivative.
+#         * \param[in] input image to compute gardients for
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[in] gaussian_kernel_derivative the associated derivative
+#         * \param[out] grad_x gradient along X direction
+#         * \param[out] grad_y gradient along Y direction
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> inline void
+#       computeGradients (const pcl::PointCloud<PointT> &input, boost::function <float (const PointT& p)> field_accessor,
+#                         const Eigen::VectorXf &gaussian_kernel, const Eigen::VectorXf &gaussian_kernel_derivative,
+#                         pcl::PointCloud<float> &grad_x, pcl::PointCloud<float> &grad_y) const
+#       
+#       /** Smooth image using a gaussian kernel.
+#         * \param[in] input image
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[out] output the smoothed image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       inline void smooth (const pcl::PointCloud<float> &input,
+#               const Eigen::VectorXf &gaussian_kernel, pcl::PointCloud<float> &output) const
+# 
+#       /** Smooth image using a gaussian kernel.
+#         * \param[in] input image
+#         * \param[in] field_accessor a field accessor
+#         * \param[in] gaussian_kernel the gaussian kernel to be used
+#         * \param[out] output the smoothed image
+#         * \note if output doesn't fit in input i.e. output.rows () < input.rows () or
+#         * output.cols () < input.cols () then output is resized to input sizes.
+#         */
+#       template <typename PointT> inline void
+#       smooth (const pcl::PointCloud<PointT> &input, boost::function <float (const PointT& p)> field_accessor,
+#               const Eigen::VectorXf &gaussian_kernel, pcl::PointCloud<float> &output) const
+#   };
+# }
+# 
+###
+
+# generate.h
+# namespace pcl
+# namespace common
+# cdef extern from "pcl/common/generate.h" namespace "pcl::common":
+# /** \brief CloudGenerator class generates a point cloud using some randoom number generator.
+#   * Generators can be found in \file common/random.h and easily extensible.
+#   * \ingroup common
+#   * \author Nizar Sallem
+#   */
+# template <typename PointT, typename GeneratorT>
+# class CloudGenerator
+# {
+#     public:
+#     typedef typename GeneratorT::Parameters GeneratorParameters;
+# 
+#     /// Default constructor
+#     CloudGenerator ();
+# 
+#     /** Consttructor with single generator to ensure all X, Y and Z values are within same range
+#       * \param params paramteres for X, Y and Z values generation. Uniqueness is ensured through
+#       * seed incrementation
+#       */
+#     CloudGenerator (const GeneratorParameters& params);
+# 
+#     /** Constructor with independant generators per axis
+#       * \param x_params parameters for x values generation
+#       * \param y_params parameters for y values generation
+#       * \param z_params parameters for z values generation
+#       */
+#     CloudGenerator (const GeneratorParameters& x_params,
+#                     const GeneratorParameters& y_params,
+#                     const GeneratorParameters& z_params);
+# 
+#     /** Set parameters for x, y and z values. Uniqueness is ensured through seed incrementation.
+#       * \param params parameteres for X, Y and Z values generation. 
+#       */
+#     void setParameters (const GeneratorParameters& params);
+# 
+#     /** Set parameters for x values generation
+#       * \param x_params paramters for x values generation
+#       */
+#     void setParametersForX (const GeneratorParameters& x_params);
+# 
+#     /** Set parameters for y values generation
+#       * \param y_params paramters for y values generation
+#       */
+#     void setParametersForY (const GeneratorParameters& y_params);
+# 
+#     /** Set parameters for z values generation
+#       * \param z_params paramters for z values generation
+#       */
+#     void setParametersForZ (const GeneratorParameters& z_params);
+# 
+#     /// \return x values generation parameters
+#     const GeneratorParameters& getParametersForX () const;
+# 
+#     /// \return y values generation parameters
+#     const GeneratorParameters& getParametersForY () const;
+# 
+#     /// \return z values generation parameters
+#     const GeneratorParameters& getParametersForZ () const;
+# 
+#     /// \return a single random generated point 
+#     PointT get ();
+# 
+#     /** Generates a cloud with X Y Z picked within given ranges. This function assumes that
+#       * cloud is properly defined else it raises errors and does nothing.
+#       * \param[out] cloud cloud to generate coordinates for
+#       * \return 0 if generation went well else -1.
+#       */
+#     int fill (pcl::PointCloud<PointT>& cloud);
+# 
+#     /** Generates a cloud of specified dimensions with X Y Z picked within given ranges. 
+#       * \param[in] width width of generated cloud
+#       * \param[in] height height of generated cloud
+#       * \param[out] cloud output cloud
+#       * \return 0 if generation went well else -1.
+#       */
+#     int fill (int width, int height, pcl::PointCloud<PointT>& cloud);
+#   };
+# 
+#     template <typename GeneratorT>
+#     class CloudGenerator<pcl::PointXY, GeneratorT>
+#     {
+#       public:
+#       typedef typename GeneratorT::Parameters GeneratorParameters;
+#       
+#       CloudGenerator ();
+#       
+#       CloudGenerator (const GeneratorParameters& params);
+# 
+#       CloudGenerator (const GeneratorParameters& x_params, const GeneratorParameters& y_params);
+#       
+#       void setParameters (const GeneratorParameters& params);
+# 
+#       void setParametersForX (const GeneratorParameters& x_params);
+# 
+#       void setParametersForY (const GeneratorParameters& y_params);
+# 
+#       const GeneratorParameters& getParametersForX () const;
+# 
+#       const GeneratorParameters& getParametersForY () const;
+# 
+#       pcl::PointXYget ();
+# 
+#       int fill (pcl::PointCloud<pcl::PointXY>& cloud);
+# 
+#       int fill (int width, int height, pcl::PointCloud<pcl::PointXY>& cloud);
+#       
+#     };
+#   }
+# }
+###
+
+# geometry.h
+# namespace pcl
+# namespace geometry
+#     /** @return the euclidean distance between 2 points */
+#     template <typename PointT> inline float distance (const PointT& p1, const PointT& p2)
+# 
+#     /** @return the squared euclidean distance between 2 points */
+#     template<typename PointT> inline float squaredDistance (const PointT& p1, const PointT& p2)
+# 
+#     /** @return the point projection on a plane defined by its origin and normal vector 
+#       * \param[in] point Point to be projected
+#       * \param[in] plane_origin The plane origin
+#       * \param[in] plane_normal The plane normal 
+#       * \param[out] projected The returned projected point
+#       */
+#     template<typename PointT, typename NormalT> inline void 
+#     project (const PointT& point, const PointT &plane_origin, const NormalT& plane_normal, PointT& projected)
+# 
+#     /** @return the point projection on a plane defined by its origin and normal vector 
+#       * \param[in] point Point to be projected
+#       * \param[in] plane_origin The plane origin
+#       * \param[in] plane_normal The plane normal 
+#       * \param[out] projected The returned projected point
+#       */
+#     inline void project (const Eigen::Vector3f& point, const Eigen::Vector3f &plane_origin, const Eigen::Vector3f& plane_normal, Eigen::Vector3f& projected)
+
+
+###
+
+# intensity.h
+# namespace pcl
+# namespace common
+#     /** \brief Intensity field accessor provides access to the inetnsity filed of a PoinT
+#       * implementation for specific types should be done in \file pcl/common/impl/intensity.hpp
+#       */
+#     template<typename PointT> struct IntensityFieldAccessor
+#     {
+#       /** \brief get intensity field
+#         * \param[in] p point
+#         * \return p.intensity
+#         */
+#       inline float operator () (const PointT &p) const
+# 
+#       /** \brief gets the intensity value of a point
+#         * \param p point for which intensity to be get
+#         * \param[in] intensity value of the intensity field
+#         */
+#       inline void get (const PointT &p, float &intensity) const
+#
+#       /** \brief sets the intensity value of a point
+#         * \param p point for which intensity to be set
+#         * \param[in] intensity value of the intensity field
+#         */
+#       inline void set (PointT &p, float intensity) const
+# 
+#       /** \brief subtract value from intensity field
+#         * \param p point for which to modify inetnsity
+#         * \param[in] value value to be subtracted from point intensity
+#         */
+#       inline void demean (PointT& p, float value) const
+# 
+#       /** \brief add value to intensity field
+#         * \param p point for which to modify inetnsity
+#         * \param[in] value value to be added to point intensity
+#         */
+#       inline void add (PointT& p, float value) const
+#     };
+#   }
+# }
+###
+
+# intersections.h
+# namespace pcl
+# {
+#   /** \brief Get the intersection of a two 3D lines in space as a 3D point
+#     * \param[in] line_a the coefficients of the first line (point, direction)
+#     * \param[in] line_b the coefficients of the second line (point, direction)
+#     * \param[out] point holder for the computed 3D point
+#     * \param[in] sqr_eps maximum allowable squared distance to the true solution
+#     * \ingroup common
+#     */
+#   PCL_EXPORTS inline bool lineWithLineIntersection (
+# 								const Eigen::VectorXf &line_a, 
+#                             	const Eigen::VectorXf &line_b, 
+#                             	Eigen::Vector4f &point,
+#                             	double sqr_eps = 1e-4);
+# 
+#   /** \brief Get the intersection of a two 3D lines in space as a 3D point
+#     * \param[in] line_a the coefficients of the first line (point, direction)
+#     * \param[in] line_b the coefficients of the second line (point, direction)
+#     * \param[out] point holder for the computed 3D point
+#     * \param[in] sqr_eps maximum allowable squared distance to the true solution
+#     * \ingroup common
+#     */
+# 
+#   PCL_EXPORTS inline bool
+#   lineWithLineIntersection (const pcl::ModelCoefficients &line_a, 
+#                             const pcl::ModelCoefficients &line_b, 
+#                             Eigen::Vector4f &point,
+#                             double sqr_eps = 1e-4);
+# 
+#   /** \brief Determine the line of intersection of two non-parallel planes using lagrange multipliers
+#     * \note Described in: "Intersection of Two Planes, John Krumm, Microsoft Research, Redmond, WA, USA"
+#     * \param[in] plane_a coefficients of plane A and plane B in the form ax + by + cz + d = 0
+#     * \param[in] plane_b coefficients of line where line.tail<3>() = direction vector and
+#     * line.head<3>() the point on the line clossest to (0, 0, 0)
+#     * \param[out] line the intersected line to be filled
+#     * \param[in] angular_tolerance tolerance in radians
+#     * \return true if succeeded/planes aren't parallel
+#     */
+#   PCL_EXPORTS template <typename Scalar> bool
+#   planeWithPlaneIntersection (const Eigen::Matrix<Scalar, 4, 1> &plane_a,
+#                               const Eigen::Matrix<Scalar, 4, 1> &plane_b,
+#                               Eigen::Matrix<Scalar, Eigen::Dynamic, 1> &line,
+#                               double angular_tolerance = 0.1);
+# 
+#   PCL_EXPORTS inline bool
+#   planeWithPlaneIntersection (const Eigen::Vector4f &plane_a,
+#                               const Eigen::Vector4f &plane_b,
+#                               Eigen::VectorXf &line,
+#                               double angular_tolerance = 0.1)
+#   {
+#     return (planeWithPlaneIntersection<float> (plane_a, plane_b, line, angular_tolerance));
+#   }
+# 
+#   PCL_EXPORTS inline bool
+#   planeWithPlaneIntersection (const Eigen::Vector4d &plane_a,
+#                               const Eigen::Vector4d &plane_b,
+#                               Eigen::VectorXd &line,
+#                               double angular_tolerance = 0.1)
+#   {
+#     return (planeWithPlaneIntersection<double> (plane_a, plane_b, line, angular_tolerance));
+#   }
+# 
+#   /** \brief Determine the point of intersection of three non-parallel planes by solving the equations.
+#     * \note If using nearly parralel planes you can lower the determinant_tolerance value. This can
+#     * lead to inconsistent results.
+#     * If the three planes intersects in a line the point will be anywhere on the line.
+#     * \param[in] plane_a are the coefficients of the first plane in the form ax + by + cz + d = 0
+#     * \param[in] plane_b are the coefficients of the second plane
+#     * \param[in] plane_c are the coefficients of the third plane
+#     * \param[in] determinant_tolerance is a limit to determine whether planes are parallel or not
+#     * \param[out] intersection_point the three coordinates x, y, z of the intersection point
+#     * \return true if succeeded/planes aren't parallel
+#     */
+#   PCL_EXPORTS template <typename Scalar> bool
+#   threePlanesIntersection (const Eigen::Matrix<Scalar, 4, 1> &plane_a,
+#                            const Eigen::Matrix<Scalar, 4, 1> &plane_b,
+#                            const Eigen::Matrix<Scalar, 4, 1> &plane_c,
+#                            Eigen::Matrix<Scalar, 3, 1> &intersection_point,
+#                            double determinant_tolerance = 1e-6);
+# 
+# 
+#   PCL_EXPORTS inline bool
+#   threePlanesIntersection (const Eigen::Vector4f &plane_a,
+#                            const Eigen::Vector4f &plane_b,
+#                            const Eigen::Vector4f &plane_c,
+#                            Eigen::Vector3f &intersection_point,
+#                            double determinant_tolerance = 1e-6)
+#   {
+#     return (threePlanesIntersection<float> (plane_a, plane_b, plane_c,
+#                                             intersection_point, determinant_tolerance));
+#   }
+# 
+#   PCL_EXPORTS inline bool
+#   threePlanesIntersection (const Eigen::Vector4d &plane_a,
+#                            const Eigen::Vector4d &plane_b,
+#                            const Eigen::Vector4d &plane_c,
+#                            Eigen::Vector3d &intersection_point,
+#                            double determinant_tolerance = 1e-6)
+#   {
+#     return (threePlanesIntersection<double> (plane_a, plane_b, plane_c, intersection_point, determinant_tolerance));
+#   }
+# 
+# }
+###
+
+# io.h
+# namespace pcl
+# /** \brief Get the index of a specified field (i.e., dimension/channel)
+#   * \param[in] cloud the the point cloud message
+#   * \param[in] field_name the string defining the field name
+#   * \ingroup common
+#   */
+# inline int getFieldIndex (const pcl::PCLPointCloud2 &cloud, const std::string &field_name)
+# 
+# /** \brief Get the index of a specified field (i.e., dimension/channel)
+#   * \param[in] cloud the the point cloud message
+#   * \param[in] field_name the string defining the field name
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline int getFieldIndex (const pcl::PointCloud<PointT> &cloud, const std::string &field_name, std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the index of a specified field (i.e., dimension/channel)
+#   * \param[in] field_name the string defining the field name
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline int getFieldIndex (const std::string &field_name, std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the list of available fields (i.e., dimension/channel)
+#   * \param[in] cloud the point cloud message
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void getFields (const pcl::PointCloud<PointT> &cloud, std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the list of available fields (i.e., dimension/channel)
+#   * \param[out] fields a vector to the original \a PCLPointField vector that the raw PointCloud message contains
+#   * \ingroup common
+#   */
+# template <typename PointT> inline void getFields (std::vector<pcl::PCLPointField> &fields);
+# 
+# /** \brief Get the list of all fields available in a given cloud
+#   * \param[in] cloud the the point cloud message
+#   * \ingroup common
+#   */
+# template <typename PointT> inline std::string  getFieldsList (const pcl::PointCloud<PointT> &cloud);
+# 
+# /** \brief Get the available point cloud fields as a space separated string
+#   * \param[in] cloud a pointer to the PointCloud message
+#   * \ingroup common
+#   */
+# inline std::string getFieldsList (const pcl::PCLPointCloud2 &cloud)
+# 
+# /** \brief Obtains the size of a specific field data type in bytes
+#   * \param[in] datatype the field data type (see PCLPointField.h)
+#   * \ingroup common
+#   */
+# inline int getFieldSize (const int datatype)
+# 
+# /** \brief Obtain a vector with the sizes of all valid fields (e.g., not "_")
+#   * \param[in] fields the input vector containing the fields
+#   * \param[out] field_sizes the resultant field sizes in bytes
+#   */
+# PCL_EXPORTS void getFieldsSizes (const std::vector<pcl::PCLPointField> &fields,std::vector<int> &field_sizes);
+# 
+# /** \brief Obtains the type of the PCLPointField from a specific size and type
+#   * \param[in] size the size in bytes of the data field
+#   * \param[in] type a char describing the type of the field  ('F' = float, 'I' = signed, 'U' = unsigned)
+#   * \ingroup common
+#   */
+# inline int getFieldType (const int size, char type)
+# 
+# /** \brief Obtains the type of the PCLPointField from a specific PCLPointField as a char
+#   * \param[in] type the PCLPointField field type
+#   * \ingroup common
+#   */
+# inline char getFieldType (const int type)
+# {
+#   switch (type)
+#   {
+#     case pcl::PCLPointField::INT8:
+#     case pcl::PCLPointField::INT16:
+#     case pcl::PCLPointField::INT32:
+#       return ('I');
+# 
+#     case pcl::PCLPointField::UINT8:
+#     case pcl::PCLPointField::UINT16:
+#     case pcl::PCLPointField::UINT32:
+#       return ('U');
+# 
+#     case pcl::PCLPointField::FLOAT32:
+#     case pcl::PCLPointField::FLOAT64:
+#       return ('F');
+#     default:
+#       return ('?');
+#   }
+# }
+# 
+# typedef enum
+# {
+#   BORDER_CONSTANT = 0, BORDER_REPLICATE = 1,
+#   BORDER_REFLECT = 2, BORDER_WRAP = 3,
+#   BORDER_REFLECT_101 = 4, BORDER_TRANSPARENT = 5,
+#   BORDER_DEFAULT = BORDER_REFLECT_101
+# } InterpolationType;
+###
+
+# /** \brief \return the right index according to the interpolation type.
+#   * \note this is adapted from OpenCV
+#   * \param p the index of point to interpolate
+#   * \param length the top/bottom row or left/right column index
+#   * \param type the requested interpolation
+#   * \throws pcl::BadArgumentException if type is unknown
+#   */
+# PCL_EXPORTS int interpolatePointIndex (int p, int length, InterpolationType type);
+###
+
+# /** \brief Concatenate two pcl::PCLPointCloud2.
+#   * \param[in] cloud1 the first input point cloud dataset
+#   * \param[in] cloud2 the second input point cloud dataset
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \return true if successful, false if failed (e.g., name/number of fields differs)
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool concatenatePointCloud (const pcl::PCLPointCloud2 &cloud1, const pcl::PCLPointCloud2 &cloud2, pcl::PCLPointCloud2 &cloud_out);
+###
+
+# pcl1.6.0 NG
+# pcl1.7.2
+# copy_point.h
+# namespace pcl
+# \brief Copy the fields of a source point into a target point.
+#  If the source and the target point types are the same, then a complete
+#  copy is made. Otherwise only those fields that the two point types share
+#  in common are copied.
+# \param[in]  point_in the source point
+# \param[out] point_out the target point
+# \ingroup common
+# template <typename PointInT, typename PointOutT> void copyPoint (const PointInT& point_in, PointOutT& point_out);
+# PCL 1.7.2
+# cdef extern from "pcl/common/copy_point.h" namespace "pcl":
+# PCL 1.6.0
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    void copyPointCloud [PointInT, PointOutT](const PointInT &cloud_in, const PointOutT &cloud_out)
+
+# void copyPointCloud [shared_ptr[cpp.PointCloud[cpp.PointXYZ]], shared_ptr[cpp.PointCloud[cpp.PointXYZ]] (hogehoge)
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# PCL_EXPORTS void copyPointCloud (const pcl::PCLPointCloud2 &cloud_in, const std::vector<int> &indices, pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# PCL_EXPORTS void copyPointCloud (const pcl::PCLPointCloud2 &cloud_in, const std::vector<int, Eigen::aligned_allocator<int> > &indices,  pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Copy fields and point cloud data from \a cloud_in to \a cloud_out
+# \param[in] cloud_in the input point cloud dataset
+# \param[out] cloud_out the resultant output point cloud dataset
+# \ingroup common
+# PCL_EXPORTS void copyPointCloud (const pcl::PCLPointCloud2 &cloud_in, pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Check if two given point types are the same or not. */
+# template <typename Point1T, typename Point2T> inline bool isSamePointType ()
+###
+
+# common/io.h
+# namespace pcl
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const std::vector<int> &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    # cdef void copyPointCloud [PointT](shared_ptr[cpp.PointCloud[PointT]] &cloud_in, const vector[int] &indices, shared_ptr[cpp.PointCloud[PointT]] &cloud_out)
+    # NG
+    # cdef void copyPointCloud_Indices "copyPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud_in, const vector[int] &indices, shared_ptr[cpp.PointCloud[PointT]] &cloud_out)
+    # cdef void copyPointCloud_Indices "pcl::copyPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud_in, const vector[int] &indices, shared_ptr[cpp.PointCloud[PointT]] &cloud_out)
+    void copyPointCloud_Indices "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const vector[int] &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# \brief Extract the indices of a given point cloud as a new point cloud
+# \param[in] cloud_in the input point cloud dataset
+# \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+# \param[out] cloud_out the resultant output point cloud dataset
+# \note Assumes unique indices.
+# \ingroup common
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const std::vector<int, Eigen::aligned_allocator<int> > &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    cdef void copyPointCloud_Indices2 "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const vector[int, eigen3.aligned_allocator_t] &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Extract the indices of a given point cloud as a new point cloud
+#   * \param[in] cloud_in the input point cloud dataset
+#   * \param[in] indices the PointIndices structure representing the points to be copied from cloud_in
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \note Assumes unique indices.
+#   * \ingroup common
+#   */
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const PointIndices &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    cdef void copyPointCloud_Indices3 "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const cpp.PointIndices &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Extract the indices of a given point cloud as a new point cloud
+#   * \param[in] cloud_in the input point cloud dataset
+#   * \param[in] indices the vector of indices representing the points to be copied from \a cloud_in
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \note Assumes unique indices.
+#   * \ingroup common
+#   */
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, const std::vector<pcl::PointIndices> &indices, pcl::PointCloud<PointT> &cloud_out);
+cdef extern from "pcl/common/io.h" namespace "pcl":
+    cdef void copyPointCloud_Indices4 "pcl::copyPointCloud" [PointT](const cpp.PointCloud[PointT]* &cloud_in, const vector[cpp.PointIndices] &indices, cpp.PointCloud[PointT] &cloud_out)
+
+
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Copy a point cloud inside a larger one interpolating borders.
+#   * \param[in] cloud_in the input point cloud dataset
+#   * \param[out] cloud_out the resultant output point cloud dataset
+#   * \param top
+#   * \param bottom
+#   * \param left
+#   * \param right
+#   * Position of cloud_in inside cloud_out is given by \a top, \a left, \a bottom \a right.
+#   * \param[in] border_type the interpolating method (pcl::BORDER_XXX)
+#   *  BORDER_REPLICATE:     aaaaaa|abcdefgh|hhhhhhh
+#   *  BORDER_REFLECT:       fedcba|abcdefgh|hgfedcb
+#   *  BORDER_REFLECT_101:   gfedcb|abcdefgh|gfedcba
+#   *  BORDER_WRAP:          cdefgh|abcdefgh|abcdefg
+#   *  BORDER_CONSTANT:      iiiiii|abcdefgh|iiiiiii  with some specified 'i'
+#   *  BORDER_TRANSPARENT:   mnopqr|abcdefgh|tuvwxyz  where m-r and t-z are orignal values of cloud_out
+#   * \param value
+#   * \throw pcl::BadArgumentException if any of top, bottom, left or right is negative.
+#   * \ingroup common
+#   */
+# template <typename PointT> void copyPointCloud (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, int top, int bottom, int left, int right, pcl::InterpolationType border_type, const PointT& value);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Concatenate two datasets representing different fields.
+#   * \note If the input datasets have overlapping fields (i.e., both contain
+#   * the same fields), then the data in the second cloud (cloud2_in) will
+#   * overwrite the data in the first (cloud1_in).
+#   * \param[in] cloud1_in the first input dataset
+#   * \param[in] cloud2_in the second input dataset (overwrites the fields of the first dataset for those that are shared)
+#   * \param[out] cloud_out the resultant output dataset created by the concatenation of all the fields in the input datasets
+#   * \ingroup common
+#   */
+# template <typename PointIn1T, typename PointIn2T, typename PointOutT> void concatenateFields (const pcl::PointCloud<PointIn1T> &cloud1_in, const pcl::PointCloud<PointIn2T> &cloud2_in, pcl::PointCloud<PointOutT> &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Concatenate two datasets representing different fields.
+#   * \note If the input datasets have overlapping fields (i.e., both contain
+#   * the same fields), then the data in the second cloud (cloud2_in) will
+#   * overwrite the data in the first (cloud1_in).
+#   * \param[in] cloud1_in the first input dataset
+#   * \param[in] cloud2_in the second input dataset (overwrites the fields of the first dataset for those that are shared)
+#   * \param[out] cloud_out the output dataset created by concatenating all the fields in the input datasets
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool concatenateFields (const pcl::PCLPointCloud2 &cloud1_in,const pcl::PCLPointCloud2 &cloud2_in,pcl::PCLPointCloud2 &cloud_out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Copy the XYZ dimensions of a pcl::PCLPointCloud2 into Eigen format
+#   * \param[in] in the point cloud message
+#   * \param[out] out the resultant Eigen MatrixXf format containing XYZ0 / point
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool getPointCloudAsEigen (const pcl::PCLPointCloud2 &in, Eigen::MatrixXf &out);
+###
+
+# common/io.h
+# namespace pcl
+# cdef extern from "pcl/common/io.h" namespace "pcl":
+# /** \brief Copy the XYZ dimensions from an Eigen MatrixXf into a pcl::PCLPointCloud2 message
+#   * \param[in] in the Eigen MatrixXf format containing XYZ0 / point
+#   * \param[out] out the resultant point cloud message
+#   * \note the method assumes that the PCLPointCloud2 message already has the fields set up properly !
+#   * \ingroup common
+#   */
+# PCL_EXPORTS bool getEigenAsPointCloud (Eigen::MatrixXf &in, pcl::PCLPointCloud2 &out);
+# 
+# namespace io 
+# {
+#   /** \brief swap bytes order of a char array of length N
+#     * \param bytes char array to swap
+#     * \ingroup common
+#     */
+#   template <std::size_t N> void swapByte (char* bytes);
+# 
+#  /** \brief specialization of swapByte for dimension 1
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<1> (char* bytes) { bytes[0] = bytes[0]; }
+# 
+#  /** \brief specialization of swapByte for dimension 2
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<2> (char* bytes) { std::swap (bytes[0], bytes[1]); }
+# 
+#  /** \brief specialization of swapByte for dimension 4
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<4> (char* bytes)
+# 
+#  /** \brief specialization of swapByte for dimension 8
+#    * \param bytes char array to swap
+#    */
+#   template <> inline void swapByte<8> (char* bytes)
+# 
+#   /** \brief swaps byte of an arbitrary type T casting it to char*
+#     * \param value the data you want its bytes swapped
+#     */
+#   template <typename T> void swapByte (T& value)
+
+
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Enum that defines all the types of norms available.
+#  * \note Any new norm type should have its own enum value and its own case in the selectNorm () method
+#  * \ingroup common
+#  */
+# enum NormType {L1, L2_SQR, L2, LINF, JM, B, SUBLINEAR, CS, DIV, PF, K, KL, HIK};
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Method that calculates any norm type available, based on the norm_type variable
+#  * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#  * \ingroup common
+#  * */
+# template <typename FloatVectorT> inline float
+# selectNorm (FloatVectorT A, FloatVectorT B, int dim, NormType norm_type);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the L1 norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# L1_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the squared L2 norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# L2_Norm_SQR (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the L2 norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# L2_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the L-infinity norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */  
+# template <typename FloatVectorT> inline float
+# Linf_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the JM norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# JM_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the B norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# B_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the sublinear norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# Sublinear_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the CS norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# CS_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the div norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# Div_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the PF norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \param P1 the first parameter
+#   * \param P2 the second parameter
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# PF_Norm (FloatVectorT A, FloatVectorT B, int dim, float P1, float P2);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the K norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \param P1 the first parameter
+#   * \param P2 the second parameter
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# K_Norm (FloatVectorT A, FloatVectorT B, int dim, float P1, float P2);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the KL between two discrete probability density functions
+#   * \param A the first discrete PDF
+#   * \param B the second discrete PDF
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# KL_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# norms.h
+# namespace pcl
+# cdef extern from "pcl/common/norms.h" namespace "pcl":
+# /** \brief Compute the HIK norm of the vector between two points
+#   * \param A the first point
+#   * \param B the second point
+#   * \param dim the number of dimensions in \a A and \a B (dimensions must match)
+#   * \note FloatVectorT is any type of vector with its values accessible via [ ]
+#   * \ingroup common
+#   */
+# template <typename FloatVectorT> inline float
+# HIK_Norm (FloatVectorT A, FloatVectorT B, int dim);
+###
+
+# pca.h
+# namespace pcl
+# cdef extern from "pcl/common/pca.h" namespace "pcl":
+# /** Principal Component analysis (PCA) class.\n
+#   *  Principal components are extracted by singular values decomposition on the 
+#   * covariance matrix of the centered input cloud. Available data after pca computation 
+#   * are the mean of the input data, the eigenvalues (in descending order) and 
+#   * corresponding eigenvectors.\n
+#   * Other methods allow projection in the eigenspace, reconstruction from eigenspace and 
+#   *  update of the eigenspace with a new datum (according Matej Artec, Matjaz Jogan and 
+#   * Ales Leonardis: "Incremental PCA for On-line Visual Learning and Recognition").
+#   * \author Nizar Sallem
+#   * \ingroup common
+#   */
+# template <typename PointT>
+# class PCA : public pcl::PCLBase <PointT>
+# {
+#   public:
+#     typedef pcl::PCLBase <PointT> Base;
+#     typedef typename Base::PointCloud PointCloud;
+#     typedef typename Base::PointCloudPtr PointCloudPtr;
+#     typedef typename Base::PointCloudConstPtr PointCloudConstPtr;
+#     typedef typename Base::PointIndicesPtr PointIndicesPtr;
+#     typedef typename Base::PointIndicesConstPtr PointIndicesConstPtr;
+# 
+#     using Base::input_;
+#     using Base::indices_;
+#     using Base::initCompute;
+#     using Base::setInputCloud;
+# 
+#     /** Updating method flag */
+#     enum FLAG 
+#     {
+#       /** keep the new basis vectors if possible */
+#       increase, 
+#       /** preserve subspace dimension */
+#       preserve
+#     };
+# 
+#     /** \brief Default Constructor
+#       * \param basis_only flag to compute only the PCA basis
+#       */
+#     PCA (bool basis_only = false)
+#       : Base ()
+#       , compute_done_ (false)
+#       , basis_only_ (basis_only) 
+#       , eigenvectors_ ()
+#       , coefficients_ ()
+#       , mean_ ()
+#       , eigenvalues_  ()
+#     {}
+#     
+#     /** \brief Constructor with direct computation
+#       * X input m*n matrix (ie n vectors of R(m))
+#       * basis_only flag to compute only the PCA basis
+#       */
+#     PCL_DEPRECATED ("Use PCA (bool basis_only); setInputCloud (X.makeShared ()); instead")
+#     PCA (const pcl::PointCloud<PointT>& X, bool basis_only = false);
+# 
+#     /** Copy Constructor
+#       * \param[in] pca PCA object
+#       */
+#     PCA (PCA const & pca) 
+#       : Base (pca)
+#       , compute_done_ (pca.compute_done_)
+#       , basis_only_ (pca.basis_only_) 
+#       , eigenvectors_ (pca.eigenvectors_)
+#       , coefficients_ (pca.coefficients_)
+#       , mean_ (pca.mean_)
+#       , eigenvalues_  (pca.eigenvalues_)
+#     {}
+# 
+#     /** Assignment operator
+#       * \param[in] pca PCA object
+#       */
+#     inline PCA& operator= (PCA const & pca) 
+# 
+#     /** \brief Provide a pointer to the input dataset
+#       * \param cloud the const boost shared pointer to a PointCloud message
+#       */
+#     inline void setInputCloud (const PointCloudConstPtr &cloud) 
+# 
+#     /** \brief Mean accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::Vector4f& getMean () 
+# 
+#     /** Eigen Vectors accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::Matrix3f& getEigenVectors () 
+# 
+#     /** Eigen Values accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::Vector3f& getEigenValues ()
+# 
+#     /** Coefficients accessor
+#       * \throw InitFailedException
+#       */
+#     inline Eigen::MatrixXf& getCoefficients () 
+# 
+#     /** update PCA with a new point
+#       * \param[in] input input point 
+#       * \param[in] flag update flag
+#       * \throw InitFailedException
+#       */
+#     inline void update (const PointT& input, FLAG flag = preserve);
+# 
+#     /** Project point on the eigenspace.
+#       * \param[in] input point from original dataset
+#       * \param[out] projection the point in eigen vectors space
+#       * \throw InitFailedException
+#       */
+#     inline void project (const PointT& input, PointT& projection);
+# 
+#     /** Project cloud on the eigenspace.
+#       * \param[in] input cloud from original dataset
+#       * \param[out] projection the cloud in eigen vectors space
+#       * \throw InitFailedException
+#       */
+#     inline void project (const PointCloud& input, PointCloud& projection);
+# 
+#     /** Reconstruct point from its projection
+#       * \param[in] projection point from eigenvector space
+#       * \param[out] input reconstructed point
+#       * \throw InitFailedException
+#       */
+#     inline void reconstruct (const PointT& projection, PointT& input);
+# 
+#     /** Reconstruct cloud from its projection
+#       * \param[in] projection cloud from eigenvector space
+#       * \param[out] input reconstructed cloud
+#       * \throw InitFailedException
+#       */
+#     inline void reconstruct (const PointCloud& projection, PointCloud& input);
+###
+
+# piecewise_linear_function.h
+# namespace pcl
+# cdef extern from "pcl/common/piecewise_linear_function.h" namespace "pcl":
+# /**
+#   * \brief This provides functionalities to efficiently return values for piecewise linear function
+#   * \ingroup common
+#   */
+# class PiecewiseLinearFunction
+#     	public:
+#       // =====CONSTRUCTOR & DESTRUCTOR=====
+#       //! Constructor
+#       PiecewiseLinearFunction (float factor, float offset);
+#       
+#       // =====PUBLIC METHODS=====
+#       //! Get the list of known data points
+#       std::vector<float>& getDataPoints () 
+#       
+#       //! Get the value of the function at the given point
+#       inline float getValue (float point) const;
+#       
+#       // =====PUBLIC MEMBER VARIABLES=====
+#       
+###
+
+# point_operators.h
+###
+
+# point_tests.h
+# namespace pcl
+# {
+#   /** Tests if the 3D components of a point are all finite
+#     * param[in] pt point to be tested
+#     */
+#   template <typename PointT> inline bool
+#   isFinite (const PointT &pt)
+#   {
+#     return (pcl_isfinite (pt.x) && pcl_isfinite (pt.y) && pcl_isfinite (pt.z));
+#   }
+# 
+# #ifdef _MSC_VER
+#   template <typename PointT> inline bool
+#   isFinite (const Eigen::internal::workaround_msvc_stl_support<PointT> &pt)
+#   {
+#     return isFinite<PointT> (static_cast<const PointT&> (pt));
+#   }
+# #endif
+# 
+#   template<> inline bool isFinite<pcl::RGB> (const pcl::RGB&) { return (true); }
+#   template<> inline bool isFinite<pcl::Label> (const pcl::Label&) { return (true); }
+#   template<> inline bool isFinite<pcl::Axis> (const pcl::Axis&) { return (true); }
+#   template<> inline bool isFinite<pcl::Intensity> (const pcl::Intensity&) { return (true); }
+#   template<> inline bool isFinite<pcl::MomentInvariants> (const pcl::MomentInvariants&) { return (true); }
+#   template<> inline bool isFinite<pcl::PrincipalRadiiRSD> (const pcl::PrincipalRadiiRSD&) { return (true); }
+#   template<> inline bool isFinite<pcl::Boundary> (const pcl::Boundary&) { return (true); }
+#   template<> inline bool isFinite<pcl::PrincipalCurvatures> (const pcl::PrincipalCurvatures&) { return (true); }
+#   template<> inline bool isFinite<pcl::SHOT352> (const pcl::SHOT352&) { return (true); }
+#   template<> inline bool isFinite<pcl::SHOT1344> (const pcl::SHOT1344&) { return (true); }
+#   template<> inline bool isFinite<pcl::ReferenceFrame> (const pcl::ReferenceFrame&) { return (true); }
+#   template<> inline bool isFinite<pcl::ShapeContext1980> (const pcl::ShapeContext1980&) { return (true); }
+#   template<> inline bool isFinite<pcl::PFHSignature125> (const pcl::PFHSignature125&) { return (true); }
+#   template<> inline bool isFinite<pcl::PFHRGBSignature250> (const pcl::PFHRGBSignature250&) { return (true); }
+#   template<> inline bool isFinite<pcl::PPFSignature> (const pcl::PPFSignature&) { return (true); }
+#   template<> inline bool isFinite<pcl::PPFRGBSignature> (const pcl::PPFRGBSignature&) { return (true); }
+#   template<> inline bool isFinite<pcl::NormalBasedSignature12> (const pcl::NormalBasedSignature12&) { return (true); }
+#   template<> inline bool isFinite<pcl::FPFHSignature33> (const pcl::FPFHSignature33&) { return (true); }
+#   template<> inline bool isFinite<pcl::VFHSignature308> (const pcl::VFHSignature308&) { return (true); }
+#   template<> inline bool isFinite<pcl::ESFSignature640> (const pcl::ESFSignature640&) { return (true); }
+#   template<> inline bool isFinite<pcl::IntensityGradient> (const pcl::IntensityGradient&) { return (true); }
+# 
+#   // specification for pcl::PointXY
+#   template <> inline bool
+#   isFinite<pcl::PointXY> (const pcl::PointXY &p)
+#   {
+#     return (pcl_isfinite (p.x) && pcl_isfinite (p.y));
+#   }
+# 
+#   // specification for pcl::BorderDescription
+#   template <> inline bool
+#   isFinite<pcl::BorderDescription> (const pcl::BorderDescription &p)
+#   {
+#     return (pcl_isfinite (p.x) && pcl_isfinite (p.y));
+#   }
+# 
+#   // specification for pcl::Normal
+#   template <> inline bool
+#   isFinite<pcl::Normal> (const pcl::Normal &n)
+#   {
+#     return (pcl_isfinite (n.normal_x) && pcl_isfinite (n.normal_y) && pcl_isfinite (n.normal_z));
+#   }
+# }
+###
+
+# polynomial_calculations.h
+# namespace pcl 
+# {
+#   /** \brief This provides some functionality for polynomials,
+#     *         like finding roots or approximating bivariate polynomials
+#     *  \author Bastian Steder 
+#     *  \ingroup common
+#     */
+#   template <typename real>
+#   class PolynomialCalculationsT 
+#   {
+#     public:
+#       // =====CONSTRUCTOR & DESTRUCTOR=====
+#       PolynomialCalculationsT ();
+#       ~PolynomialCalculationsT ();
+#       
+#       // =====PUBLIC STRUCTS=====
+#       //! Parameters used in this class
+#       struct Parameters
+#       {
+#         Parameters () : zero_value (), sqr_zero_value () { setZeroValue (1e-6);}
+#         //! Set zero_value
+#         void
+#         setZeroValue (real new_zero_value);
+# 
+#         real zero_value;       //!< Every value below this is considered to be zero
+#         real sqr_zero_value;   //!< sqr of the above
+#       };
+#       
+#       // =====PUBLIC METHODS=====
+#       /** Solves an equation of the form ax^4 + bx^3 + cx^2 +dx + e = 0
+#        *  See http://en.wikipedia.org/wiki/Quartic_equation#Summary_of_Ferrari.27s_method */
+#       inline void
+#       solveQuarticEquation (real a, real b, real c, real d, real e, std::vector<real>& roots) const;
+# 
+#       /** Solves an equation of the form ax^3 + bx^2 + cx + d = 0
+#        *  See http://en.wikipedia.org/wiki/Cubic_equation */
+#       inline void
+#       solveCubicEquation (real a, real b, real c, real d, std::vector<real>& roots) const;
+# 
+#       /** Solves an equation of the form ax^2 + bx + c = 0
+#        *  See http://en.wikipedia.org/wiki/Quadratic_equation */
+#       inline void
+#       solveQuadraticEquation (real a, real b, real c, std::vector<real>& roots) const;
+# 
+#       /** Solves an equation of the form ax + b = 0 */
+#       inline void
+#       solveLinearEquation (real a, real b, std::vector<real>& roots) const;
+#       
+#       /** Get the bivariate polynomial approximation for Z(X,Y) from the given sample points.
+#        *  The parameters a,b,c,... for the polynom are returned.
+#        *  The order is, e.g., for degree 1: ax+by+c and for degree 2: ax2+bxy+cx+dy2+ey+f.
+#        *  error is set to true if the approximation did not work for any reason
+#        *  (not enough points, matrix not invertible, etc.) */
+#       inline BivariatePolynomialT<real>
+#       bivariatePolynomialApproximation (std::vector<Eigen::Matrix<real, 3, 1> >& samplePoints,
+#                                         unsigned int polynomial_degree, bool& error) const;
+#       
+#       //! Same as above, using a reference for the return value
+#       inline bool
+#       bivariatePolynomialApproximation (std::vector<Eigen::Matrix<real, 3, 1> >& samplePoints,
+#                                         unsigned int polynomial_degree, BivariatePolynomialT<real>& ret) const;
+# 
+#       //! Set the minimum value under which values are considered zero
+#       inline void
+#       setZeroValue (real new_zero_value) { parameters_.setZeroValue(new_zero_value); }
+#       
+#     protected:  
+#       // =====PROTECTED METHODS=====
+#       //! check if fabs(d)<zeroValue
+#       inline bool
+#       isNearlyZero (real d) const 
+#       { 
+#         return (fabs (d) < parameters_.zero_value);
+#       }
+#       
+#       //! check if sqrt(fabs(d))<zeroValue
+#       inline bool
+#       sqrtIsNearlyZero (real d) const 
+#       { 
+#         return (fabs (d) < parameters_.sqr_zero_value);
+#       }
+#       
+#       // =====PROTECTED MEMBERS=====
+#       Parameters parameters_;
+#   };
+# 
+#   typedef PolynomialCalculationsT<double> PolynomialCalculationsd;
+#   typedef PolynomialCalculationsT<float>  PolynomialCalculations;
+# 
+# }  // end namespace
+###
+
+# poses_from_matches.h
+# namespace pcl
+# {
+#   /**
+#     * \brief calculate 3D transformation based on point correspondencdes
+#     * \author Bastian Steder
+#     * \ingroup common
+#     */
+#   class PCL_EXPORTS PosesFromMatches
+#   {
+#     public:
+#       // =====CONSTRUCTOR & DESTRUCTOR=====
+#       //! Constructor
+#       PosesFromMatches();
+#       //! Destructor
+#       ~PosesFromMatches();
+#       
+#       // =====STRUCTS=====
+#       //! Parameters used in this class
+#       struct PCL_EXPORTS Parameters
+#       {
+#         Parameters() : max_correspondence_distance_error(0.2f) {}
+#         float max_correspondence_distance_error;  // As a fraction
+#       };
+# 
+#       //! A result of the pose estimation process
+#       struct PoseEstimate
+#       {
+#         PoseEstimate () : 
+#           transformation (Eigen::Affine3f::Identity ()),
+#           score (0),
+#           correspondence_indices (0) 
+#         {}
+# 
+#         Eigen::Affine3f transformation;   //!< The estimated transformation between the two coordinate systems
+#         float score;                         //!< An estimate in [0,1], how good the estimated pose is 
+#         std::vector<int> correspondence_indices;  //!< The indices of the used correspondences
+# 
+#         struct IsBetter 
+#         {
+#           bool operator()(const PoseEstimate& pe1, const PoseEstimate& pe2) const { return pe1.score>pe2.score;}
+#         };
+#         public:
+#           EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#       };
+#       
+#       // =====TYPEDEFS=====
+#       typedef std::vector<PoseEstimate, Eigen::aligned_allocator<PoseEstimate> > PoseEstimatesVector;
+# 
+#       
+#       // =====STATIC METHODS=====
+#       
+#       // =====PUBLIC METHODS=====
+#       /** Use single 6DOF correspondences to estimate transformations between the coordinate systems.
+#        *  Use max_no_of_results=-1 to use all.
+#        *  It is assumed, that the correspondences are sorted from good to bad. */
+#       void 
+#       estimatePosesUsing1Correspondence (
+#           const PointCorrespondences6DVector& correspondences,
+#           int max_no_of_results, PoseEstimatesVector& pose_estimates) const;
+# 
+#       /** Use pairs of 6DOF correspondences to estimate transformations between the coordinate systems.
+#        *  It is assumed, that the correspondences are sorted from good to bad. */
+#       void 
+#       estimatePosesUsing2Correspondences (
+#           const PointCorrespondences6DVector& correspondences,
+#           int max_no_of_tested_combinations, int max_no_of_results,
+#           PoseEstimatesVector& pose_estimates) const;
+#       
+#       /** Use triples of 6DOF correspondences to estimate transformations between the coordinate systems.
+#        *  It is assumed, that the correspondences are sorted from good to bad. */
+#       void 
+#       estimatePosesUsing3Correspondences (
+#           const PointCorrespondences6DVector& correspondences,
+#           int max_no_of_tested_combinations, int max_no_of_results,
+#           PoseEstimatesVector& pose_estimates) const;
+# 
+#       /// Get a reference to the parameters struct
+#       Parameters& 
+#       getParameters () { return parameters_; }
+# 
+#     protected:
+#       // =====PROTECTED MEMBER VARIABLES=====
+#       Parameters parameters_;
+# 
+#   };
+# 
+# }  // end namespace pcl
+###
+
+# projection_matrix.h
+# namespace pcl
+# {
+#   template <typename T> class PointCloud;
+# 
+#   /** \brief Estimates the projection matrix P = K * (R|-R*t) from organized point clouds, with
+#     *        K = [[fx, s, cx], [0, fy, cy], [0, 0, 1]]
+#     *        R = rotation matrix and
+#     *        t = translation vector  
+#     * 
+#     * \param[in] cloud input cloud. Must be organized and from a projective device. e.g. stereo or kinect, ...
+#     * \param[out] projection_matrix output projection matrix
+#     * \param[in] indices The indices to be used to determine the projection matrix 
+#     * \return the resudial error. A high residual indicates, that the point cloud was not from a projective device.
+#     */
+#   template<typename PointT> double
+#   estimateProjectionMatrix (typename pcl::PointCloud<PointT>::ConstPtr cloud, Eigen::Matrix<float, 3, 4, Eigen::RowMajor>& projection_matrix, const std::vector<int>& indices = std::vector<int> ());
+#   
+#   /** \brief Determines the camera matrix from the given projection matrix.
+#     * \note This method does NOT use a RQ decomposition, but uses the fact that the left 3x3 matrix P' of P squared eliminates the rotational part.
+#     *       P' = K * R -> P' * P'^T = K * R * R^T * K = K * K^T
+#     * \param[in] projection_matrix
+#     * \param[out] camera_matrix
+#     */
+#   PCL_EXPORTS void
+#   getCameraMatrixFromProjectionMatrix (const Eigen::Matrix<float, 3, 4, Eigen::RowMajor>& projection_matrix, Eigen::Matrix3f& camera_matrix);  
+# }
+###
+
+# random.h
+# namespace pcl 
+# {
+#   namespace common 
+#   {
+#     /// uniform distribution dummy struct
+#     template <typename T> struct uniform_distribution;
+#     /// uniform distribution int specialized
+#     template<> 
+#     struct uniform_distribution<int> 
+#     {
+#       typedef boost::uniform_int<int> type;
+#     };
+#     /// uniform distribution float specialized
+#     template<> 
+#     struct uniform_distribution<float> 
+#     {
+#       typedef boost::uniform_real<float> type;
+#     };
+#     ///  normal distribution
+#     template<typename T> 
+#     struct normal_distribution
+#     {
+#       typedef boost::normal_distribution<T> type;
+#     };
+# 
+#     /** \brief UniformGenerator class generates a random number from range [min, max] at each run picked
+#       * according to a uniform distribution i.e eaach number within [min, max] has almost the same 
+#       * probability of being drawn.
+#       *
+#       * \author Nizar Sallem
+#       */
+#     template<typename T>
+#     class UniformGenerator 
+#     {
+#       public:
+#         struct Parameters
+#         {
+#             Parameters (T _min = 0, T _max = 1, pcl::uint32_t _seed = 1)
+#             : min (_min)
+#             , max (_max)
+#             , seed (_seed)
+#           {}
+# 
+#           T min;
+#           T max;
+#           pcl::uint32_t seed;
+#         };
+# 
+#         /** Constructor
+#           * \param min: included lower bound
+#           * \param max: included higher bound
+#           * \param seed: seeding value
+#           */
+#         UniformGenerator(T min = 0, T max = 1, pcl::uint32_t seed = -1);
+# 
+#         /** Constructor
+#           * \param parameters uniform distribution parameters and generator seed
+#           */
+#         UniformGenerator(const Parameters& parameters);
+# 
+#         /** Change seed value
+#           * \param[in] seed new generator seed value
+#           */
+#         void 
+#         setSeed (pcl::uint32_t seed);
+# 
+#         /** Set the uniform number generator parameters
+#           * \param[in] min minimum allowed value
+#           * \param[in] max maximum allowed value
+#           * \param[in] seed random number generator seed (applied if != -1)
+#           */
+#         void 
+#         setParameters (T min, T max, pcl::uint32_t seed = -1);
+# 
+#         /** Set generator parameters
+#           * \param parameters uniform distribution parameters and generator seed
+#           */
+#         void
+#         setParameters (const Parameters& parameters);
+# 
+#         /// \return uniform distribution parameters and generator seed
+#         const Parameters&
+#         getParameters () { return (parameters_); }
+# 
+#         /// \return a randomly generated number in the interval [min, max]
+#         inline T 
+#         run () { return (generator_ ()); }
+# 
+#       private:
+#         typedef boost::mt19937 EngineType;
+#         typedef typename uniform_distribution<T>::type DistributionType;
+#         /// parameters
+#         Parameters parameters_;
+#         /// uniform distribution
+#         DistributionType distribution_;
+#         /// random number generator
+#         EngineType rng_;
+#         /// generator of random number from a uniform distribution
+#         boost::variate_generator<EngineType&, DistributionType> generator_;
+#     };
+# 
+#     /** \brief NormalGenerator class generates a random number from a normal distribution specified
+#       * by (mean, sigma).
+#       *
+#       * \author Nizar Sallem
+#       */
+#     template<typename T>
+#     class NormalGenerator 
+#     {
+#       public:
+#         struct Parameters
+#         {
+#             Parameters (T _mean = 0, T _sigma = 1, pcl::uint32_t _seed = 1)
+#             : mean (_mean)
+#             , sigma (_sigma)
+#             , seed (_seed)
+#           {}
+# 
+#           T mean;
+#           T sigma;
+#           pcl::uint32_t seed;
+#         };
+# 
+#         /** Constructor
+#           * \param[in] mean normal mean
+#           * \param[in] sigma normal variation
+#           * \param[in] seed seeding value
+#           */
+#         NormalGenerator(T mean = 0, T sigma = 1, pcl::uint32_t seed = -1);
+# 
+#         /** Constructor
+#           * \param parameters normal distribution parameters and seed
+#           */
+#         NormalGenerator(const Parameters& parameters);
+# 
+#         /** Change seed value
+#           * \param[in] seed new seed value
+#           */
+#         void 
+#         setSeed (pcl::uint32_t seed);
+# 
+#         /** Set the normal number generator parameters
+#           * \param[in] mean mean of the normal distribution
+#           * \param[in] sigma standard variation of the normal distribution
+#           * \param[in] seed random number generator seed (applied if != -1)
+#           */
+#         void 
+#         setParameters (T mean, T sigma, pcl::uint32_t seed = -1);
+# 
+#         /** Set generator parameters
+#           * \param parameters normal distribution parameters and seed
+#           */
+#         void
+#         setParameters (const Parameters& parameters);
+# 
+#         /// \return normal distribution parameters and generator seed
+#         const Parameters&
+#         getParameters () { return (parameters_); }
+# 
+#         /// \return a randomly generated number in the normal distribution (mean, sigma)
+#         inline T 
+#         run () { return (generator_ ()); }
+# 
+#         typedef boost::mt19937 EngineType;
+#         typedef typename normal_distribution<T>::type DistributionType;
+#         /// parameters
+#         Parameters parameters_;
+#         /// normal distribution
+#         DistributionType distribution_;
+#         /// random number generator
+#         EngineType rng_;
+#         /// generator of random number from a normal distribution
+#         boost::variate_generator<EngineType&, DistributionType > generator_;
+#     };
+#   }
+# }
+###
+
+# register_point_struct.h
+# #include <pcl/pcl_macros.h>
+# #include <pcl/point_traits.h>
+# #include <boost/mpl/vector.hpp>
+# #include <boost/preprocessor/seq/enum.hpp>
+# #include <boost/preprocessor/seq/for_each.hpp>
+# #include <boost/preprocessor/seq/transform.hpp>
+# #include <boost/preprocessor/cat.hpp>
+# #include <boost/preprocessor/comparison.hpp>
+# #include <boost/utility.hpp>
+# //https://bugreports.qt-project.org/browse/QTBUG-22829
+# #ifndef Q_MOC_RUN
+# #include <boost/type_traits.hpp>
+# #endif
+# #include <stddef.h> //offsetof
+# 
+# // Must be used in global namespace with name fully qualified
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT(name, fseq)               \
+#   POINT_CLOUD_REGISTER_POINT_STRUCT_I(name,                         \
+#     BOOST_PP_CAT(POINT_CLOUD_REGISTER_POINT_STRUCT_X fseq, 0))      \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_POINT_WRAPPER(wrapper, pod)    \
+#   BOOST_MPL_ASSERT_MSG(sizeof(wrapper) == sizeof(pod), POINT_WRAPPER_AND_POD_TYPES_HAVE_DIFFERENT_SIZES, (wrapper&, pod&)); \
+#   namespace pcl {                                           \
+#     namespace traits {                                      \
+#       template<> struct POD<wrapper> { typedef pod type; }; \
+#     }                                                       \
+#   }                                                         \
+#   /***/
+# 
+# // These macros help transform the unusual data structure (type, name, tag)(type, name, tag)...
+# // into a proper preprocessor sequence of 3-tuples ((type, name, tag))((type, name, tag))...
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_X(type, name, tag)            \
+#   ((type, name, tag)) POINT_CLOUD_REGISTER_POINT_STRUCT_Y
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_Y(type, name, tag)            \
+#   ((type, name, tag)) POINT_CLOUD_REGISTER_POINT_STRUCT_X
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_X0
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_Y0
+# 
+# namespace pcl
+# {
+#   namespace traits
+#   {
+#     template<typename T> inline
+#     typename boost::disable_if_c<boost::is_array<T>::value>::type
+#     plus (T &l, const T &r)
+#     {
+#       l += r;
+#     }
+# 
+#     template<typename T> inline
+#     typename boost::enable_if_c<boost::is_array<T>::value>::type
+#     plus (typename boost::remove_const<T>::type &l, const T &r)
+#     {
+#       typedef typename boost::remove_all_extents<T>::type type;
+#       static const uint32_t count = sizeof (T) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         l[i] += r[i];
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     plusscalar (T1 &p, const T2 &scalar)
+#     {
+#       p += scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     plusscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] += scalar;
+#     }
+# 
+#     template<typename T> inline
+#     typename boost::disable_if_c<boost::is_array<T>::value>::type
+#     minus (T &l, const T &r)
+#     {
+#       l -= r;
+#     }
+# 
+#     template<typename T> inline
+#     typename boost::enable_if_c<boost::is_array<T>::value>::type
+#     minus (typename boost::remove_const<T>::type &l, const T &r)
+#     {
+#       typedef typename boost::remove_all_extents<T>::type type;
+#       static const uint32_t count = sizeof (T) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         l[i] -= r[i];
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     minusscalar (T1 &p, const T2 &scalar)
+#     {
+#       p -= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     minusscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] -= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     mulscalar (T1 &p, const T2 &scalar)
+#     {
+#       p *= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     mulscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] *= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::disable_if_c<boost::is_array<T1>::value>::type
+#     divscalar (T1 &p, const T2 &scalar)
+#     {
+#       p /= scalar;
+#     }
+# 
+#     template<typename T1, typename T2> inline
+#     typename boost::enable_if_c<boost::is_array<T1>::value>::type
+#     divscalar (T1 &p, const T2 &scalar)
+#     {
+#       typedef typename boost::remove_all_extents<T1>::type type;
+#       static const uint32_t count = sizeof (T1) / sizeof (type);
+#       for (int i = 0; i < count; ++i)
+#         p[i] /= scalar;
+#     }
+#   }
+# }
+# 
+# // Point operators
+# #define PCL_PLUSEQ_POINT_TAG(r, data, elem)                \
+#   pcl::traits::plus (lhs.BOOST_PP_TUPLE_ELEM(3, 1, elem),  \
+#                      rhs.BOOST_PP_TUPLE_ELEM(3, 1, elem)); \
+#   /***/
+# 
+# #define PCL_PLUSEQSC_POINT_TAG(r, data, elem)                 \
+#   pcl::traits::plusscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                            scalar);                           \
+#   /***/
+#    //p.BOOST_PP_TUPLE_ELEM(3, 1, elem) += scalar;  \
+# 
+# #define PCL_MINUSEQ_POINT_TAG(r, data, elem)                \
+#   pcl::traits::minus (lhs.BOOST_PP_TUPLE_ELEM(3, 1, elem),  \
+#                       rhs.BOOST_PP_TUPLE_ELEM(3, 1, elem)); \
+#   /***/
+# 
+# #define PCL_MINUSEQSC_POINT_TAG(r, data, elem)                 \
+#   pcl::traits::minusscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                             scalar);                           \
+#   /***/
+#    //p.BOOST_PP_TUPLE_ELEM(3, 1, elem) -= scalar;   \
+# 
+# #define PCL_MULEQSC_POINT_TAG(r, data, elem)                 \
+#   pcl::traits::mulscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                             scalar);                         \
+#   /***/
+# 
+# #define PCL_DIVEQSC_POINT_TAG(r, data, elem)   \
+#   pcl::traits::divscalar (p.BOOST_PP_TUPLE_ELEM(3, 1, elem), \
+#                             scalar);                         \
+#   /***/
+# 
+# // Construct type traits given full sequence of (type, name, tag) triples
+# //  BOOST_MPL_ASSERT_MSG(boost::is_pod<name>::value,
+# //                       REGISTERED_POINT_TYPE_MUST_BE_PLAIN_OLD_DATA, (name));
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_I(name, seq)                           \
+#   namespace pcl                                                                  \
+#   {                                                                              \
+#     namespace fields                                                             \
+#     {                                                                            \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_TAG, name, seq)           \
+#     }                                                                            \
+#     namespace traits                                                             \
+#     {                                                                            \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_NAME, name, seq)          \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_OFFSET, name, seq)        \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_DATATYPE, name, seq)      \
+#       POINT_CLOUD_REGISTER_POINT_FIELD_LIST(name, POINT_CLOUD_EXTRACT_TAGS(seq)) \
+#     }                                                                            \
+#     namespace common                                           \
+#     {                                                          \
+#       inline const name&                                       \
+#       operator+= (name& lhs, const name& rhs)                  \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_PLUSEQ_POINT_TAG, _, seq)    \
+#         return (lhs);                                          \
+#       }                                                        \
+#       inline const name&                                       \
+#       operator+= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_PLUSEQSC_POINT_TAG, _, seq)  \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator+ (const name& lhs, const name& rhs)   \
+#       { name result = lhs; result += rhs; return (result); }           \
+#       inline const name operator+ (const float& scalar, const name& p) \
+#       { name result = p; result += scalar; return (result); }          \
+#       inline const name operator+ (const name& p, const float& scalar) \
+#       { name result = p; result += scalar; return (result); }          \
+#       inline const name&                                       \
+#       operator-= (name& lhs, const name& rhs)                  \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_MINUSEQ_POINT_TAG, _, seq)   \
+#         return (lhs);                                          \
+#       }                                                        \
+#       inline const name&                                       \
+#       operator-= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_MINUSEQSC_POINT_TAG, _, seq) \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator- (const name& lhs, const name& rhs)   \
+#       { name result = lhs; result -= rhs; return (result); }           \
+#       inline const name operator- (const float& scalar, const name& p) \
+#       { name result = p; result -= scalar; return (result); }          \
+#       inline const name operator- (const name& p, const float& scalar) \
+#       { name result = p; result -= scalar; return (result); }          \
+#       inline const name&                                       \
+#       operator*= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_MULEQSC_POINT_TAG, _, seq)   \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator* (const float& scalar, const name& p) \
+#       { name result = p; result *= scalar; return (result); }          \
+#       inline const name operator* (const name& p, const float& scalar) \
+#       { name result = p; result *= scalar; return (result); }          \
+#       inline const name&                                       \
+#       operator/= (name& p, const float& scalar)                \
+#       {                                                        \
+#         BOOST_PP_SEQ_FOR_EACH(PCL_DIVEQSC_POINT_TAG, _, seq)   \
+#         return (p);                                            \
+#       }                                                        \
+#       inline const name operator/ (const float& scalar, const name& p) \
+#       { name result = p; result /= scalar; return (result); }          \
+#       inline const name operator/ (const name& p, const float& scalar) \
+#       { name result = p; result /= scalar; return (result); }          \
+#     }                                                          \
+#   }                                                            \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_TAG(r, name, elem)   \
+#   struct BOOST_PP_TUPLE_ELEM(3, 2, elem);               \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_NAME(r, point, elem)                 \
+#   template<int dummy>                                                   \
+#   struct name<point, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem), dummy> \
+#   {                                                                     \
+#     static const char value[];                                          \
+#   };                                                                    \
+#                                                                         \
+#   template<int dummy>                                                   \
+#   const char name<point,                                                \
+#                   pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem),         \
+#                   dummy>::value[] =                                     \
+#     BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(3, 2, elem));                \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_OFFSET(r, name, elem)                \
+#   template<> struct offset<name, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)> \
+#   {                                                                     \
+#     static const size_t value = offsetof(name, BOOST_PP_TUPLE_ELEM(3, 1, elem)); \
+#   };                                                                    \
+#   /***/
+# 
+# // \note: the mpl::identity weirdness is to support array types without requiring the
+# // user to wrap them. The basic problem is:
+# // typedef float[81] type; // SYNTAX ERROR!
+# // typedef float type[81]; // OK, can now use "type" as a synonym for float[81]
+# #define POINT_CLOUD_REGISTER_FIELD_DATATYPE(r, name, elem)              \
+#   template<> struct datatype<name, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)> \
+#   {                                                                     \
+#     typedef boost::mpl::identity<BOOST_PP_TUPLE_ELEM(3, 0, elem)>::type type; \
+#     typedef decomposeArray<type> decomposed;                            \
+#     static const uint8_t value = asEnum<decomposed::type>::value;       \
+#     static const uint32_t size = decomposed::value;                     \
+#   };                                                                    \
+#   /***/
+# 
+# #define POINT_CLOUD_TAG_OP(s, data, elem) pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)
+# 
+# #define POINT_CLOUD_EXTRACT_TAGS(seq) BOOST_PP_SEQ_TRANSFORM(POINT_CLOUD_TAG_OP, _, seq)
+# 
+# #define POINT_CLOUD_REGISTER_POINT_FIELD_LIST(name, seq)        \
+#   template<> struct fieldList<name>                             \
+#   {                                                             \
+#     typedef boost::mpl::vector<BOOST_PP_SEQ_ENUM(seq)> type;    \
+#   };                                                            \
+#   /***/
+# 
+# #if defined _MSC_VER
+#   #pragma warning (pop)
+# #endif
+###
+
+# spring.h
+# namespace pcl
+# {
+#   namespace common
+#   {
+#     /** expand point cloud inserting \a amount rows at the 
+#      * top and the bottom of a point cloud and filling them with 
+#      * custom values.
+#      * \param[in] input the input point cloud
+#      * \param[out] output the output point cloud
+#      * \param[in] val the point value to be insterted
+#      * \param[in] amount the amount of rows to be added
+#      */
+#     template <typename PointT> void
+#     expandRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const PointT& val, const size_t& amount);
+# 
+#     /** expand point cloud inserting \a amount columns at 
+#       * the right and the left of a point cloud and filling them with 
+#       * custom values.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] val the point value to be insterted
+#       * \param[in] amount the amount of columns to be added
+#       */
+#     template <typename PointT> void
+#     expandColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                    const PointT& val, const size_t& amount);
+# 
+#     /** expand point cloud duplicating the \a amount top and bottom rows times.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     duplicateRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                    const size_t& amount);
+# 
+#     /** expand point cloud duplicating the \a amount right and left columns
+#       * times.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of cilumns to be added
+#       */
+#     template <typename PointT> void
+#     duplicateColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                       const size_t& amount);
+# 
+#     /** expand point cloud mirroring \a amount top and bottom rows. 
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     mirrorRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const size_t& amount);
+# 
+#     /** expand point cloud mirroring \a amount right and left columns.
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     mirrorColumns (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                    const size_t& amount);
+# 
+#     /** delete \a amount rows in top and bottom of point cloud 
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     deleteRows (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const size_t& amount);
+# 
+#     /** delete \a amount columns in top and bottom of point cloud
+#       * \param[in] input the input point cloud
+#       * \param[out] output the output point cloud
+#       * \param[in] amount the amount of rows to be added
+#       */
+#     template <typename PointT> void
+#     deleteCols (const PointCloud<PointT>& input, PointCloud<PointT>& output, 
+#                 const size_t& amount);
+#   };
+# }
+###
+
+# synchronizer.h
+# namespace pcl
+# {
+#   /** /brief This template class synchronizes two data streams of different types.
+#    *         The data can be added using add0 and add1 methods which expects also a timestamp of type unsigned long.
+#    *         If two matching data objects are found, registered callback functions are invoked with the objects and the time stamps.
+#    *         The only assumption of the timestamp is, that they are in the same unit, linear and strictly monotonic increasing.
+#    *         If filtering is desired, e.g. thresholding of time differences, the user can do that in the callback method.
+#    *         This class is thread safe.
+#    * /ingroup common
+#    */
+#   template <typename T1, typename T2>
+#   class Synchronizer
+#   {
+#     typedef std::pair<unsigned long, T1> T1Stamped;
+#     typedef std::pair<unsigned long, T2> T2Stamped;
+#     boost::mutex mutex1_;
+#     boost::mutex mutex2_;
+#     boost::mutex publish_mutex_;
+#     std::deque<T1Stamped> queueT1;
+#     std::deque<T2Stamped> queueT2;
+# 
+#     typedef boost::function<void(T1, T2, unsigned long, unsigned long) > CallbackFunction;
+# 
+#     std::map<int, CallbackFunction> cb_;
+#     int callback_counter;
+#   public:
+# 
+#     Synchronizer () : mutex1_ (), mutex2_ (), publish_mutex_ (), queueT1 (), queueT2 (), cb_ (), callback_counter (0) { };
+# 
+#     int
+#     addCallback (const CallbackFunction& callback)
+#     {
+#       boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+#       cb_[callback_counter] = callback;
+#       return callback_counter++;
+#     }
+# 
+#     void
+#     removeCallback (int i)
+#     {
+#       boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+#       cb_.erase (i);
+#     }
+# 
+#     void
+#     add0 (const T1& t, unsigned long time)
+#     {
+#       mutex1_.lock ();
+#       queueT1.push_back (T1Stamped (time, t));
+#       mutex1_.unlock ();
+#       publish ();
+#     }
+# 
+#     void
+#     add1 (const T2& t, unsigned long time)
+#     {
+#       mutex2_.lock ();
+#       queueT2.push_back (T2Stamped (time, t));
+#       mutex2_.unlock ();
+#       publish ();
+#     }
+# 
+#   private:
+# 
+#     void
+#     publishData ()
+#     {
+#       boost::unique_lock<boost::mutex> lock1 (mutex1_);
+#       boost::unique_lock<boost::mutex> lock2 (mutex2_);
+# 
+#       for (typename std::map<int, CallbackFunction>::iterator cb = cb_.begin (); cb != cb_.end (); ++cb)
+#       {
+#         if (!cb->second.empty ())
+#         {
+#           cb->second.operator()(queueT1.front ().second, queueT2.front ().second, queueT1.front ().first, queueT2.front ().first);
+#         }
+#       }
+# 
+#       queueT1.pop_front ();
+#       queueT2.pop_front ();
+#     }
+# 
+#     void
+#     publish ()
+#     {
+#       // only one publish call at once allowed
+#       boost::unique_lock<boost::mutex> publish_lock (publish_mutex_);
+# 
+#       boost::unique_lock<boost::mutex> lock1 (mutex1_);
+#       if (queueT1.empty ())
+#         return;
+#       T1Stamped t1 = queueT1.front ();
+#       lock1.unlock ();
+# 
+#       boost::unique_lock<boost::mutex> lock2 (mutex2_);
+#       if (queueT2.empty ())
+#         return;
+#       T2Stamped t2 = queueT2.front ();
+#       lock2.unlock ();
+# 
+#       bool do_publish = false;
+# 
+#       if (t1.first <= t2.first)
+#       { // iterate over queue1
+#         lock1.lock ();
+#         while (queueT1.size () > 1 && queueT1[1].first <= t2.first)
+#           queueT1.pop_front ();
+# 
+#         if (queueT1.size () > 1)
+#         { // we have at least 2 measurements; first in past and second in future -> find out closer one!
+#           if ( (t2.first << 1) > (queueT1[0].first + queueT1[1].first) )
+#             queueT1.pop_front ();
+# 
+#           do_publish = true;
+#         }
+#         lock1.unlock ();
+#       }
+#       else
+#       { // iterate over queue2
+#         lock2.lock ();
+#         while (queueT2.size () > 1 && (queueT2[1].first <= t1.first) )
+#           queueT2.pop_front ();
+# 
+#         if (queueT2.size () > 1)
+#         { // we have at least 2 measurements; first in past and second in future -> find out closer one!
+#           if ( (t1.first << 1) > queueT2[0].first + queueT2[1].first )
+#             queueT2.pop_front ();
+# 
+#           do_publish = true;
+#         }
+#         lock2.unlock ();
+#       }
+# 
+#       if (do_publish)
+#         publishData ();
+#     }
+#   } ;
+# } // namespace
+###
+
+# time.h
+# namespace pcl
+# {
+#   /** \brief Simple stopwatch.
+#     * \ingroup common
+#     */
+#   class StopWatch
+#   {
+#     public:
+#       /** \brief Constructor. */
+#       StopWatch () : start_time_ (boost::posix_time::microsec_clock::local_time ())
+#       {
+#       }
+# 
+#       /** \brief Destructor. */
+#       virtual ~StopWatch () {}
+# 
+#       /** \brief Retrieve the time in milliseconds spent since the last call to \a reset(). */
+#       inline double
+#       getTime ()
+#       {
+#         boost::posix_time::ptime end_time = boost::posix_time::microsec_clock::local_time ();
+#         return (static_cast<double> (((end_time - start_time_).total_milliseconds ())));
+#       }
+# 
+#       /** \brief Retrieve the time in seconds spent since the last call to \a reset(). */
+#       inline double
+#       getTimeSeconds ()
+#       {
+#         return (getTime () * 0.001f);
+#       }
+# 
+#       /** \brief Reset the stopwatch to 0. */
+#       inline void
+#       reset ()
+#       {
+#         start_time_ = boost::posix_time::microsec_clock::local_time ();
+#       }
+# 
+#     protected:
+#       boost::posix_time::ptime start_time_;
+#   };
+# 
+#   /** \brief Class to measure the time spent in a scope
+#     *
+#     * To use this class, e.g. to measure the time spent in a function,
+#     * just create an instance at the beginning of the function. Example:
+#     *
+#     * \code
+#     * {
+#     *   pcl::ScopeTime t1 ("calculation");
+#     *
+#     *   // ... perform calculation here
+#     * }
+#     * \endcode
+#     *
+#     * \ingroup common
+#     */
+#   class ScopeTime : public StopWatch
+#   {
+#     public:
+#       inline ScopeTime (const char* title) : 
+#         title_ (std::string (title))
+#       {
+#         start_time_ = boost::posix_time::microsec_clock::local_time ();
+#       }
+# 
+#       inline ScopeTime () :
+#         title_ (std::string (""))
+#       {
+#         start_time_ = boost::posix_time::microsec_clock::local_time ();
+#       }
+# 
+#       inline ~ScopeTime ()
+#       {
+#         double val = this->getTime ();
+#         std::cerr << title_ << " took " << val << "ms.\n";
+#       }
+#   };
+# 
+# 
+# #ifndef MEASURE_FUNCTION_TIME
+# #define MEASURE_FUNCTION_TIME \
+#   ScopeTime scopeTime(__func__)
+# #endif
+# 
+# inline double getTime ()
+# 
+# /// Executes code, only if secs are gone since last exec.
+# #ifndef DO_EVERY_TS
+# #define DO_EVERY_TS(secs, currentTime, code) \
+# if (1) {\
+#   static double s_lastDone_ = 0.0; \
+#   double s_now_ = (currentTime); \
+#   if (s_lastDone_ > s_now_) \
+#     s_lastDone_ = s_now_; \
+#   if ((s_now_ - s_lastDone_) > (secs)) {        \
+#     code; \
+#     s_lastDone_ = s_now_; \
+#   }\
+# } else \
+#   (void)0
+# #endif
+# 
+# /// Executes code, only if secs are gone since last exec.
+# #ifndef DO_EVERY
+# #define DO_EVERY(secs, code) \
+#   DO_EVERY_TS(secs, pcl::getTime(), code)
+# #endif
+# 
+# }  // end namespace
+# /*@}*/
+###
+
+# time_trigger.h
+# namespace pcl
+# {
+#   /** \brief Timer class that invokes registered callback methods periodically.
+#     * \ingroup common
+#     */
+#   class PCL_EXPORTS TimeTrigger
+#   {
+#     public:
+#       typedef boost::function<void() > callback_type;
+# 
+#       /** \brief Timer class that calls a callback method periodically. Due to possible blocking calls, only one callback method can be registered per instance.
+#         * \param[in] interval_seconds interval in seconds
+#         * \param[in] callback callback to be invoked periodically
+#         */
+#       TimeTrigger (double interval_seconds, const callback_type& callback);
+# 
+#       /** \brief Timer class that calls a callback method periodically. Due to possible blocking calls, only one callback method can be registered per instance.
+#         * \param[in] interval_seconds interval in seconds
+#         */
+#       TimeTrigger (double interval_seconds = 1.0);
+# 
+#       /** \brief Destructor. */
+#       ~TimeTrigger ();
+# 
+#       /** \brief registeres a callback
+#         * \param[in] callback callback function to the list of callbacks. signature has to be boost::function<void()>
+#         * \return connection the connection, which can be used to disable/enable and remove callback from list
+#         */
+#       boost::signals2::connection registerCallback (const callback_type& callback);
+# 
+#       /** \brief Resets the timer interval
+#         * \param[in] interval_seconds interval in seconds
+#         */
+#       void 
+#       setInterval (double interval_seconds);
+# 
+#       /** \brief Start the Trigger. */
+#       void 
+#       start ();
+# 
+#       /** \brief Stop the Trigger. */
+#       void 
+#       stop ();
+#     private:
+#       void 
+#       thread_function ();
+#       boost::signals2::signal <void() > callbacks_;
+# 
+#       double interval_;
+# 
+#       bool quit_;
+#       bool running_;
+# 
+#       boost::thread timer_thread_;
+#       boost::condition_variable condition_;
+#       boost::mutex condition_mutex_;
+#   };
+# }
+###
+
+# transformation_from_correspondences.h
+# namespace pcl 
+# {
+#   /**
+#     * \brief Calculates a transformation based on corresponding 3D points
+#     * \author Bastian Steder
+#     * \ingroup common
+#     */
+#   class TransformationFromCorrespondences 
+#   {
+#      public:
+#         //-----CONSTRUCTOR&DESTRUCTOR-----
+#         /** Constructor - dimension gives the size of the vectors to work with. */
+#         TransformationFromCorrespondences () : 
+#           no_of_samples_ (0), accumulated_weight_ (0), 
+#           mean1_ (Eigen::Vector3f::Identity ()),
+#           mean2_ (Eigen::Vector3f::Identity ()),
+#           covariance_ (Eigen::Matrix<float, 3, 3>::Identity ())
+#         { reset (); }
+# 
+#         /** Destructor */
+#         ~TransformationFromCorrespondences () { };
+#         
+#         //-----METHODS-----
+#         /** Reset the object to work with a new data set */
+#         inline void 
+#         reset ();
+#         
+#         /** Get the summed up weight of all added vectors */
+#         inline float 
+#         getAccumulatedWeight () const { return accumulated_weight_;}
+#         
+#         /** Get the number of added vectors */
+#         inline unsigned int 
+#         getNoOfSamples () { return no_of_samples_;}
+#         
+#         /** Add a new sample */
+#         inline void 
+#         add (const Eigen::Vector3f& point, const Eigen::Vector3f& corresponding_point, float weight=1.0);
+#         
+#         /** Calculate the transformation that will best transform the points into their correspondences */
+#         inline Eigen::Affine3f 
+#         getTransformation ();
+#         
+#         //-----VARIABLES-----
+#         
+#   };
+# 
+# }  // END namespace
+###
+
+# transforms.h
+# namespace pcl
+# /** \brief Apply an affine transform defined by an Eigen Transform
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Affine3f &transform)
+# 
+# /** \brief Apply an affine transform defined by an Eigen Transform
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Affine3f &transform)
+# 
+# /** \brief Apply an affine transform defined by an Eigen Transform
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Affine3f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Affine3f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Affine3f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const pcl::PointIndices &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const pcl::PointIndices &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Affine3f &transform)
+# 
+# /** \brief Apply a rigid transform defined by a 4x4 matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform a rigid transformation 
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix4f &transform)
+# 
+# /** \brief Apply a rigid transform defined by a 4x4 matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform a rigid transformation 
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const std::vector<int> &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix4f &transform)
+# 
+# /** \brief Apply a rigid transform defined by a 4x4 matrix
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform a rigid transformation 
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, 
+#                      const pcl::PointIndices &indices, 
+#                      pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix4f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix4f &transform)
+# 
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 4, 4> &transform)
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, 
+#                                 const std::vector<int> &indices, 
+#                                 pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix4f &transform)
+###
+
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[in] indices the set of point indices to use from the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] transform an affine transformation (typically a rigid transformation)
+#   * \note Can be used with cloud_in equal to cloud_out
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, const pcl::PointIndices &indices, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 4, 4> &transform)
+###
+
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, const pcl::PointIndices &indices, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix4f &transform)
+###
+
+# /** \brief Apply a rigid transform defined by a 3D offset and a quaternion
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] offset the translation component of the rigid transformation
+#   * \param[in] rotation the rotation component of the rigid transformation
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Matrix<Scalar, 3, 1> &offset, const Eigen::Quaternion<Scalar> &rotation);
+###
+
+# template <typename PointT> inline void 
+# transformPointCloud (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                      const Eigen::Vector3f &offset, const Eigen::Quaternionf &rotation)
+###
+
+# /** \brief Transform a point cloud and rotate its normals using an Eigen transform.
+#   * \param[in] cloud_in the input point cloud
+#   * \param[out] cloud_out the resultant output point cloud
+#   * \param[in] offset the translation component of the rigid transformation
+#   * \param[in] rotation the rotation component of the rigid transformation
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Matrix<Scalar, 3, 1> &offset, const Eigen::Quaternion<Scalar> &rotation);
+# 
+# template <typename PointT> void 
+# transformPointCloudWithNormals (const pcl::PointCloud<PointT> &cloud_in, pcl::PointCloud<PointT> &cloud_out, 
+#                                 const Eigen::Vector3f &offset, const Eigen::Quaternionf &rotation)
+###
+
+# /** \brief Transform a point with members x,y,z
+#   * \param[in] point the point to transform
+#   * \param[out] transform the transformation to apply
+#   * \return the transformed point
+#   * \ingroup common
+#   */
+# template <typename PointT, typename Scalar> inline PointT
+# transformPoint (const PointT &point, const Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+###
+
+# template <typename PointT> inline PointT transformPoint (const PointT &point, const Eigen::Affine3f &transform)
+###
+
+# /** \brief Calculates the principal (PCA-based) alignment of the point cloud
+#   * \param[in] cloud the input point cloud
+#   * \param[out] transform the resultant transform
+#   * \return the ratio lambda1/lambda2 or lambda2/lambda3, whatever is closer to 1.
+#   * \note If the return value is close to one then the transformation might be not unique -> two principal directions have
+#   * almost same variance (extend)
+#   */
+# template <typename PointT, typename Scalar> inline double
+# getPrincipalTransformation (const pcl::PointCloud<PointT> &cloud, Eigen::Transform<Scalar, 3, Eigen::Affine> &transform);
+# 
+# template <typename PointT> inline double getPrincipalTransformation (const pcl::PointCloud<PointT> &cloud, Eigen::Affine3f &transform)
+###
+
+# utils.h
+# namespace pcl
+# namespace utils
+# /** \brief Check if val1 and val2 are equals to an epsilon extent
+#   * \param[in] val1 first number to check
+#   * \param[in] val2 second number to check
+#   * \param[in] eps epsilon
+#   * \return true if val1 is equal to val2, false otherwise.
+#   */
+# template<typename T> bool equal (T val1, T val2, T eps = std::numeric_limits<T>::min ())
+###
+
+# vector_average.h
+# namespace pcl 
+# /** \brief Calculates the weighted average and the covariance matrix
+#   *
+#   * A class to calculate the weighted average and the covariance matrix of a set of vectors with given weights.
+#   * The original data is not saved. Mean and covariance are calculated iteratively.
+#   * \author Bastian Steder
+#   * \ingroup common
+#   */
+# template <typename real, int dimension>
+# class VectorAverage 
+#      public:
+#         //-----CONSTRUCTOR&DESTRUCTOR-----
+#         /** Constructor - dimension gives the size of the vectors to work with. */
+#         VectorAverage ();
+#         /** Destructor */
+#         ~VectorAverage () {}
+#         
+#         //-----METHODS-----
+#         /** Reset the object to work with a new data set */
+#         inline void 
+#         reset ();
+#         
+#         /** Get the mean of the added vectors */
+#         inline const
+#         Eigen::Matrix<real, dimension, 1>& getMean () const { return mean_;}
+#         
+#         /** Get the covariance matrix of the added vectors */
+#         inline const
+#         Eigen::Matrix<real, dimension, dimension>& getCovariance () const { return covariance_;}
+#         
+#         /** Get the summed up weight of all added vectors */
+#         inline real
+#         getAccumulatedWeight () const { return accumulatedWeight_;}
+#         
+#         /** Get the number of added vectors */
+#         inline unsigned int
+#         getNoOfSamples () { return noOfSamples_;}
+#         
+#         /** Add a new sample */
+#         inline void add (const Eigen::Matrix<real, dimension, 1>& sample, real weight=1.0);
+# 
+#         /** Do Principal component analysis */
+#         inline void
+#         doPCA (Eigen::Matrix<real, dimension, 1>& eigen_values, Eigen::Matrix<real, dimension, 1>& eigen_vector1,
+#                Eigen::Matrix<real, dimension, 1>& eigen_vector2, Eigen::Matrix<real, dimension, 1>& eigen_vector3) const;
+#         
+#         /** Do Principal component analysis */
+#         inline void doPCA (Eigen::Matrix<real, dimension, 1>& eigen_values) const;
+#         
+#         /** Get the eigenvector corresponding to the smallest eigenvalue */
+#         inline void getEigenVector1 (Eigen::Matrix<real, dimension, 1>& eigen_vector1) const;
+#         
+#         //-----VARIABLES-----
+#   };
+# 
+#   typedef VectorAverage<float, 2> VectorAverage2f;
+#   typedef VectorAverage<float, 3> VectorAverage3f;
+#   typedef VectorAverage<float, 4> VectorAverage4f;
+# }  // END namespace
+###
+
+### end of vector_average.h file ###
+
diff --git a/pcl/pcl_compression_172.txt b/pcl/pcl_compression_172.txt
new file mode 100644
index 0000000..88c24b9
--- /dev/null
+++ b/pcl/pcl_compression_172.txt
@@ -0,0 +1,1106 @@
+# color_coding.h
+namespace pcl
+{
+  namespace octree
+  {
+    using namespace std;
+
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /** \brief @b ColorCoding class
+     *  \note This class encodes 8-bit color information for octree-based point cloud compression.
+     *  \note
+     *  \note typename: PointT: type of point used in pointcloud
+     *  \author Julius Kammerl (julius@kammerl.de)
+     */
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template<typename PointT>
+      class ColorCoding
+      {
+
+      // public typedefs
+        typedef pcl::PointCloud<PointT> PointCloud;
+        typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+
+      public:
+
+        /** \brief Constructor.
+         *
+         * */
+        ColorCoding () :
+          output_ (), pointAvgColorDataVector_ (), pointAvgColorDataVector_Iterator_ (),
+          pointDiffColorDataVector_ (), pointDiffColorDataVector_Iterator_ (), colorBitReduction_ (0)
+        {
+        }
+
+        /** \brief Empty class constructor. */
+        virtual
+        ~ColorCoding ()
+        {
+        }
+
+        /** \brief Define color bit depth of encoded color information.
+          * \param bitDepth_arg: amounts of bits for representing one color component
+          */
+        inline
+        void
+        setBitDepth (unsigned char bitDepth_arg)
+        {
+          colorBitReduction_ = static_cast<unsigned char> (8 - bitDepth_arg);
+        }
+
+        /** \brief Retrieve color bit depth of encoded color information.
+          * \return amounts of bits for representing one color component
+          */
+        inline unsigned char
+        getBitDepth ()
+        {
+          return (static_cast<unsigned char> (8 - colorBitReduction_));
+        }
+
+        /** \brief Set amount of voxels containing point color information and reserve memory
+          * \param voxelCount_arg: amounts of voxels
+          */
+        inline void
+        setVoxelCount (unsigned int voxelCount_arg)
+        {
+          pointAvgColorDataVector_.reserve (voxelCount_arg * 3);
+        }
+
+        /** \brief Set amount of points within point cloud to be encoded and reserve memory
+         *  \param pointCount_arg: amounts of points within point cloud
+         * */
+        inline
+        void
+        setPointCount (unsigned int pointCount_arg)
+        {
+          pointDiffColorDataVector_.reserve (pointCount_arg * 3);
+        }
+
+        /** \brief Initialize encoding of color information
+         * */
+        void
+        initializeEncoding ()
+        {
+          pointAvgColorDataVector_.clear ();
+
+          pointDiffColorDataVector_.clear ();
+        }
+
+        /** \brief Initialize decoding of color information
+         * */
+        void
+        initializeDecoding ()
+        {
+          pointAvgColorDataVector_Iterator_ = pointAvgColorDataVector_.begin ();
+
+          pointDiffColorDataVector_Iterator_ = pointDiffColorDataVector_.begin ();
+        }
+
+        /** \brief Get reference to vector containing averaged color data
+         * */
+        std::vector<char>&
+        getAverageDataVector ()
+        {
+          return pointAvgColorDataVector_;
+        }
+
+        /** \brief Get reference to vector containing differential color data
+         * */
+        std::vector<char>&
+        getDifferentialDataVector ()
+        {
+          return pointDiffColorDataVector_;
+        }
+
+        /** \brief Encode averaged color information for a subset of points from point cloud
+         * \param indexVector_arg indices defining a subset of points from points cloud
+         * \param rgba_offset_arg offset to color information
+         * \param inputCloud_arg input point cloud
+         * */
+        void
+        encodeAverageOfPoints (const typename std::vector<int>& indexVector_arg, unsigned char rgba_offset_arg, PointCloudConstPtr inputCloud_arg)
+        {
+          std::size_t i, len;
+
+          unsigned int avgRed;
+          unsigned int avgGreen;
+          unsigned int avgBlue;
+
+          // initialize
+          avgRed = avgGreen = avgBlue = 0;
+
+          // iterate over points
+          len = indexVector_arg.size ();
+          for (i = 0; i < len; i++)
+          {
+            // get color information from points
+            const int& idx = indexVector_arg[i];
+            const char* idxPointPtr = reinterpret_cast<const char*> (&inputCloud_arg->points[idx]);
+            const int& colorInt = *reinterpret_cast<const int*> (idxPointPtr+rgba_offset_arg);
+
+            // add color information
+            avgRed += (colorInt >> 0) & 0xFF;
+            avgGreen += (colorInt >> 8) & 0xFF;
+            avgBlue += (colorInt >> 16) & 0xFF;
+
+          }
+
+          // calculated average color information
+          if (len > 1)
+          {
+            avgRed   /= static_cast<unsigned int> (len);
+            avgGreen /= static_cast<unsigned int> (len);
+            avgBlue  /= static_cast<unsigned int> (len);
+          }
+
+          // remove least significant bits
+          avgRed >>= colorBitReduction_;
+          avgGreen >>= colorBitReduction_;
+          avgBlue >>= colorBitReduction_;
+
+          // add to average color vector
+          pointAvgColorDataVector_.push_back (static_cast<char> (avgRed));
+          pointAvgColorDataVector_.push_back (static_cast<char> (avgGreen));
+          pointAvgColorDataVector_.push_back (static_cast<char> (avgBlue));
+        }
+
+        /** \brief Encode color information of a subset of points from point cloud
+         * \param indexVector_arg indices defining a subset of points from points cloud
+         * \param rgba_offset_arg offset to color information
+         * \param inputCloud_arg input point cloud
+         * */
+        void
+        encodePoints (const typename std::vector<int>& indexVector_arg, unsigned char rgba_offset_arg, PointCloudConstPtr inputCloud_arg)
+        {
+          std::size_t i, len;
+
+          unsigned int avgRed;
+          unsigned int avgGreen;
+          unsigned int avgBlue;
+
+          // initialize
+          avgRed = avgGreen = avgBlue = 0;
+
+          // iterate over points
+          len = indexVector_arg.size ();
+          for (i = 0; i < len; i++)
+          {
+            // get color information from point
+            const int& idx = indexVector_arg[i];
+            const char* idxPointPtr = reinterpret_cast<const char*> (&inputCloud_arg->points[idx]);
+            const int& colorInt = *reinterpret_cast<const int*> (idxPointPtr+rgba_offset_arg);
+
+            // add color information
+            avgRed += (colorInt >> 0) & 0xFF;
+            avgGreen += (colorInt >> 8) & 0xFF;
+            avgBlue += (colorInt >> 16) & 0xFF;
+
+          }
+
+          if (len > 1)
+          {
+            unsigned char diffRed;
+            unsigned char diffGreen;
+            unsigned char diffBlue;
+
+            // calculated average color information
+            avgRed   /= static_cast<unsigned int> (len);
+            avgGreen /= static_cast<unsigned int> (len);
+            avgBlue  /= static_cast<unsigned int> (len);
+
+            // iterate over points for differential encoding
+            for (i = 0; i < len; i++)
+            {
+              const int& idx = indexVector_arg[i];
+              const char* idxPointPtr = reinterpret_cast<const char*> (&inputCloud_arg->points[idx]);
+              const int& colorInt = *reinterpret_cast<const int*> (idxPointPtr+rgba_offset_arg);
+
+              // extract color components and do XOR encoding with predicted average color
+              diffRed = (static_cast<unsigned char> (avgRed)) ^ static_cast<unsigned char> (((colorInt >> 0) & 0xFF));
+              diffGreen = (static_cast<unsigned char> (avgGreen)) ^ static_cast<unsigned char> (((colorInt >> 8) & 0xFF));
+              diffBlue = (static_cast<unsigned char> (avgBlue)) ^ static_cast<unsigned char> (((colorInt >> 16) & 0xFF));
+
+              // remove least significant bits
+              diffRed = static_cast<unsigned char> (diffRed >> colorBitReduction_);
+              diffGreen = static_cast<unsigned char> (diffGreen >> colorBitReduction_);
+              diffBlue = static_cast<unsigned char> (diffBlue >> colorBitReduction_);
+
+              // add to differential color vector
+              pointDiffColorDataVector_.push_back (static_cast<char> (diffRed));
+              pointDiffColorDataVector_.push_back (static_cast<char> (diffGreen));
+              pointDiffColorDataVector_.push_back (static_cast<char> (diffBlue));
+            }
+          }
+
+          // remove least significant bits from average color information
+          avgRed   >>= colorBitReduction_;
+          avgGreen >>= colorBitReduction_;
+          avgBlue  >>= colorBitReduction_;
+
+          // add to differential color vector
+          pointAvgColorDataVector_.push_back (static_cast<char> (avgRed));
+          pointAvgColorDataVector_.push_back (static_cast<char> (avgGreen));
+          pointAvgColorDataVector_.push_back (static_cast<char> (avgBlue));
+
+        }
+
+        /** \brief Decode color information
+          * \param outputCloud_arg output point cloud
+          * \param beginIdx_arg index indicating first point to be assiged with color information
+          * \param endIdx_arg index indicating last point to be assiged with color information
+          * \param rgba_offset_arg offset to color information
+          */
+        void
+        decodePoints (PointCloudPtr outputCloud_arg, std::size_t beginIdx_arg, std::size_t endIdx_arg, unsigned char rgba_offset_arg)
+        {
+          std::size_t i;
+          unsigned int pointCount;
+          unsigned int colorInt;
+
+          assert (beginIdx_arg <= endIdx_arg);
+
+          // amount of points to be decoded
+          pointCount = static_cast<unsigned int> (endIdx_arg - beginIdx_arg);
+
+          // get averaged color information for current voxel
+          unsigned char avgRed = *(pointAvgColorDataVector_Iterator_++);
+          unsigned char avgGreen = *(pointAvgColorDataVector_Iterator_++);
+          unsigned char avgBlue = *(pointAvgColorDataVector_Iterator_++);
+
+          // invert bit shifts during encoding
+          avgRed = static_cast<unsigned char> (avgRed << colorBitReduction_);
+          avgGreen = static_cast<unsigned char> (avgGreen << colorBitReduction_);
+          avgBlue = static_cast<unsigned char> (avgBlue << colorBitReduction_);
+
+          // iterate over points
+          for (i = 0; i < pointCount; i++)
+          {
+            if (pointCount > 1)
+            {
+              // get differential color information from input vector
+              unsigned char diffRed   = static_cast<unsigned char> (*(pointDiffColorDataVector_Iterator_++));
+              unsigned char diffGreen = static_cast<unsigned char> (*(pointDiffColorDataVector_Iterator_++));
+              unsigned char diffBlue  = static_cast<unsigned char> (*(pointDiffColorDataVector_Iterator_++));
+
+              // invert bit shifts during encoding
+              diffRed = static_cast<unsigned char> (diffRed << colorBitReduction_);
+              diffGreen = static_cast<unsigned char> (diffGreen << colorBitReduction_);
+              diffBlue = static_cast<unsigned char> (diffBlue << colorBitReduction_);
+
+              // decode color information
+              colorInt = ((avgRed ^ diffRed) << 0) |
+                         ((avgGreen ^ diffGreen) << 8) |
+                         ((avgBlue ^ diffBlue) << 16);
+            }
+            else
+            {
+              // decode color information
+              colorInt = (avgRed << 0) | (avgGreen << 8) | (avgBlue << 16);
+            }
+
+            char* idxPointPtr = reinterpret_cast<char*> (&outputCloud_arg->points[beginIdx_arg + i]);
+            int& pointColor = *reinterpret_cast<int*> (idxPointPtr+rgba_offset_arg);
+            // assign color to point from point cloud
+            pointColor=colorInt;
+          }
+        }
+
+        /** \brief Set default color to points
+         * \param outputCloud_arg output point cloud
+         * \param beginIdx_arg index indicating first point to be assiged with color information
+         * \param endIdx_arg index indicating last point to be assiged with color information
+         * \param rgba_offset_arg offset to color information
+         * */
+        void
+        setDefaultColor (PointCloudPtr outputCloud_arg, std::size_t beginIdx_arg, std::size_t endIdx_arg, unsigned char rgba_offset_arg)
+        {
+          std::size_t i;
+          unsigned int pointCount;
+
+          assert (beginIdx_arg <= endIdx_arg);
+
+          // amount of points to be decoded
+          pointCount = static_cast<unsigned int> (endIdx_arg - beginIdx_arg);
+
+          // iterate over points
+          for (i = 0; i < pointCount; i++)
+          {
+            char* idxPointPtr = reinterpret_cast<char*> (&outputCloud_arg->points[beginIdx_arg + i]);
+            int& pointColor = *reinterpret_cast<int*> (idxPointPtr+rgba_offset_arg);
+            // assign color to point from point cloud
+            pointColor = defaultColor_;
+          }
+        }
+
+
+      protected:
+
+        /** \brief Pointer to output point cloud dataset. */
+        PointCloudPtr output_;
+
+        /** \brief Vector for storing average color information  */
+        std::vector<char> pointAvgColorDataVector_;
+
+        /** \brief Iterator on average color information vector */
+        std::vector<char>::const_iterator pointAvgColorDataVector_Iterator_;
+
+        /** \brief Vector for storing differential color information  */
+        std::vector<char> pointDiffColorDataVector_;
+
+        /** \brief Iterator on differential color information vector */
+        std::vector<char>::const_iterator pointDiffColorDataVector_Iterator_;
+
+        /** \brief Amount of bits to be removed from color components before encoding */
+        unsigned char colorBitReduction_;
+
+        // frame header identifier
+        static const int defaultColor_;
+
+      };
+
+    // define default color
+    template<typename PointT>
+    const int ColorCoding<PointT>::defaultColor_ = ((255) << 0) |
+                                                   ((255) << 8) |
+                                                   ((255) << 16);
+
+  }
+}
+
+#define PCL_INSTANTIATE_ColorCoding(T) template class PCL_EXPORTS pcl::octree::ColorCoding<T>;
+
+#endif
+###
+
+
+# compression_profiles.h
+namespace pcl
+{
+  namespace io
+  {
+
+    enum compression_Profiles_e
+    {
+      LOW_RES_ONLINE_COMPRESSION_WITHOUT_COLOR,
+      LOW_RES_ONLINE_COMPRESSION_WITH_COLOR,
+
+      MED_RES_ONLINE_COMPRESSION_WITHOUT_COLOR,
+      MED_RES_ONLINE_COMPRESSION_WITH_COLOR,
+
+      HIGH_RES_ONLINE_COMPRESSION_WITHOUT_COLOR,
+      HIGH_RES_ONLINE_COMPRESSION_WITH_COLOR,
+
+      LOW_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR,
+      LOW_RES_OFFLINE_COMPRESSION_WITH_COLOR,
+
+      MED_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR,
+      MED_RES_OFFLINE_COMPRESSION_WITH_COLOR,
+
+      HIGH_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR,
+      HIGH_RES_OFFLINE_COMPRESSION_WITH_COLOR,
+
+      COMPRESSION_PROFILE_COUNT,
+      MANUAL_CONFIGURATION
+    };
+
+    // compression configuration profile
+    struct configurationProfile_t
+    {
+      double pointResolution;
+      const double octreeResolution;
+      bool doVoxelGridDownSampling;
+      unsigned int iFrameRate;
+      const unsigned char colorBitResolution;
+      bool doColorEncoding;
+    };
+
+    // predefined configuration parameters
+    const struct configurationProfile_t compressionProfiles_[COMPRESSION_PROFILE_COUNT] = {
+    {
+    // PROFILE: LOW_RES_ONLINE_COMPRESSION_WITHOUT_COLOR
+       0.01, /* pointResolution = */
+       0.01, /* octreeResolution = */
+       true, /* doVoxelGridDownDownSampling = */
+       50, /* iFrameRate = */
+       4, /* colorBitResolution = */
+       false /* doColorEncoding = */
+    }, {
+    // PROFILE: LOW_RES_ONLINE_COMPRESSION_WITH_COLOR
+        0.01, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        true, /* doVoxelGridDownDownSampling = */
+        50, /* iFrameRate = */
+        4, /* colorBitResolution = */
+        true /* doColorEncoding = */
+    }, {
+    // PROFILE: MED_RES_ONLINE_COMPRESSION_WITHOUT_COLOR
+        0.005, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        false, /* doVoxelGridDownDownSampling = */
+        40, /* iFrameRate = */
+        5, /* colorBitResolution = */
+        false /* doColorEncoding = */
+    }, {
+    // PROFILE: MED_RES_ONLINE_COMPRESSION_WITH_COLOR
+        0.005, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        false, /* doVoxelGridDownDownSampling = */
+        40, /* iFrameRate = */
+        5, /* colorBitResolution = */
+        true /* doColorEncoding = */
+    }, {
+    // PROFILE: HIGH_RES_ONLINE_COMPRESSION_WITHOUT_COLOR
+        0.0001, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        false, /* doVoxelGridDownDownSampling = */
+        30, /* iFrameRate = */
+        7, /* colorBitResolution = */
+        false /* doColorEncoding = */
+    }, {
+    // PROFILE: HIGH_RES_ONLINE_COMPRESSION_WITH_COLOR
+        0.0001, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        false, /* doVoxelGridDownDownSampling = */
+        30, /* iFrameRate = */
+        7, /* colorBitResolution = */
+        true /* doColorEncoding = */
+    }, {
+    // PROFILE: LOW_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR
+        0.01, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        true, /* doVoxelGridDownDownSampling = */
+        100, /* iFrameRate = */
+        4, /* colorBitResolution = */
+        false /* doColorEncoding = */
+    }, {
+    // PROFILE: LOW_RES_OFFLINE_COMPRESSION_WITH_COLOR
+        0.01, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        true, /* doVoxelGridDownDownSampling = */
+        100, /* iFrameRate = */
+        4, /* colorBitResolution = */
+        true /* doColorEncoding = */
+    }, {
+    // PROFILE: MED_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR
+        0.005, /* pointResolution = */
+        0.005, /* octreeResolution = */
+        true, /* doVoxelGridDownDownSampling = */
+        100, /* iFrameRate = */
+        5, /* colorBitResolution = */
+        false /* doColorEncoding = */
+    }, {
+    // PROFILE: MED_RES_OFFLINE_COMPRESSION_WITH_COLOR
+        0.005, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        false, /* doVoxelGridDownDownSampling = */
+        100, /* iFrameRate = */
+        5, /* colorBitResolution = */
+        true /* doColorEncoding = */
+    }, {
+    // PROFILE: HIGH_RES_OFFLINE_COMPRESSION_WITHOUT_COLOR
+        0.0001, /* pointResolution = */
+        0.0001, /* octreeResolution = */
+        true, /* doVoxelGridDownDownSampling = */
+        100, /* iFrameRate = */
+        8, /* colorBitResolution = */
+        false /* doColorEncoding = */
+    }, {
+    // PROFILE: HIGH_RES_OFFLINE_COMPRESSION_WITH_COLOR
+        0.0001, /* pointResolution = */
+        0.01, /* octreeResolution = */
+        false, /* doVoxelGridDownDownSampling = */
+        100, /* iFrameRate = */
+        8, /* colorBitResolution = */
+        true /* doColorEncoding = */
+    }};
+
+  }
+}
+
+
+#endif
+###
+
+
+# entropy_range_coder.h
+namespace pcl
+{
+
+  using boost::uint8_t;
+  using boost::uint32_t;
+  using boost::uint64_t;
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief @b AdaptiveRangeCoder compression class
+   *  \note This class provides adaptive range coding functionality.
+   *  \note Its symbol probability/frequency table is adaptively updated during encoding
+   *  \note
+   *  \author Julius Kammerl (julius@kammerl.de)
+   */
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  class AdaptiveRangeCoder
+  {
+
+  public:
+
+    /** \brief Empty constructor. */
+    AdaptiveRangeCoder () : outputCharVector_ ()
+    {
+    }
+
+    /** \brief Empty deconstructor. */
+    virtual
+    ~AdaptiveRangeCoder ()
+    {
+    }
+
+    /** \brief Encode char vector to output stream
+     * \param inputByteVector_arg input vector
+     * \param outputByteStream_arg output stream containing compressed data
+     * \return amount of bytes written to output stream
+     */
+    unsigned long
+    encodeCharVectorToStream (const std::vector<char>& inputByteVector_arg, std::ostream& outputByteStream_arg);
+
+    /** \brief Decode char stream to output vector
+     * \param inputByteStream_arg input stream of compressed data
+     * \param outputByteVector_arg decompressed output vector
+     * \return amount of bytes read from input stream
+     */
+    unsigned long
+    decodeStreamToCharVector (std::istream& inputByteStream_arg, std::vector<char>& outputByteVector_arg);
+
+  protected:
+    typedef boost::uint32_t DWord; // 4 bytes
+
+  private:
+    /** vector containing compressed data
+     */
+    std::vector<char> outputCharVector_;
+
+  };
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  /** \brief @b StaticRangeCoder compression class
+   *  \note This class provides static range coding functionality.
+   *  \note Its symbol probability/frequency table is precomputed and encoded to the output stream
+   *  \note
+   *  \author Julius Kammerl (julius@kammerl.de)
+   */
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  class StaticRangeCoder
+  {
+    public:
+      /** \brief Constructor. */
+      StaticRangeCoder () :
+        cFreqTable_ (65537), outputCharVector_ ()
+      {
+      }
+
+      /** \brief Empty deconstructor. */
+      virtual
+      ~StaticRangeCoder ()
+      {
+      }
+
+      /** \brief Encode integer vector to output stream
+        * \param[in] inputIntVector_arg input vector
+        * \param[out] outputByterStream_arg output stream containing compressed data
+        * \return amount of bytes written to output stream
+        */
+      unsigned long
+      encodeIntVectorToStream (std::vector<unsigned int>& inputIntVector_arg, std::ostream& outputByterStream_arg);
+
+      /** \brief Decode stream to output integer vector
+       * \param inputByteStream_arg input stream of compressed data
+       * \param outputIntVector_arg decompressed output vector
+       * \return amount of bytes read from input stream
+       */
+      unsigned long
+      decodeStreamToIntVector (std::istream& inputByteStream_arg, std::vector<unsigned int>& outputIntVector_arg);
+
+      /** \brief Encode char vector to output stream
+       * \param inputByteVector_arg input vector
+       * \param outputByteStream_arg output stream containing compressed data
+       * \return amount of bytes written to output stream
+       */
+      unsigned long
+      encodeCharVectorToStream (const std::vector<char>& inputByteVector_arg, std::ostream& outputByteStream_arg);
+
+      /** \brief Decode char stream to output vector
+       * \param inputByteStream_arg input stream of compressed data
+       * \param outputByteVector_arg decompressed output vector
+       * \return amount of bytes read from input stream
+       */
+      unsigned long
+      decodeStreamToCharVector (std::istream& inputByteStream_arg, std::vector<char>& outputByteVector_arg);
+
+    protected:
+      typedef boost::uint32_t DWord; // 4 bytes
+
+      /** \brief Helper function to calculate the binary logarithm
+       * \param n_arg: some value
+       * \return binary logarithm (log2) of argument n_arg
+       */
+      inline double
+      Log2 (double n_arg)
+      {
+        return log (n_arg) / log (2.0);
+      }
+
+    private:
+      /** \brief Vector containing cumulative symbol frequency table. */
+      std::vector<uint64_t> cFreqTable_;
+
+      /** \brief Vector containing compressed data. */
+      std::vector<char> outputCharVector_;
+
+  };
+}
+
+
+//#include "impl/entropy_range_coder.hpp"
+
+#endif
+###
+
+# octree_pointcloud_compression.h
+using namespace pcl::octree;
+
+namespace pcl
+{
+  namespace io
+  {
+    /** \brief @b Octree pointcloud compression class
+     *  \note This class enables compression and decompression of point cloud data based on octree data structures.
+     *  \note
+     *  \note typename: PointT: type of point used in pointcloud
+     *  \author Julius Kammerl (julius@kammerl.de)
+     */
+    template<typename PointT, typename LeafT = OctreeContainerPointIndices,
+        typename BranchT = OctreeContainerEmpty,
+        typename OctreeT = Octree2BufBase<LeafT, BranchT> >
+    class OctreePointCloudCompression : public OctreePointCloud<PointT, LeafT,
+        BranchT, OctreeT>
+    {
+      public:
+        // public typedefs
+        typedef typename OctreePointCloud<PointT, LeafT, BranchT, OctreeT>::PointCloud PointCloud;
+        typedef typename OctreePointCloud<PointT, LeafT, BranchT, OctreeT>::PointCloudPtr PointCloudPtr;
+        typedef typename OctreePointCloud<PointT, LeafT, BranchT, OctreeT>::PointCloudConstPtr PointCloudConstPtr;
+
+        // Boost shared pointers
+        typedef boost::shared_ptr<OctreePointCloudCompression<PointT, LeafT, BranchT, OctreeT> > Ptr;
+        typedef boost::shared_ptr<const OctreePointCloudCompression<PointT, LeafT, BranchT, OctreeT> > ConstPtr;
+
+        typedef typename OctreeT::LeafNode LeafNode;
+        typedef typename OctreeT::BranchNode BranchNode;
+
+        typedef OctreePointCloudCompression<PointT, LeafT, BranchT, Octree2BufBase<LeafT, BranchT> > RealTimeStreamCompression;
+        typedef OctreePointCloudCompression<PointT, LeafT, BranchT, OctreeBase<LeafT, BranchT> > SinglePointCloudCompressionLowMemory;
+
+
+        /** \brief Constructor
+          * \param compressionProfile_arg:  define compression profile
+          * \param octreeResolution_arg:  octree resolution at lowest octree level
+          * \param pointResolution_arg:  precision of point coordinates
+          * \param doVoxelGridDownDownSampling_arg:  voxel grid filtering
+          * \param iFrameRate_arg:  i-frame encoding rate
+          * \param doColorEncoding_arg:  enable/disable color coding
+          * \param colorBitResolution_arg:  color bit depth
+          * \param showStatistics_arg:  output compression statistics
+          */
+        OctreePointCloudCompression (compression_Profiles_e compressionProfile_arg = MED_RES_ONLINE_COMPRESSION_WITH_COLOR,
+                               bool showStatistics_arg = false,
+                               const double pointResolution_arg = 0.001,
+                               const double octreeResolution_arg = 0.01,
+                               bool doVoxelGridDownDownSampling_arg = false,
+                               const unsigned int iFrameRate_arg = 30,
+                               bool doColorEncoding_arg = true,
+                               const unsigned char colorBitResolution_arg = 6) :
+          OctreePointCloud<PointT, LeafT, BranchT, OctreeT> (octreeResolution_arg),
+          output_ (PointCloudPtr ()),
+          binary_tree_data_vector_ (),
+          binary_color_tree_vector_ (),
+          point_count_data_vector_ (),
+          point_count_data_vector_iterator_ (),
+          color_coder_ (),
+          point_coder_ (),
+          entropy_coder_ (),
+          do_voxel_grid_enDecoding_ (doVoxelGridDownDownSampling_arg), i_frame_rate_ (iFrameRate_arg),
+          i_frame_counter_ (0), frame_ID_ (0), point_count_ (0), i_frame_ (true),
+          do_color_encoding_ (doColorEncoding_arg), cloud_with_color_ (false), data_with_color_ (false),
+          point_color_offset_ (0), b_show_statistics_ (showStatistics_arg), 
+          compressed_point_data_len_ (), compressed_color_data_len_ (), selected_profile_(compressionProfile_arg),
+          point_resolution_(pointResolution_arg), octree_resolution_(octreeResolution_arg),
+          color_bit_resolution_(colorBitResolution_arg),
+          object_count_(0)
+        {
+          initialization();
+        }
+
+        /** \brief Empty deconstructor. */
+        virtual
+        ~OctreePointCloudCompression ()
+        {
+        }
+
+        /** \brief Initialize globals */
+        void initialization () {
+          if (selected_profile_ != MANUAL_CONFIGURATION)
+          {
+            // apply selected compression profile
+
+            // retrieve profile settings
+            const configurationProfile_t selectedProfile = compressionProfiles_[selected_profile_];
+
+            // apply profile settings
+            i_frame_rate_ = selectedProfile.iFrameRate;
+            do_voxel_grid_enDecoding_ = selectedProfile.doVoxelGridDownSampling;
+            this->setResolution (selectedProfile.octreeResolution);
+            point_coder_.setPrecision (static_cast<float> (selectedProfile.pointResolution));
+            do_color_encoding_ = selectedProfile.doColorEncoding;
+            color_coder_.setBitDepth (selectedProfile.colorBitResolution);
+
+          }
+          else 
+          {
+            // configure point & color coder
+            point_coder_.setPrecision (static_cast<float> (point_resolution_));
+            color_coder_.setBitDepth (color_bit_resolution_);
+          }
+
+          if (point_coder_.getPrecision () == this->getResolution ())
+            //disable differential point colding
+            do_voxel_grid_enDecoding_ = true;
+
+        }
+
+        /** \brief Add point at index from input pointcloud dataset to octree
+         * \param[in] pointIdx_arg the index representing the point in the dataset given by \a setInputCloud to be added
+         */
+        virtual void
+        addPointIdx (const int pointIdx_arg)
+        {
+          ++object_count_;
+          OctreePointCloud<PointT, LeafT, BranchT, OctreeT>::addPointIdx(pointIdx_arg);
+        }
+
+        /** \brief Provide a pointer to the output data set.
+          * \param cloud_arg: the boost shared pointer to a PointCloud message
+          */
+        inline void
+        setOutputCloud (const PointCloudPtr &cloud_arg)
+        {
+          if (output_ != cloud_arg)
+          {
+            output_ = cloud_arg;
+          }
+        }
+
+        /** \brief Get a pointer to the output point cloud dataset.
+          * \return pointer to pointcloud output class.
+          */
+        inline PointCloudPtr
+        getOutputCloud () const
+        {
+          return (output_);
+        }
+
+        /** \brief Encode point cloud to output stream
+          * \param cloud_arg:  point cloud to be compressed
+          * \param compressed_tree_data_out_arg:  binary output stream containing compressed data
+          */
+        void
+        encodePointCloud (const PointCloudConstPtr &cloud_arg, std::ostream& compressed_tree_data_out_arg);
+
+        /** \brief Decode point cloud from input stream
+          * \param compressed_tree_data_in_arg: binary input stream containing compressed data
+          * \param cloud_arg: reference to decoded point cloud
+          */
+        void
+        decodePointCloud (std::istream& compressed_tree_data_in_arg, PointCloudPtr &cloud_arg);
+
+      protected:
+
+        /** \brief Write frame information to output stream
+          * \param compressed_tree_data_out_arg: binary output stream
+          */
+        void
+        writeFrameHeader (std::ostream& compressed_tree_data_out_arg);
+
+        /** \brief Read frame information to output stream
+          * \param compressed_tree_data_in_arg: binary input stream
+          */
+        void
+        readFrameHeader (std::istream& compressed_tree_data_in_arg);
+
+        /** \brief Synchronize to frame header
+          * \param compressed_tree_data_in_arg: binary input stream
+          */
+        void
+        syncToHeader (std::istream& compressed_tree_data_in_arg);
+
+        /** \brief Apply entropy encoding to encoded information and output to binary stream
+          * \param compressed_tree_data_out_arg: binary output stream
+          */
+        void
+        entropyEncoding (std::ostream& compressed_tree_data_out_arg);
+
+        /** \brief Entropy decoding of input binary stream and output to information vectors
+          * \param compressed_tree_data_in_arg: binary input stream
+          */
+        void
+        entropyDecoding (std::istream& compressed_tree_data_in_arg);
+
+        /** \brief Encode leaf node information during serialization
+          * \param leaf_arg: reference to new leaf node
+          * \param key_arg: octree key of new leaf node
+         */
+        virtual void
+        serializeTreeCallback (LeafT &leaf_arg, const OctreeKey& key_arg);
+
+        /** \brief Decode leaf nodes information during deserialization
+         * \param key_arg octree key of new leaf node
+         */
+        // param leaf_arg reference to new leaf node
+        virtual void
+        deserializeTreeCallback (LeafT&, const OctreeKey& key_arg);
+
+
+        /** \brief Pointer to output point cloud dataset. */
+        PointCloudPtr output_;
+
+        /** \brief Vector for storing binary tree structure */
+        std::vector<char> binary_tree_data_vector_;
+
+        /** \brief Interator on binary tree structure vector */
+        std::vector<char> binary_color_tree_vector_;
+
+        /** \brief Vector for storing points per voxel information  */
+        std::vector<unsigned int> point_count_data_vector_;
+
+        /** \brief Interator on points per voxel vector */
+        std::vector<unsigned int>::const_iterator point_count_data_vector_iterator_;
+
+        /** \brief Color coding instance */
+        ColorCoding<PointT> color_coder_;
+
+        /** \brief Point coding instance */
+        PointCoding<PointT> point_coder_;
+
+        /** \brief Static range coder instance */
+        StaticRangeCoder entropy_coder_;
+
+        bool do_voxel_grid_enDecoding_;
+        uint32_t i_frame_rate_;
+        uint32_t i_frame_counter_;
+        uint32_t frame_ID_;
+        uint64_t point_count_;
+        bool i_frame_;
+
+        bool do_color_encoding_;
+        bool cloud_with_color_;
+        bool data_with_color_;
+        unsigned char point_color_offset_;
+
+        //bool activating statistics
+        bool b_show_statistics_;
+        uint64_t compressed_point_data_len_;
+        uint64_t compressed_color_data_len_;
+
+        // frame header identifier
+        static const char* frame_header_identifier_;
+
+        const compression_Profiles_e selected_profile_;
+        const double point_resolution_;
+        const double octree_resolution_;
+        const unsigned char color_bit_resolution_;
+
+        std::size_t object_count_;
+
+      };
+
+    // define frame identifier
+    template<typename PointT, typename LeafT, typename BranchT, typename OctreeT>
+      const char* OctreePointCloudCompression<PointT, LeafT, BranchT, OctreeT>::frame_header_identifier_ = "<PCL-OCT-COMPRESSED>";
+  }
+
+}
+
+
+#endif
+###
+
+
+# point_coding.h
+namespace pcl
+{
+  namespace octree
+  {
+    /** \brief @b PointCoding class
+      * \note This class encodes 8-bit differential point information for octree-based point cloud compression.
+      * \note typename: PointT: type of point used in pointcloud
+      * \author Julius Kammerl (julius@kammerl.de)
+      */
+    template<typename PointT>
+    class PointCoding
+    {
+        // public typedefs
+        typedef pcl::PointCloud<PointT> PointCloud;
+        typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+
+      public:
+        /** \brief Constructor. */
+        PointCoding () :
+          output_ (), pointDiffDataVector_ (), pointDiffDataVectorIterator_ (), 
+          pointCompressionResolution_ (0.001f) // 1mm
+        {
+        }
+
+        /** \brief Empty class constructor. */
+        virtual
+        ~PointCoding ()
+        {
+        }
+
+        /** \brief Define precision of point information
+          * \param precision_arg: precision
+          */
+        inline void
+        setPrecision (float precision_arg)
+        {
+          pointCompressionResolution_ = precision_arg;
+        }
+
+        /** \brief Retrieve precision of point information
+          * \return precision
+          */
+        inline float
+        getPrecision ()
+        {
+          return (pointCompressionResolution_);
+        }
+
+        /** \brief Set amount of points within point cloud to be encoded and reserve memory
+          * \param pointCount_arg: amounts of points within point cloud
+          */
+        inline void
+        setPointCount (unsigned int pointCount_arg)
+        {
+          pointDiffDataVector_.reserve (pointCount_arg * 3);
+        }
+
+        /** \brief Initialize encoding of differential point */
+        void
+        initializeEncoding ()
+        {
+          pointDiffDataVector_.clear ();
+        }
+
+        /** \brief Initialize decoding of differential point */
+        void
+        initializeDecoding ()
+        {
+          pointDiffDataVectorIterator_ = pointDiffDataVector_.begin ();
+        }
+
+        /** \brief Get reference to vector containing differential color data */
+        std::vector<char>&
+        getDifferentialDataVector ()
+        {
+          return (pointDiffDataVector_);
+        }
+
+        /** \brief Encode differential point information for a subset of points from point cloud
+          * \param indexVector_arg indices defining a subset of points from points cloud
+          * \param referencePoint_arg coordinates of reference point
+          * \param inputCloud_arg input point cloud
+          */
+        void
+        encodePoints (const typename std::vector<int>& indexVector_arg, const double* referencePoint_arg,
+                      PointCloudConstPtr inputCloud_arg)
+        {
+          std::size_t i, len;
+
+          len = indexVector_arg.size ();
+
+          // iterate over points within current voxel
+          for (i = 0; i < len; i++)
+          {
+            unsigned char diffX, diffY, diffZ;
+
+            // retrieve point from cloud
+            const int& idx = indexVector_arg[i];
+            const PointT& idxPoint = inputCloud_arg->points[idx];
+
+            // differentially encode point coordinates and truncate overflow
+            diffX = static_cast<unsigned char> (max (-127, min<int>(127, static_cast<int> ((idxPoint.x - referencePoint_arg[0])  / pointCompressionResolution_))));
+            diffY = static_cast<unsigned char> (max (-127, min<int>(127, static_cast<int> ((idxPoint.y - referencePoint_arg[1])  / pointCompressionResolution_))));
+            diffZ = static_cast<unsigned char> (max (-127, min<int>(127, static_cast<int> ((idxPoint.z - referencePoint_arg[2])  / pointCompressionResolution_))));
+
+            // store information in differential point vector
+            pointDiffDataVector_.push_back (diffX);
+            pointDiffDataVector_.push_back (diffY);
+            pointDiffDataVector_.push_back (diffZ);
+          }
+        }
+
+        /** \brief Decode differential point information
+          * \param outputCloud_arg output point cloud
+          * \param referencePoint_arg coordinates of reference point
+          * \param beginIdx_arg index indicating first point to be assiged with color information
+          * \param endIdx_arg index indicating last point to be assiged with color information
+          */
+        void
+        decodePoints (PointCloudPtr outputCloud_arg, const double* referencePoint_arg, std::size_t beginIdx_arg,
+                      std::size_t endIdx_arg)
+        {
+          std::size_t i;
+          unsigned int pointCount;
+
+          assert (beginIdx_arg <= endIdx_arg);
+
+          pointCount = static_cast<unsigned int> (endIdx_arg - beginIdx_arg);
+
+          // iterate over points within current voxel
+          for (i = 0; i < pointCount; i++)
+          {
+            // retrieve differential point information
+            const unsigned char& diffX = static_cast<unsigned char> (*(pointDiffDataVectorIterator_++));
+            const unsigned char& diffY = static_cast<unsigned char> (*(pointDiffDataVectorIterator_++));
+            const unsigned char& diffZ = static_cast<unsigned char> (*(pointDiffDataVectorIterator_++));
+
+            // retrieve point from point cloud
+            PointT& point = outputCloud_arg->points[beginIdx_arg + i];
+
+            // decode point position
+            point.x = static_cast<float> (referencePoint_arg[0] + diffX * pointCompressionResolution_);
+            point.y = static_cast<float> (referencePoint_arg[1] + diffY * pointCompressionResolution_);
+            point.z = static_cast<float> (referencePoint_arg[2] + diffZ * pointCompressionResolution_);
+          }
+        }
+
+      protected:
+        /** \brief Pointer to output point cloud dataset. */
+        PointCloudPtr output_;
+
+        /** \brief Vector for storing differential point information  */
+        std::vector<char> pointDiffDataVector_;
+
+        /** \brief Iterator on differential point information vector */
+        std::vector<char>::const_iterator pointDiffDataVectorIterator_;
+
+        /** \brief Precision of point coding*/
+        float pointCompressionResolution_;
+    };
+  }
+}
+
+#define PCL_INSTANTIATE_ColorCoding(T) template class PCL_EXPORTS pcl::octree::ColorCoding<T>;
+
+#endif
+###
+
diff --git a/pcl/pcl_defs.pxd b/pcl/pcl_defs.pxd
index b477b6a..881f707 100644
--- a/pcl/pcl_defs.pxd
+++ b/pcl/pcl_defs.pxd
@@ -1,23 +1,107 @@
+# -*- coding: utf-8 -*-
 from libc.stddef cimport size_t
 
 from libcpp.vector cimport vector
 from libcpp.string cimport string
 from libcpp cimport bool
 
-from shared_ptr cimport shared_ptr
+from boost_shared_ptr cimport shared_ptr
+
+# Eigen
+from eigen cimport Vector4f
+from eigen cimport Quaternionf
+
 from vector cimport vector as vector2
 
-cdef extern from "Eigen/Eigen" namespace "Eigen" nogil:
-    cdef cppclass Vector4f:
-        float *data()
-    cdef cppclass Quaternionf:
-        float w()
-        float x()
-        float y()
-        float z()
-    cdef cppclass aligned_allocator[T]:
-        pass
+# Vertices
+# ctypedef unsigned int uint32_t
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+###
+
+### Inheritance class ###
+
+# channel_properties.h
+###
+
+# cloud_properties.h
+###
+
+# correspondence.h
+###
+
+# exceptions.h
+
+###
+
+# for_each_type.h
+
+###
+
+# pcl_config.h
+
+###
+
+# pcl_exports.h
+
+###
 
+# pcl_macros.h
+
+###
+
+# pcl_tests.h
+
+###
+
+# point_representation.h
+
+###
+
+# point_traits.h
+
+###
+
+# point_types_conversion.h
+
+###
+
+# template <>
+# class PCL_EXPORTS PCLBase<sensor_msgs::PointCloud2>
+#   public:
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+#       /** \brief Empty constructor. */
+#       PCLBase ()
+#       /** \brief destructor. */
+#       virtual ~PCLBase() 
+#       /** \brief Provide a pointer to the input dataset
+#         * \param cloud the const boost shared pointer to a PointCloud message
+#         */
+#       void setInputCloud (const PointCloud2ConstPtr &cloud);
+#       /** \brief Get a pointer to the input point cloud dataset. */
+#        PointCloud2ConstPtr const getInputCloud ()
+#       /** \brief Provide a pointer to the vector of indices that represents the input data.
+#         * \param indices a pointer to the vector of indices that represents the input data.
+#         */
+#        void setIndices (const IndicesPtr &indices)
+#       /** \brief Provide a pointer to the vector of indices that represents the input data.
+#         * \param indices a pointer to the vector of indices that represents the input data.
+#         */
+#        void setIndices (const PointIndicesConstPtr &indices)
+#       /** \brief Get a pointer to the vector of indices used. */
+#        IndicesPtr const getIndices ()
+###
+
+# point_cloud.h
 cdef extern from "pcl/point_cloud.h" namespace "pcl":
     cdef cppclass PointCloud[T]:
         PointCloud() except +
@@ -27,105 +111,361 @@ cdef extern from "pcl/point_cloud.h" namespace "pcl":
         bool is_dense
         void resize(size_t) except +
         size_t size()
+        # NG
         #T& operator[](size_t)
+        # ???(No Test)
+        #T& "operator[]"(size_t)
         #T& at(size_t) except +
         #T& at(int, int) except +
         shared_ptr[PointCloud[T]] makeShared()
-
+        
         Quaternionf sensor_orientation_
         Vector4f sensor_origin_
 
-cdef extern from "indexing.hpp":
-    # Use these instead of operator[] or at.
-    PointXYZ *getptr(PointCloud[PointXYZ] *, size_t)
-    PointXYZ *getptr_at(PointCloud[PointXYZ] *, size_t) except +
-    PointXYZ *getptr_at(PointCloud[PointXYZ] *, int, int) except +
+###
 
+# point_types.h
+# use cython type ?
+# ctypedef fused PointCloudTypes:
+#     PointXYZ
+#     PointXYZRGBA
 cdef extern from "pcl/point_types.h" namespace "pcl":
     cdef struct PointXYZ:
         PointXYZ()
         float x
         float y
         float z
+#     cdef struct Normal:
+#         pass
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
     cdef struct Normal:
-        pass
-
-cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
-    cdef cppclass NormalEstimation[T, N]:
-        NormalEstimation()
-
-cdef extern from "pcl/segmentation/sac_segmentation.h" namespace "pcl":
-    cdef cppclass SACSegmentationFromNormals[T, N]:
-        SACSegmentationFromNormals()
-        void setOptimizeCoefficients (bool)
-        void setModelType (SacModel)
-        void setMethodType (int)
-        void setNormalDistanceWeight (float)
-        void setMaxIterations (int)
-        void setDistanceThreshold (float)
-        void setRadiusLimits (float, float)
-        void setInputCloud (shared_ptr[PointCloud[T]])
-        void setInputNormals (shared_ptr[PointCloud[N]])
-        void setEpsAngle (double ea)
-        void segment (PointIndices, ModelCoefficients)
-        void setMinMaxOpeningAngle(double, double)
-        void getMinMaxOpeningAngle(double, double)
-
-
-    cdef cppclass SACSegmentation[T]:
-        void setOptimizeCoefficients (bool)
-        void setModelType (SacModel)
-        void setMethodType (int)
-        void setDistanceThreshold (float)
-        void setInputCloud (shared_ptr[PointCloud[T]])
-        void segment (PointIndices, ModelCoefficients)
-
-ctypedef SACSegmentation[PointXYZ] SACSegmentation_t
-ctypedef SACSegmentationFromNormals[PointXYZ,Normal] SACSegmentationNormal_t
-
-cdef extern from "pcl/surface/mls.h" namespace "pcl":
-    cdef cppclass MovingLeastSquares[I,O]:
-        MovingLeastSquares()
-        void setInputCloud (shared_ptr[PointCloud[I]])
-        void setSearchRadius (double)
-        void setPolynomialOrder(bool)
-        void setPolynomialFit(int)
-        void process(PointCloud[O] &) except +
-
-ctypedef MovingLeastSquares[PointXYZ,PointXYZ] MovingLeastSquares_t
-
-cdef extern from "pcl/search/kdtree.h" namespace "pcl::search":
-    cdef cppclass KdTree[T]:
-        KdTree()
-
-ctypedef aligned_allocator[PointXYZ] aligned_allocator_t 
-ctypedef vector2[PointXYZ, aligned_allocator_t] AlignedPointTVector_t
-
-cdef extern from "pcl/octree/octree_pointcloud.h" namespace "pcl::octree":
-    cdef cppclass OctreePointCloud[T]:
-        OctreePointCloud(double)
-        void setInputCloud (shared_ptr[PointCloud[T]])
-        void defineBoundingBox()
-        void defineBoundingBox(double, double, double, double, double, double)
-        void addPointsFromInputCloud()
-        void deleteTree()
-        bool isVoxelOccupiedAtPoint(double, double, double)
-        int getOccupiedVoxelCenters(AlignedPointTVector_t)	
-        void deleteVoxelAtPoint(PointXYZ)
-
-ctypedef OctreePointCloud[PointXYZ] OctreePointCloud_t
-
-cdef extern from "pcl/octree/octree_search.h" namespace "pcl::octree":
-    cdef cppclass OctreePointCloudSearch[T]:
-        OctreePointCloudSearch(double)
-        int radiusSearch (PointXYZ, double, vector[int], vector[float], unsigned int)
-
-ctypedef OctreePointCloudSearch[PointXYZ] OctreePointCloudSearch_t
+        float normal_x
+        float normal_y
+        float normal_z
+        float curvature
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+     cdef struct PointXYZRGBA:
+         PointXYZRGBA()
+         float x
+         float y
+         float z
+         # uint32_t rgba
+         # unsigned long rgba
+         float rgba
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointXYZRGB:
+         PointXYZRGB()
+         float x
+         float y
+         float z
+         float rgb
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+     cdef struct PointXYZRGBL:
+         PointXYZRGBA()
+         float x
+         float y
+         float z
+         # uint32_t rgba
+         #unsigned long rgba
+         float rgba
+         # uint32_t label
+         #unsigned long label
+         float label
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+     cdef struct PointXYZHSV:
+         PointXYZHSV()
+         float x
+         float y
+         float z
+         float h
+         float s
+         float v
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+     cdef struct PointXY:
+         PointXY()
+         float x
+         float y
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct InterestPoint:
+        InterestPoint()
+        float x
+        float y
+        float z
+        float strength
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+     cdef struct PointXYZI:
+        PointXYZI()
+        float x
+        float y
+        float z
+        float intensity
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+     cdef struct PointXYZL:
+        PointXYZL()
+        float x
+        float y
+        float z
+        # unsigned long label
+        float label
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+     cdef struct Label:
+        Label()
+        # uint32_t label
+        # unsigned long label
+        float label
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct Axis:
+        Axis()
+        float normal_x
+        float normal_y
+        float normal_z
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointNormal:
+        PointNormal()
+        float x
+        float y
+        float z
+        float normal_x
+        float normal_y
+        float normal_z
+        float curvature
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointXYZRGBNormal:
+        PointXYZRGBNormal()
+        float x
+        float y
+        float z
+        float rgb
+        float normal_x
+        float normal_y
+        float normal_z
+        float curvature
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointXYZINormal:
+        PointXYZINormal()
+        float x
+        float y
+        float z
+        float intensity
+        float normal_x
+        float normal_y
+        float normal_z
+        float curvature
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointWithRange:
+        PointWithRange()
+        float x
+        float y
+        float z
+        float range
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointWithViewpoint:
+        PointWithViewpoint()
+        float x
+        float y
+        float z
+        float vp_x
+        float vp_y
+        float vp_z
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct MomentInvariants:
+        MomentInvariants()
+        float j1
+        float j2
+        float j3
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PrincipalRadiiRSD:
+        PrincipalRadiiRSD()
+        float r_min
+        float r_max
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct Boundary:
+        Boundary()
+        # uint8_t boundary_point
+        unsigned char boundary_point
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PrincipalCurvatures:
+        PrincipalCurvatures()
+        float principal_curvature_x
+        float principal_curvature_y
+        float principal_curvature_z
+        float pc1
+        float pc2
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PFHSignature125:
+        PFHSignature125()
+        float[125] histogram
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PFHRGBSignature250:
+        PFHRGBSignature250()
+        float[250] histogram
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PPFSignature:
+        PPFSignature()
+        float f1
+        float f2
+        float f3
+        float f4
+        float alpha_m
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PPFRGBSignature:
+        PPFRGBSignature()
+        float f1
+        float f2
+        float f3
+        float f4
+        float r_ratio
+        float g_ratio
+        float b_ratio
+        float alpha_m
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct NormalBasedSignature12:
+        NormalBasedSignature12()
+        float[12] values
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct SHOT352:
+        SHOT352()
+        float[352] descriptor
+        float[9] rf
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct SHOT1344:
+        SHOT1344()
+        float[1344] descriptor
+        float[9] rf
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct FPFHSignature33:
+        FPFHSignature33()
+        float[33] histogram
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct VFHSignature308:
+        VFHSignature308()
+        float[308] histogram
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct ESFSignature640:
+        ESFSignature640()
+        float[640] histogram
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct Narf36:
+        Narf36()
+        float[36] descriptor
+
+# brief Data type to store extended information about a transition from foreground to backgroundSpecification of the fields for BorderDescription::traits.
+# ingroup common
+# typedef std::bitset<32> BorderTraits;
+# 
+# brief Specification of the fields for BorderDescription::traits.
+# ingroup common
+# 
+# enum BorderTrait
+# {
+#   BORDER_TRAIT__OBSTACLE_BORDER, BORDER_TRAIT__SHADOW_BORDER, BORDER_TRAIT__VEIL_POINT,
+#   BORDER_TRAIT__SHADOW_BORDER_TOP, BORDER_TRAIT__SHADOW_BORDER_RIGHT, BORDER_TRAIT__SHADOW_BORDER_BOTTOM,
+#   BORDER_TRAIT__SHADOW_BORDER_LEFT, BORDER_TRAIT__OBSTACLE_BORDER_TOP, BORDER_TRAIT__OBSTACLE_BORDER_RIGHT,
+#   BORDER_TRAIT__OBSTACLE_BORDER_BOTTOM, BORDER_TRAIT__OBSTACLE_BORDER_LEFT, BORDER_TRAIT__VEIL_POINT_TOP,
+#   BORDER_TRAIT__VEIL_POINT_RIGHT, BORDER_TRAIT__VEIL_POINT_BOTTOM, BORDER_TRAIT__VEIL_POINT_LEFT
+# };
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct BorderDescription:
+        BorderDescription()
+        int x
+        int y
+        int traits
+        # BorderTraits traits;
+        # //std::vector<const BorderDescription*> neighbors;
+
+# inline std::ostream& operator << (std::ostream& os, const BorderDescription& p)
+# {
+#   os << "(" << p.x << "," << p.y << ")";
+#   return (os);
+# }
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct GFPFHSignature16:
+        GFPFHSignature16()
+        float[16] histogram
 
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct IntensityGradient:
+        IntensityGradient()
+        float gradient_x
+        float gradient_y
+        float gradient_z
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointWithScale:
+        PointWithScale()
+        float x
+        float y
+        float z
+        float scale
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct PointSurfel:
+        PointSurfel()
+        float x
+        float y
+        float z
+        float normal_x
+        float normal_y
+        float normal_z
+        # uint32_t rgba
+        unsigned long rgba
+        float radius
+        float confidence
+        float curvature
+
+cdef extern from "pcl/point_types.h" namespace "pcl":
+    cdef struct ReferenceFrame:
+        ReferenceFrame()
+        float[3] x_axis
+        float[3] y_axis
+        float[3] z_axis
+        # float confidence
+###
+
+# ModelCoefficients.h
 cdef extern from "pcl/ModelCoefficients.h" namespace "pcl":
     cdef struct ModelCoefficients:
         vector[float] values
 
+ctypedef ModelCoefficients ModelCoefficients_t
+ctypedef shared_ptr[ModelCoefficients] ModelCoefficientsPtr_t
+
+###
+
+# PointIndices.h
 cdef extern from "pcl/PointIndices.h" namespace "pcl":
     #FIXME: I made this a cppclass so that it can be allocated using new (cython barfs otherwise), and
     #hence passed to shared_ptr. This is needed because if one passes memory allocated
@@ -139,97 +479,138 @@ cdef extern from "pcl/PointIndices.h" namespace "pcl":
 
 ctypedef PointIndices PointIndices_t
 ctypedef shared_ptr[PointIndices] PointIndicesPtr_t
-
-cdef extern from "pcl/io/pcd_io.h" namespace "pcl::io":
-    int load(string file_name, PointCloud[PointXYZ] &cloud) nogil except +
-    int loadPCDFile(string file_name,
-                    PointCloud[PointXYZ] &cloud) nogil except +
-    int savePCDFile(string file_name, PointCloud[PointXYZ] &cloud,
-                    bool binary_mode) nogil except +
-
-cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
-    int loadPLYFile(string file_name,
-                    PointCloud[PointXYZ] &cloud) nogil except +
-    int savePLYFile(string file_name, PointCloud[PointXYZ] &cloud,
-                    bool binary_mode) nogil except +
-
-#http://dev.pointclouds.org/issues/624
-#cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
-#    int loadPLYFile (string file_name, PointCloud[PointXYZ] cloud)
-#    int savePLYFile (string file_name, PointCloud[PointXYZ] cloud, bool binary_mode)
-
-cdef extern from "pcl/sample_consensus/model_types.h" namespace "pcl":
-    cdef enum SacModel:
-        SACMODEL_PLANE
-        SACMODEL_LINE
-        SACMODEL_CIRCLE2D
-        SACMODEL_CIRCLE3D
-        SACMODEL_SPHERE
-        SACMODEL_CYLINDER
-        SACMODEL_CONE
-        SACMODEL_TORUS
-        SACMODEL_PARALLEL_LINE
-        SACMODEL_PERPENDICULAR_PLANE
-        SACMODEL_PARALLEL_LINES
-        SACMODEL_NORMAL_PLANE
-        #SACMODEL_NORMAL_SPHERE
-        SACMODEL_REGISTRATION
-        SACMODEL_PARALLEL_PLANE
-        SACMODEL_NORMAL_PARALLEL_PLANE
-        SACMODEL_STICK
-
-cdef extern from "pcl/sample_consensus/method_types.h" namespace "pcl":
-    cdef enum:
-        SAC_RANSAC = 0
-        SAC_LMEDS = 1
-        SAC_MSAC = 2
-        SAC_RRANSAC = 3
-        SAC_RMSAC = 4
-        SAC_MLESAC = 5
-        SAC_PROSAC = 6
+###
 
 ctypedef PointCloud[PointXYZ] PointCloud_t
-ctypedef PointCloud[Normal] PointNormalCloud_t
+ctypedef PointCloud[PointXYZI] PointCloud_PointXYZI_t
+ctypedef PointCloud[PointXYZRGB] PointCloud_PointXYZRGB_t
+ctypedef PointCloud[PointXYZRGBA] PointCloud_PointXYZRGBA_t
+ctypedef PointCloud[VFHSignature308] PointCloud_VFHSignature308_t
+ctypedef PointCloud[PointWithViewpoint] PointCloud_PointWithViewpoint_t
+
 ctypedef shared_ptr[PointCloud[PointXYZ]] PointCloudPtr_t
+ctypedef shared_ptr[PointCloud[PointXYZI]] PointCloud_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloud[PointXYZRGB]] PointCloud_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloud[PointXYZRGBA]] PointCloud_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[PointCloud[VFHSignature308]] PointCloud_VFHSignature308_Ptr_t
+ctypedef shared_ptr[PointCloud[PointWithViewpoint]] PointCloud_PointWithViewpoint_Ptr_t
+
+ctypedef PointCloud[Normal] PointCloud_Normal_t
+ctypedef shared_ptr[PointCloud[Normal]] PointCloud_Normal_Ptr_t
+
+ctypedef PointCloud[PointNormal] PointCloud_PointNormal_t
+ctypedef shared_ptr[PointCloud[PointNormal]] PointCloud_PointNormal_Ptr_t
+
+# definitions used everywhere
+ctypedef shared_ptr[vector[int]] IndicesPtr_t;
+# ctypedef shared_ptr[vector[int]] IndicesConstPtr_t;
+
+
+# pcl_base.h
+# template <typename PointT>
+# class PCLBase
+cdef extern from "pcl/pcl_base.h" namespace "pcl":
+    cdef cppclass PCLBase[PointT]:
+        PCLBase ()
+        # PCLBase (const PCLBase& base)
+        # virtual void setInputCloud (PointCloudPtr_t cloud)
+        # void setInputCloud (PointCloudPtr_t cloud)
+        void setInputCloud (shared_ptr[PointCloud[PointT]] cloud)
+        
+        # PointCloudPtr_t getInputCloud ()
+        shared_ptr[PointCloud[PointT]] getInputCloud ()
+        
+        void setIndices (IndicesPtr_t &indices)
+        # void setIndices (IndicesConstPtr_t &indices)
+        # void setIndices (const PointIndicesPtr_t &indices)
+        # void setIndices (size_t row_start, size_t col_start, size_t nb_rows, size_t nb_cols)
+        
+        # IndicesConstPtr_t getIndices ()
+        # # const PointT& operator[] (size_t pos)
+
+
+ctypedef PCLBase[PointXYZ] PCLBase_t
+ctypedef PCLBase[PointXYZI] PCLBase_PointXYZI_t
+ctypedef PCLBase[PointXYZRGB] PCLBase_PointXYZRGB_t
+ctypedef PCLBase[PointXYZRGBA] PCLBase_PointXYZRGBA_t
+ctypedef shared_ptr[PCLBase[PointXYZ]] PCLBasePtr_t
+ctypedef shared_ptr[PCLBase[PointXYZI]] PCLBase_PointXYZI_Ptr_t
+ctypedef shared_ptr[PCLBase[PointXYZRGB]] PCLBase_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PCLBase[PointXYZRGBA]] PCLBase_PointXYZRGBA_Ptr_t
+###
+
+# PolygonMesh.h
+# namespace pcl
+#  struct PolygonMesh
+cdef extern from "pcl/PolygonMesh.h" namespace "pcl":
+    cdef cppclass PolygonMesh:
+        PolygonMesh()
+
+# ctypedef shared_ptr[PolygonMesh] PolygonMeshPtr;
+# ctypedef shared_ptr[PolygonMesh const] PolygonMeshConstPtr;
+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::PolygonMesh &v)
+###
+
+# TextureMesh.h
+# namespace pcl
+# struct TexMaterial
+cdef extern from "pcl/TextureMesh.h" namespace "pcl":
+    cdef cppclass TexMaterial:
+        TexMaterial ()
+        # cdef struct RGB
+        #     float r
+        #     float g
+        #     float b
+        string tex_name
+        string tex_file
+        # RGB tex_Ka
+        # RGB tex_Kd
+        # RGB tex_Ks
+        float tex_d
+        float tex_Ns
+        int tex_illum
+
+
+###
+
+cdef extern from "pcl/TextureMesh.h" namespace "pcl":
+    cdef cppclass TextureMesh:
+        TextureMesh ()
+        # std_msgs::Header          header
+        # sensor_msgs::PointCloud2  cloud
+        # vector[vector[Vertices] ]    tex_polygons             // polygon which is mapped with specific texture defined in TexMaterial
+        # vector[vector[Eigen::Vector2f] ]  tex_coordinates     // UV coordinates
+        # vector[TexMaterial]               tex_materials       // define texture material
+
+# ctypedef shared_ptr[TextureMesh] TextureMeshPtr_t
+# ctypedef shared_ptr[TextureMesh const] TextureMeshConstPtr_t
+###
+
+# Vertices.h
+# namespace pcl
+# struct Vertices
+cdef extern from "pcl/Vertices.h" namespace "pcl":
+    cdef cppclass Vertices:
+        Vertices()
+        vector[size_t] vertices;
+        # ostream& element "operator()"(ostream s, Vertices v)
+        # public:
+        # ctypedef shared_ptr[Vertices] Ptr
+        # ctypedef shared_ptr[Vertices const] ConstPtr
+
+
+# ctypedef Vertices Vertices_t
+ctypedef shared_ptr[Vertices] VerticesPtr_t
+# ctypedef shared_ptr[Vertices const] VerticesConstPtr
+# inline std::ostream& operator<<(std::ostream& s, const  ::pcl::Vertices & v)
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
 
-cdef extern from "pcl/filters/statistical_outlier_removal.h" namespace "pcl":
-    cdef cppclass StatisticalOutlierRemoval[T]:
-        StatisticalOutlierRemoval()
-        int getMeanK()
-        void setMeanK (int nr_k)
-        double getStddevMulThresh()
-        void setStddevMulThresh (double std_mul)
-        bool getNegative()
-        void setNegative (bool negative)
-        void setInputCloud (shared_ptr[PointCloud[T]])
-        void filter(PointCloud[T] &c)
-
-ctypedef StatisticalOutlierRemoval[PointXYZ] StatisticalOutlierRemoval_t
-
-cdef extern from "pcl/filters/voxel_grid.h" namespace "pcl":
-    cdef cppclass VoxelGrid[T]:
-        VoxelGrid()
-        void setLeafSize (float, float, float)
-        void setInputCloud (shared_ptr[PointCloud[T]])
-        void filter(PointCloud[T] c)
-
-ctypedef VoxelGrid[PointXYZ] VoxelGrid_t
-
-cdef extern from "pcl/filters/passthrough.h" namespace "pcl":
-    cdef cppclass PassThrough[T]:
-        PassThrough()
-        void setFilterFieldName (string field_name)
-        void setFilterLimits (float, float)
-        void setInputCloud (shared_ptr[PointCloud[T]])
-        void filter(PointCloud[T] c)
-
-ctypedef PassThrough[PointXYZ] PassThrough_t
-
-cdef extern from "pcl/kdtree/kdtree_flann.h" namespace "pcl":
-    cdef cppclass KdTreeFLANN[T]:
-        KdTreeFLANN()
-        void setInputCloud (shared_ptr[PointCloud[T]])
-        int nearestKSearch (PointCloud[T],
-          int, int, vector[int], vector[float])
-
-ctypedef KdTreeFLANN[PointXYZ] KdTreeFLANN_t
diff --git a/pcl/pcl_features.pxd b/pcl/pcl_features.pxd
new file mode 100644
index 0000000..b25b827
--- /dev/null
+++ b/pcl/pcl_features.pxd
@@ -0,0 +1,2821 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_kdtree as pclkdt
+cimport pcl_range_image as pcl_r_img
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# feature.h
+# class Feature : public PCLBase<PointInT>
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass Feature[In, Out](cpp.PCLBase[In]):
+        Feature ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::input_;
+        # ctypedef PCLBase<PointInT> BaseClass;
+        # ctypedef boost::shared_ptr< Feature<PointInT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const Feature<PointInT, PointOutT> > ConstPtr;
+        # ctypedef typename pcl::search::Search<PointInT> KdTree;
+        # ctypedef typename pcl::search::Search<PointInT>::Ptr KdTreePtr;
+        # ctypedef pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # ctypedef boost::function<int (size_t, double, std::vector<int> &, std::vector<float> &)> SearchMethod;
+        # ctypedef boost::function<int (const PointCloudIn &cloud, size_t index, double, std::vector<int> &, std::vector<float> &)> SearchMethodSurface;
+        # public:
+        # inline void setSearchSurface (const cpp.PointCloudPtr_t &)
+        # inline cpp.PointCloudPtr_t getSearchSurface () const
+        void setSearchSurface (const In &)
+        In getSearchSurface () const
+        
+        # inline void setSearchMethod (const KdTreePtr &tree)
+        # void setSearchMethod (pclkdt.KdTreePtr_t tree)
+        # void setSearchMethod (pclkdt.KdTreeFLANNPtr_t tree)
+        # void setSearchMethod (pclkdt.KdTreeFLANNConstPtr_t &tree)
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # inline KdTreePtr getSearchMethod () const
+        # pclkdt.KdTreePtr_t getSearchMethod ()
+        # pclkdt.KdTreeFLANNPtr_t getSearchMethod ()
+        # pclkdt.KdTreeFLANNConstPtr_t getSearchMethod ()
+        
+        double getSearchParameter ()
+        void setKSearch (int search)
+        int getKSearch () const
+        void setRadiusSearch (double radius)
+        double getRadiusSearch ()
+        
+        # void compute (PointCloudOut &output);
+        # void compute (cpp.PointCloudPtr_t output)
+        # void compute (cpp.PointCloud_PointXYZI_Ptr_t output)
+        # void compute (cpp.PointCloud_PointXYZRGB_Ptr_t output)
+        # void compute (cpp.PointCloud_PointXYZRGBA_Ptr_t output)
+        void compute (cpp.PointCloud[Out] &output)
+        
+        # void computeEigen (cpp.PointCloud[Eigen::MatrixXf] &output);
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class FeatureFromNormals : public Feature<PointInT, PointOutT>
+# cdef cppclass FeatureFromNormals(Feature[In, Out]):
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureFromNormals[In, NT, Out](Feature[In, Out]):
+        FeatureFromNormals()
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # ctypedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # ctypedef typename PointCloudN::Ptr PointCloudNPtr;
+        # ctypedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # ctypedef boost::shared_ptr< FeatureFromNormals<PointInT, PointNT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const FeatureFromNormals<PointInT, PointNT, PointOutT> > ConstPtr;
+        # // Members derived from the base class
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of
+        #         * the XYZ dataset.
+        # * In case of search surface is set to be different from the input cloud,
+        # * normals should correspond to the search surface, not the input cloud!
+        # * \param[in] normals the const boost shared pointer to a PointCloud of normals.
+        # * By convention, L2 norm of each normal should be 1.
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        void setInputNormals (cpp.PointCloud_Normal_Ptr_t normals)
+        
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals ()
+
+
+###
+
+# 3dsc.h
+# class ShapeContext3DEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/3dsc.h" namespace "pcl":
+    cdef cppclass ShapeContext3DEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        ShapeContext3DEstimation(bool)
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::searchForNeighbors;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        ##
+        # brief Set the number of bins along the azimuth to \a bins.
+        # param[in] bins the number of bins along the azimuth
+        void setAzimuthBins (size_t bins)
+        # return the number of bins along the azimuth
+        size_t getAzimuthBins () 
+        # brief Set the number of bins along the elevation to \a bins.
+        # param[in] bins the number of bins along the elevation
+        void setElevationBins (size_t )
+        # return The number of bins along the elevation
+        size_t getElevationBins ()
+        # brief Set the number of bins along the radii to \a bins.
+        # param[in] bins the number of bins along the radii
+        void setRadiusBins (size_t )
+        # return The number of bins along the radii direction
+        size_t getRadiusBins ()
+        # brief The minimal radius value for the search sphere (rmin) in the original paper 
+        # param[in] radius the desired minimal radius
+        void setMinimalRadius (double radius)
+        # return The minimal sphere radius
+        double getMinimalRadius ()
+        # brief This radius is used to compute local point density 
+        # density = number of points within this radius
+        # param[in] radius value of the point density search radius
+        void setPointDensityRadius (double radius)
+        # return The point density search radius
+        double getPointDensityRadius ()
+        
+###
+
+# feature.h
+# cdef extern from "pcl/features/feature.h" namespace "pcl":
+#     cdef inline void solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix,
+#                                             const Eigen::Vector4f &point,
+#                                             Eigen::Vector4f &plane_parameters, float &curvature);
+#     cdef inline void solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix,
+#                         float &nx, float &ny, float &nz, float &curvature);
+# template <typename PointInT, typename PointLT, typename PointOutT>
+# class FeatureFromLabels : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureFromLabels[In, LT, Out](Feature[In, Out]):
+        FeatureFromLabels()
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # ctypedef typename PointCloudL::Ptr PointCloudNPtr;
+        # ctypedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # ctypedef boost::shared_ptr< FeatureFromLabels<PointInT, PointLT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const FeatureFromLabels<PointInT, PointLT, PointOutT> > ConstPtr;
+        # // Members derived from the base class
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::k_;
+        # /** \brief Provide a pointer to the input dataset that contains the point labels of
+        #   * the XYZ dataset.
+        #   * In case of search surface is set to be different from the input cloud,
+        #   * labels should correspond to the search surface, not the input cloud!
+        #   * \param[in] labels the const boost shared pointer to a PointCloud of labels.
+        #   */
+        # inline void setInputLabels (const PointCloudLConstPtr &labels)
+        # inline PointCloudLConstPtr getInputLabels () const
+###
+
+### Inheritance class ###
+
+# 3dsc.h
+# class ShapeContext3DEstimation<PointInT, PointNT, Eigen::MatrixXf> : public ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>
+# cdef extern from "pcl/features/3dsc.h" namespace "pcl":
+#     cdef cppclass ShapeContext3DEstimation[T, N, M]:
+#         ShapeContext3DEstimation(bool)
+#         # public:
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::feature_name_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::indices_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::descriptor_length_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::normals_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::input_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::compute;
+###
+
+# class BoundaryEstimation: public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/boundary.h" namespace "pcl":
+    cdef cppclass BoundaryEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        BoundaryEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        ##
+        # brief Check whether a point is a boundary point in a planar patch of projected points given by indices.
+        # note A coordinate system u-v-n must be computed a-priori using \a getCoordinateSystemOnPlane
+        # param[in] cloud a pointer to the input point cloud
+        # param[in] q_idx the index of the query point in \a cloud
+        # param[in] indices the estimated point neighbors of the query point
+        # param[in] u the u direction
+        # param[in] v the v direction
+        # param[in] angle_threshold the threshold angle (default \f$\pi / 2.0\f$)
+        # bool isBoundaryPoint (const cpp.PointCloud[In] &cloud, 
+        #                int q_idx, const vector[int] &indices, 
+        #                const Eigen::Vector4f &u, const Eigen::Vector4f &v, const float angle_threshold);
+        # brief Check whether a point is a boundary point in a planar patch of projected points given by indices.
+        # note A coordinate system u-v-n must be computed a-priori using \a getCoordinateSystemOnPlane
+        # param[in] cloud a pointer to the input point cloud
+        # param[in] q_point a pointer to the querry point
+        # param[in] indices the estimated point neighbors of the query point
+        # param[in] u the u direction
+        # param[in] v the v direction
+        # param[in] angle_threshold the threshold angle (default \f$\pi / 2.0\f$)
+        # bool isBoundaryPoint (const cpp.PointCloud[In] &cloud, 
+        #                const [In] &q_point, 
+        #                const vector[int] &indices, 
+        #                const Eigen::Vector4f &u, const Eigen::Vector4f &v, const float angle_threshold);
+        # brief Set the decision boundary (angle threshold) that marks points as boundary or regular. 
+        # (default \f$\pi / 2.0\f$) 
+        # param[in] angle the angle threshold
+        inline void setAngleThreshold (float angle)
+        inline float getAngleThreshold ()
+        # brief Get a u-v-n coordinate system that lies on a plane defined by its normal
+        # param[in] p_coeff the plane coefficients (containing the plane normal)
+        # param[out] u the resultant u direction
+        # param[out] v the resultant v direction
+        # inline void getCoordinateSystemOnPlane (const PointNT &p_coeff, 
+        #                           Eigen::Vector4f &u, Eigen::Vector4f &v)
+
+###
+
+# class CVFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+# cdef extern from "pcl/features/cvfh.h" namespace "pcl":
+#     cdef cppclass CVFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+#         CVFHEstimation()
+#         # public:
+#         # using Feature<PointInT, PointOutT>::feature_name_;
+#         # using Feature<PointInT, PointOutT>::getClassName;
+#         # using Feature<PointInT, PointOutT>::indices_;
+#         # using Feature<PointInT, PointOutT>::k_;
+#         # using Feature<PointInT, PointOutT>::search_radius_;
+#         # using Feature<PointInT, PointOutT>::surface_;
+#         # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#         # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#         # ctypedef typename pcl::search::Search<PointNormal>::Ptr KdTreePtr;
+#         # ctypedef typename pcl::NormalEstimation<PointNormal, PointNormal> NormalEstimator;
+#         # ctypedef typename pcl::VFHEstimation<PointInT, PointNT, pcl::VFHSignature308> VFHEstimator;
+#         ##
+#         # brief Removes normals with high curvature caused by real edges or noisy data
+#         # param[in] cloud pointcloud to be filtered
+#         # param[out] indices_out the indices of the points with higher curvature than threshold
+#         # param[out] indices_in the indices of the remaining points after filtering
+#         # param[in] threshold threshold value for curvature
+#         void filterNormalsWithHighCurvature (
+#                                               const cpp.PointCloud[NT] & cloud, 
+#                                               vector[int] &indices, vector[int] &indices2,
+#                                               vector[int] &, float);
+#         # brief Set the viewpoint.
+#         # param[in] vpx the X coordinate of the viewpoint
+#         # param[in] vpy the Y coordinate of the viewpoint
+#         # param[in] vpz the Z coordinate of the viewpoint
+#         inline void setViewPoint (float x, float y, float z)
+#         # brief Set the radius used to compute normals
+#         # param[in] radius_normals the radius
+#         inline void setRadiusNormals (float radius)
+#         # brief Get the viewpoint. 
+#         # param[out] vpx the X coordinate of the viewpoint
+#         # param[out] vpy the Y coordinate of the viewpoint
+#         # param[out] vpz the Z coordinate of the viewpoint
+#         inline void getViewPoint (float &x, float &y, float &z)
+#         # brief Get the centroids used to compute different CVFH descriptors
+#         # param[out] centroids vector to hold the centroids
+#         # inline void getCentroidClusters (vector[Eigen::Vector3f] &)
+#         # brief Get the normal centroids used to compute different CVFH descriptors
+#         # param[out] centroids vector to hold the normal centroids
+#         # inline void getCentroidNormalClusters (vector[Eigen::Vector3f] &)
+#         # brief Sets max. Euclidean distance between points to be added to the cluster 
+#         # param[in] d the maximum Euclidean distance 
+#         inline void setClusterTolerance (float tolerance)
+#         # brief Sets max. deviation of the normals between two points so they can be clustered together
+#         # param[in] d the maximum deviation 
+#         inline void setEPSAngleThreshold (float angle)
+#         # brief Sets curvature threshold for removing normals
+#         # param[in] d the curvature threshold 
+#         inline void setCurvatureThreshold (float curve)
+#         # brief Set minimum amount of points for a cluster to be considered
+#         # param[in] min the minimum amount of points to be set 
+#         inline void setMinPoints (size_t points)
+#         # brief Sets wether if the CVFH signatures should be normalized or not
+#         # param[in] normalize true if normalization is required, false otherwise 
+#         inline void setNormalizeBins (bool bins)
+#         # brief Overloaded computed method from pcl::Feature.
+#         # param[out] output the resultant point cloud model dataset containing the estimated features
+#         # void compute (cpp.PointCloud[Out] &);
+
+
+###
+
+# esf.h
+# class ESFEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/esf.h" namespace "pcl":
+    cdef cppclass ESFEstimation[In, Out](Feature[In, Out]):
+        ESFEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # ctypedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # void compute (cpp.PointCloud[Out] &output)
+###
+
+# template <typename PointInT, typename PointRFT>
+# class FeatureWithLocalReferenceFrames
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureWithLocalReferenceFrames[T, REF]:
+        FeatureWithLocalReferenceFrames ()
+        # public:
+        # ctypedef cpp.PointCloud[RFT] PointCloudLRF;
+        # ctypedef typename PointCloudLRF::Ptr PointCloudLRFPtr;
+        # ctypedef typename PointCloudLRF::ConstPtr PointCloudLRFConstPtr;
+        # inline void setInputReferenceFrames (const PointCloudLRFConstPtr &frames)
+        # inline PointCloudLRFConstPtr getInputReferenceFrames () const
+        # protected:
+        # /** \brief A boost shared pointer to the local reference frames. */
+        # PointCloudLRFConstPtr frames_;
+        # /** \brief The user has never set the frames. */
+        # bool frames_never_defined_;
+        # /** \brief Check if frames_ has been correctly initialized and compute it if needed.
+        # * \param input the subclass' input cloud dataset.
+        # * \param lrf_estimation a pointer to a local reference frame estimation class to be used as default.
+        # * \return true if frames_ has been correctly initialized.
+        # */
+        # typedef typename Feature<PointInT, PointRFT>::Ptr LRFEstimationPtr;
+        # virtual bool
+        # initLocalReferenceFrames (const size_t& indices_size,
+        #                           const LRFEstimationPtr& lrf_estimation = LRFEstimationPtr());
+###
+
+# fpfh
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::FPFHSignature33>
+# class FPFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/fpfh.h" namespace "pcl":
+    cdef cppclass FPFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        FPFHEstimation()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * represented by Cartesian coordinates and normals.
+        # * \note For explanations about the features, please see the literature mentioned above (the order of the
+        # * features might be different).
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals (assuming normalized vectors) at each point in cloud
+        # * \param[in] p_idx the index of the first point (source)
+        # * \param[in] q_idx the index of the second point (target)
+        # * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+        # * \param[out] f2 the second angular feature (angle between nq_idx and v)
+        # * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+        # * \param[out] f4 the distance feature (p_idx - q_idx)
+        # bool computePairFeatures (const pcl::PointCloud<PointInT> &cloud, const pcl::PointCloud<PointNT> &normals, int p_idx, int q_idx, float &f1, float &f2, float &f3, float &f4);
+        
+        # \brief Estimate the SPFH (Simple Point Feature Histograms) individual signatures of the three angular
+        # (f1, f2, f3) features for a given point based on its spatial neighborhood of 3D points with normals
+        # \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        # \param[in] p_idx the index of the query point (source)
+        # \param[in] row the index row in feature histogramms
+        # \param[in] indices the k-neighborhood point indices in the dataset
+        # \param[out] hist_f1 the resultant SPFH histogram for feature f1
+        # \param[out] hist_f2 the resultant SPFH histogram for feature f2
+        # \param[out] hist_f3 the resultant SPFH histogram for feature f3
+        # void computePointSPFHSignature (
+        #                               const pcl::PointCloud<PointInT> &cloud, 
+        #                               const pcl::PointCloud<PointNT> &normals, int p_idx, int row, 
+        #                               const std::vector<int> &indices, 
+        #                               Eigen::MatrixXf &hist_f1, Eigen::MatrixXf &hist_f2, Eigen::MatrixXf &hist_f3);
+        
+        # \brief Weight the SPFH (Simple Point Feature Histograms) individual histograms to create the final FPFH
+        # (Fast Point Feature Histogram) for a given point based on its 3D spatial neighborhood
+        # \param[in] hist_f1 the histogram feature vector of \a f1 values over the given patch
+        # \param[in] hist_f2 the histogram feature vector of \a f2 values over the given patch
+        # \param[in] hist_f3 the histogram feature vector of \a f3 values over the given patch
+        # \param[in] indices the point indices of p_idx's k-neighborhood in the point cloud
+        # \param[in] dists the distances from p_idx to all its k-neighbors
+        # \param[out] fpfh_histogram the resultant FPFH histogram representing the feature at the query point
+        # void weightPointSPFHSignature (
+        #                           const Eigen::MatrixXf &hist_f1, 
+        #                           const Eigen::MatrixXf &hist_f2, 
+        #                           const Eigen::MatrixXf &hist_f3, 
+        #                           const std::vector<int> &indices, 
+        #                           const std::vector<float> &dists, 
+        #                           Eigen::VectorXf &fpfh_histogram);
+        
+        # \brief Set the number of subdivisions for each angular feature interval.
+        # \param[in] nr_bins_f1 number of subdivisions for the first angular feature
+        # \param[in] nr_bins_f2 number of subdivisions for the second angular feature
+        # \param[in] nr_bins_f3 number of subdivisions for the third angular feature
+        inline void setNrSubdivisions (int , int , int )
+        
+        # \brief Get the number of subdivisions for each angular feature interval. 
+        # \param[out] nr_bins_f1 number of subdivisions for the first angular feature
+        # \param[out] nr_bins_f2 number of subdivisions for the second angular feature
+        # \param[out] nr_bins_f3 number of subdivisions for the third angular feature
+        inline void getNrSubdivisions (int &, int &, int &)
+
+
+ctypedef FPFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.PFHSignature125] FPFHEstimation_t
+ctypedef shared_ptr[FPFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.PFHSignature125]] FPFHEstimationPtr_t
+# template <typename PointInT, typename PointNT>
+# class FPFHEstimation<PointInT, PointNT, Eigen::MatrixXf> : public FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>
+# cdef extern from "pcl/features/feature.h" namespace "pcl":
+#     cdef cppclass FPFHEstimation[T, NT]:
+#         FPFHEstimation()
+# ctypedef FPFHEstimation[cpp.PointXYZ, cpp.Normal, eigen3.MatrixXf] FPFHEstimation2_t
+# ctypedef shared_ptr[FPFHEstimation[cpp.PointXYZ, cpp.Normal, eigen3.MatrixXf]] FPFHEstimation2Ptr_t
+###
+
+# fpfh_omp
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class FPFHEstimationOMP : public FPFHEstimation<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/fpfh_omp.h" namespace "pcl":
+    cdef cppclass FPFHEstimationOMP[In, NT, Out](FPFHEstimation[In, NT, Out]):
+        FPFHEstimationOMP ()
+        # FPFHEstimationOMP (unsigned int )
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f1_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f2_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f3_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::weightPointSPFHSignature;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * \brief Initialize the scheduler and set the number of threads to use.
+        # * \param[in] nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        inline void setNumberOfThreads (unsigned threads)
+        # public:
+        # * \brief The number of subdivisions for each angular feature interval. */
+        # int nr_bins_f1_, nr_bins_f2_, nr_bins_f3_;
+
+###
+
+# integral_image_normal.h
+# template <typename PointInT, typename PointOutT>
+# class IntegralImageNormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+    cdef cppclass IntegralImageNormalEstimation[In, Out](Feature[In, Out]):
+        IntegralImageNormalEstimation ()
+        # public:
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # 
+        # * \brief Set the regions size which is considered for normal estimation.
+        # * \param[in] width the width of the search rectangle
+        # * \param[in] height the height of the search rectangle
+        void setRectSize (const int width, const int height)
+        
+        # * \brief Sets the policy for handling borders.
+        # * \param[in] border_policy the border policy.
+        # minipcl
+        # void setBorderPolicy (BorderPolicy border_policy)
+        # * \brief Computes the normal at the specified position.
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[in] point_index the position index of the point
+        # * \param[out] normal the output estimated normal
+        void computePointNormal (const int pos_x, const int pos_y, const unsigned point_index, Out &normal)
+        
+        # * \brief Computes the normal at the specified position with mirroring for border handling.
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[in] point_index the position index of the point
+        # * \param[out] normal the output estimated normal
+        void computePointNormalMirror (const int pos_x, const int pos_y, const unsigned point_index, Out &normal)
+        
+        # * \brief The depth change threshold for computing object borders
+        # * \param[in] max_depth_change_factor the depth change threshold for computing object borders based on
+        # * depth changes
+        void setMaxDepthChangeFactor (float max_depth_change_factor)
+        
+        # * \brief Set the normal smoothing size
+        # * \param[in] normal_smoothing_size factor which influences the size of the area used to smooth normals
+        # * (depth dependent if useDepthDependentSmoothing is true)
+        void setNormalSmoothingSize (float normal_smoothing_size)
+        
+        # TODO : use minipcl.cpp/h
+        # * \brief Set the normal estimation method. The current implemented algorithms are:
+        # * <ul>
+        # *   <li><b>COVARIANCE_MATRIX</b> - creates 9 integral images to compute the normal for a specific point
+        # *   from the covariance matrix of its local neighborhood.</li>
+        # *   <li><b>AVERAGE_3D_GRADIENT</b> - creates 6 integral images to compute smoothed versions of
+        # *   horizontal and vertical 3D gradients and computes the normals using the cross-product between these
+        # *   two gradients.
+        # *   <li><b>AVERAGE_DEPTH_CHANGE</b> -  creates only a single integral image and computes the normals
+        # *   from the average depth changes.
+        # * </ul>
+        # * \param[in] normal_estimation_method the method used for normal estimation
+        # void setNormalEstimationMethod (NormalEstimationMethod2 normal_estimation_method)
+       
+        # brief Set whether to use depth depending smoothing or not
+        # param[in] use_depth_dependent_smoothing decides whether the smoothing is depth dependent
+        void setDepthDependentSmoothing (bool use_depth_dependent_smoothing)
+        
+        # brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        # \param[in] cloud the const boost shared pointer to a PointCloud message
+        # void setInputCloud (const typename PointCloudIn::ConstPtr &cloud)
+        void setInputCloud (In cloud)
+        
+        # brief Returns a pointer to the distance map which was computed internally
+        inline float* getDistanceMap ()
+        
+        # * \brief Set the viewpoint.
+        # * \param vpx the X coordinate of the viewpoint
+        # * \param vpy the Y coordinate of the viewpoint
+        # * \param vpz the Z coordinate of the viewpoint
+        inline void setViewPoint (float vpx, float vpy, float vpz)
+        
+        # * \brief Get the viewpoint.
+        # * \param [out] vpx x-coordinate of the view point
+        # * \param [out] vpy y-coordinate of the view point
+        # * \param [out] vpz z-coordinate of the view point
+        # * \note this method returns the currently used viewpoint for normal flipping.
+        # * If the viewpoint is set manually using the setViewPoint method, this method will return the set view point coordinates.
+        # * If an input cloud is set, it will return the sensor origin otherwise it will return the origin (0, 0, 0)
+        inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        
+        # * \brief sets whether the sensor origin or a user given viewpoint should be used. After this method, the 
+        # * normal estimation method uses the sensor origin of the input cloud.
+        # * to use a user defined view point, use the method setViewPoint
+        inline void useSensorOriginAsViewPoint ()
+
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal]) IntegralImageNormalEstimation_PointXYZI_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal](Feature[cpp.PointXYZRGB, cpp.Normal]) IntegralImageNormalEstimation_PointXYZRGB_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal](Feature[cpp.PointXYZRGBA, cpp.Normal]) IntegralImageNormalEstimation_PointXYZRGBA_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal])] IntegralImageNormalEstimationPtr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal])] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal](Feature[cpp.PointXYZRGB, cpp.Normal])] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal](Feature[cpp.PointXYZRGBA, cpp.Normal])] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+###
+
+# integral_image2D.h
+# template <class DataType, unsigned Dimension>
+# class IntegralImage2D
+cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+    cdef cppclass IntegralImage2D[Type, Dim]:
+        # IntegralImage2D ()
+        IntegralImage2D (bool flag)
+        # public:
+        # static const unsigned second_order_size = (Dimension * (Dimension + 1)) >> 1;
+        # ctypedef Eigen::Matrix<typename IntegralImageTypeTraits<DataType>::IntegralType, Dimension, 1> ElementType;
+        # ctypedef Eigen::Matrix<typename IntegralImageTypeTraits<DataType>::IntegralType, second_order_size, 1> SecondOrderType;
+        # void setSecondOrderComputation (bool compute_second_order_integral_images);
+        # * \brief Set the input data to compute the integral image for
+        #   * \param[in] data the input data
+        #   * \param[in] width the width of the data
+        #   * \param[in] height the height of the data
+        #   * \param[in] element_stride the element stride of the data
+        #   * \param[in] row_stride the row stride of the data
+        # void setInput (const DataType * data, unsigned width, unsigned height, unsigned element_stride, unsigned row_stride)
+        # * \brief Compute the first order sum within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        # inline ElementType getFirstOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the first order sum within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        # inline ElementType getFirstOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+        # /** \brief Compute the second order sum within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        # inline SecondOrderType getSecondOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the second order sum within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        # inline SecondOrderType getSecondOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+        # /** \brief Compute the number of finite elements within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        inline unsigned getFiniteElementsCount (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the number of finite elements within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        inline unsigned getFiniteElementsCountSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+###
+
+# template <class DataType>
+# class IntegralImage2D <DataType, 1>
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+#     cdef cppclass IntegralImage2D[Type]:
+#         # IntegralImage2D ()
+#         IntegralImage2D (bool flag)
+#         # public:
+#         # static const unsigned second_order_size = 1;
+#         # ctypedef typename IntegralImageTypeTraits<DataType>::IntegralType ElementType;
+#         # ctypedef typename IntegralImageTypeTraits<DataType>::IntegralType SecondOrderType;
+#         # /** \brief Set the input data to compute the integral image for
+#         #   * \param[in] data the input data
+#         #   * \param[in] width the width of the data
+#         #   * \param[in] height the height of the data
+#         #   * \param[in] element_stride the element stride of the data
+#         #   * \param[in] row_stride the row stride of the data
+#         #   */
+#         # void setInput (const DataType * data, unsigned width, unsigned height, unsigned element_stride, unsigned row_stride);
+#         # /** \brief Compute the first order sum within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         # inline ElementType getFirstOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the first order sum within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         #   */
+#         # inline ElementType getFirstOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+#         # /** \brief Compute the second order sum within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         # inline SecondOrderType getSecondOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the second order sum within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         # inline SecondOrderType getSecondOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+#         # /** \brief Compute the number of finite elements within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         inline unsigned getFiniteElementsCount (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the number of finite elements within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         #   */
+#         inline unsigned getFiniteElementsCountSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+
+###
+
+# intensity_gradient.h
+# template <typename PointInT, typename PointNT, typename PointOutT, typename IntensitySelectorT = pcl::common::IntensityFieldAccessor<PointInT> >
+# class IntensityGradientEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/intensity_gradient.h" namespace "pcl":
+    cdef cppclass IntensityGradientEstimation[In, NT, Out, Intensity](FeatureFromNormals[In, NT, Out]):
+        IntensityGradientEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (int nr_threads)
+###
+
+# template <typename PointInT, typename PointNT>
+# class IntensityGradientEstimation<PointInT, PointNT, Eigen::MatrixXf>: public IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>
+# cdef extern from "pcl/features/intensity_gradient.h" namespace "pcl":
+#     cdef cppclass IntensityGradientEstimation[In, NT]:
+#         IntensityGradientEstimation ()
+#         # public:
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::indices_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::normals_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::input_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::surface_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::k_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::search_parameter_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::compute;
+
+###
+
+# intensity_spin.h
+# template <typename PointInT, typename PointOutT>
+# class IntensitySpinEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/intensity_spin.h" namespace "pcl":
+    cdef cppclass IntensitySpinEstimation[In, Out](Feature[In, Out]):
+        IntensitySpinEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # ctypedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        ##
+        # /** \brief Estimate the intensity-domain spin image descriptor for a given point based on its spatial
+        #   * neighborhood of 3D points and their intensities. 
+        #   * \param[in] cloud the dataset containing the Cartesian coordinates and intensity values of the points
+        #   * \param[in] radius the radius of the feature
+        #   * \param[in] sigma the standard deviation of the Gaussian smoothing kernel to use during the soft histogram update
+        #   * \param[in] k the number of neighbors to use from \a indices and \a squared_distances
+        #   * \param[in] indices the indices of the points that comprise the query point's neighborhood
+        #   * \param[in] squared_distances the squared distances from the query point to each point in the neighborhood
+        #   * \param[out] intensity_spin_image the resultant intensity-domain spin image descriptor
+        #   */
+        # void computeIntensitySpinImage (const PointCloudIn &cloud, 
+        #                            float radius, float sigma, int k, 
+        #                            const std::vector<int> &indices, 
+        #                            const std::vector<float> &squared_distances, 
+        #                            Eigen::MatrixXf &intensity_spin_image);
+
+        # /** \brief Set the number of bins to use in the distance dimension of the spin image
+        #   * \param[in] nr_distance_bins the number of bins to use in the distance dimension of the spin image
+        #   */
+        # inline void setNrDistanceBins (size_t nr_distance_bins) { nr_distance_bins_ = static_cast<int> (nr_distance_bins); };
+        # /** \brief Returns the number of bins in the distance dimension of the spin image. */
+        # inline int getNrDistanceBins ()
+        # /** \brief Set the number of bins to use in the intensity dimension of the spin image.
+        #   * \param[in] nr_intensity_bins the number of bins to use in the intensity dimension of the spin image
+        #   */
+        # inline void setNrIntensityBins (size_t nr_intensity_bins)
+        # /** \brief Returns the number of bins in the intensity dimension of the spin image. */
+        # inline int getNrIntensityBins ()
+        # /** \brief Set the standard deviation of the Gaussian smoothing kernel to use when constructing the spin images.  
+        #   * \param[in] sigma the standard deviation of the Gaussian smoothing kernel to use when constructing the spin images
+        # inline void setSmoothingBandwith (float sigma)
+        # /** \brief Returns the standard deviation of the Gaussian smoothing kernel used to construct the spin images.  */
+        # inline float getSmoothingBandwith ()
+        # /** \brief Estimate the intensity-domain descriptors at a set of points given by <setInputCloud (), setIndices ()>
+        #   *  using the surface in setSearchSurface (), and the spatial locator in setSearchMethod ().
+        #   * \param[out] output the resultant point cloud model dataset that contains the intensity-domain spin image features
+        # void computeFeature (PointCloudOut &output);
+        # /** \brief The number of distance bins in the descriptor. */
+        # int nr_distance_bins_;
+        # /** \brief The number of intensity bins in the descriptor. */
+        # int nr_intensity_bins_;
+        # /** \brief The standard deviation of the Gaussian smoothing kernel used to construct the spin images. */
+        # float sigma_;
+
+###
+
+# template <typename PointInT>
+# class IntensitySpinEstimation<PointInT, Eigen::MatrixXf>: public IntensitySpinEstimation<PointInT, pcl::Histogram<20> >
+# cdef extern from "pcl/features/intensity_spin.h" namespace "pcl":
+#     cdef cppclass IntensitySpinEstimation[In](IntensitySpinEstimation[In]):
+#         IntensitySpinEstimation ()
+#         # public:
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::getClassName;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::input_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::indices_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::surface_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::search_radius_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::nr_intensity_bins_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::nr_distance_bins_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::tree_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::sigma_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::compute;
+###
+
+# moment_invariants.h
+# template <typename PointInT, typename PointOutT>
+# class MomentInvariantsEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/moment_invariants.h" namespace "pcl":
+    cdef cppclass MomentInvariantsEstimation[In, Out](Feature[In, Out]):
+        MomentInvariantsEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # /** \brief Compute the 3 moment invariants (j1, j2, j3) for a given set of points, using their indices.
+        # * \param[in] cloud the input point cloud
+        # * \param[in] indices the point cloud indices that need to be used
+        # * \param[out] j1 the resultant first moment invariant
+        # * \param[out] j2 the resultant second moment invariant
+        # * \param[out] j3 the resultant third moment invariant
+        # */
+        # void computePointMomentInvariants (const pcl::PointCloud<PointInT> &cloud, 
+        #                             const std::vector<int> &indices, 
+        #                             float &j1, float &j2, float &j3);
+        # * \brief Compute the 3 moment invariants (j1, j2, j3) for a given set of points, using their indices.
+        # * \param[in] cloud the input point cloud
+        # * \param[out] j1 the resultant first moment invariant
+        # * \param[out] j2 the resultant second moment invariant
+        # * \param[out] j3 the resultant third moment invariant
+        # void computePointMomentInvariants (const pcl::PointCloud<PointInT> &cloud, 
+        #                             float &j1, float &j2, float &j3);
+###
+
+# template <typename PointInT>
+# class MomentInvariantsEstimation<PointInT, Eigen::MatrixXf>: public MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>
+# cdef extern from "pcl/features/moment_invariants.h" namespace "pcl":
+#     cdef cppclass MomentInvariantsEstimation[In, Out](MomentInvariantsEstimation[In]):
+#         MomentInvariantsEstimation ()
+#         public:
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::k_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::indices_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::search_parameter_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::surface_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::input_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::compute;
+###
+
+# multiscale_feature_persistence.h
+# template <typename PointSource, typename PointFeature>
+# class MultiscaleFeaturePersistence : public PCLBase<PointSource>
+cdef extern from "pcl/features/multiscale_feature_persistence.h" namespace "pcl":
+    cdef cppclass MultiscaleFeaturePersistence[Source, Feature](cpp.PCLBase[Source]):
+        MultiscaleFeaturePersistence ()
+        # public:
+        # typedef pcl::PointCloud<PointFeature> FeatureCloud;
+        # typedef typename pcl::PointCloud<PointFeature>::Ptr FeatureCloudPtr;
+        # typedef typename pcl::Feature<PointSource, PointFeature>::Ptr FeatureEstimatorPtr;
+        # typedef boost::shared_ptr<const pcl::PointRepresentation <PointFeature> > FeatureRepresentationConstPtr;
+        # using pcl::PCLBase<PointSource>::input_;
+        # 
+        # /** \brief Method that calls computeFeatureAtScale () for each scale parameter */
+        # void computeFeaturesAtAllScales ();
+        
+        # /** \brief Central function that computes the persistent features
+        #  * \param output_features a cloud containing the persistent features
+        #  * \param output_indices vector containing the indices of the points in the input cloud
+        #  * that have persistent features, under a one-to-one correspondence with the output_features cloud
+        #  */
+        # void determinePersistentFeatures (FeatureCloud &output_features, boost::shared_ptr<std::vector<int> > &output_indices);
+        
+        # /** \brief Method for setting the scale parameters for the algorithm
+        #  * \param scale_values vector of scales to determine the characteristic of each scaling step
+        #  */
+        inline void setScalesVector (vector[float] &scale_values)
+        
+        # /** \brief Method for getting the scale parameters vector */
+        inline vector[float] getScalesVector ()
+        
+        # /** \brief Setter method for the feature estimator
+        #  * \param feature_estimator pointer to the feature estimator instance that will be used
+        #  * \note the feature estimator instance should already have the input data given beforehand
+        #  * and everything set, ready to be given the compute () command
+        #  */
+        # inline void setFeatureEstimator (FeatureEstimatorPtr feature_estimator)
+        
+        # /** \brief Getter method for the feature estimator */
+        # inline FeatureEstimatorPtr getFeatureEstimator ()
+        
+        # \brief Provide a pointer to the feature representation to use to convert features to k-D vectors.
+        # \param feature_representation the const boost shared pointer to a PointRepresentation
+        # inline void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation)
+        
+        # \brief Get a pointer to the feature representation used when converting features into k-D vectors. */
+        # inline FeatureRepresentationConstPtr const getPointRepresentation ()
+        
+        # \brief Sets the alpha parameter
+        # \param alpha value to replace the current alpha with
+        inline void setAlpha (float alpha)
+        
+        # /** \brief Get the value of the alpha parameter */
+        inline float getAlpha ()
+        
+        # /** \brief Method for setting the distance metric that will be used for computing the difference between feature vectors
+        # * \param distance_metric the new distance metric chosen from the NormType enum
+        # inline void setDistanceMetric (NormType distance_metric)
+        
+        # /** \brief Returns the distance metric that is currently used to calculate the difference between feature vectors */
+        # inline NormType getDistanceMetric ()
+###
+
+# narf.h
+# namespace pcl 
+# {
+#   // Forward declarations
+#   class RangeImage;
+#   struct InterestPoint;
+# 
+# #define NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE 10
+# narf.h
+# namespace pcl 
+# /**
+# * \brief NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data.
+# * Please refer to pcl/features/narf_descriptor.h if you want the class derived from pcl Feature.
+# * See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard
+# *     Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries
+# *     In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011. 
+# * \author Bastian Steder
+# * \ingroup features
+# */
+# class PCL_EXPORTS Narf
+        # public:
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # //! Constructor
+        # Narf();
+        # //! Copy Constructor
+        # Narf(const Narf& other);
+        # //! Destructor
+        # ~Narf();
+        # 
+        # // =====Operators=====
+        # //! Assignment operator
+        # const Narf& operator=(const Narf& other);
+        # 
+        # // =====STATIC=====
+        # /** The maximum number of openmp threads that can be used in this class */
+        # static int max_no_of_threads;
+        # 
+        # /** Add features extracted at the given interest point and add them to the list */
+        # static void extractFromRangeImageAndAddToList (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Same as above */
+        # static void extractFromRangeImageAndAddToList (const RangeImage& range_image, float image_x, float image_y, int descriptor_size,float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Get a list of features from the given interest points. */
+        # static void extractForInterestPoints (const RangeImage& range_image, const PointCloud<InterestPoint>& interest_points, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Extract an NARF for every point in the range image. */
+        # static void extractForEveryRangeImagePointAndAddToList (const RangeImage& range_image, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # // =====PUBLIC METHODS=====
+        # /** Method to extract a NARF feature from a certain 3D point using a range image.
+        # *  pose determines the coordinate system of the feature, whereas it transforms a point from the world into the feature system.
+        # *  This means the interest point at which the feature is extracted will be the inverse application of pose onto (0,0,0).
+        # *  descriptor_size_ determines the size of the descriptor,
+        # *  support_size determines the support size of the feature, meaning the size in the world it covers */
+        # bool extractFromRangeImage (const RangeImage& range_image, const Eigen::Affine3f& pose, int descriptor_size, float support_size,int surface_patch_world_size=NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE);
+        # 
+        # //! Same as above, but determines the transformation from the surface in the range image
+        # bool extractFromRangeImage (const RangeImage& range_image, float x, float y, int descriptor_size, float support_size);
+        # 
+        # //! Same as above
+        # bool extractFromRangeImage (const RangeImage& range_image, const InterestPoint& interest_point, int descriptor_size, float support_size);
+        # 
+        # //! Same as above
+        # bool extractFromRangeImage (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size);
+        # 
+        # /** Same as above, but using the rotational invariant version by choosing the best extracted rotation around the normal.
+        # *  Use extractFromRangeImageAndAddToList if you want to enable the system to return multiple features with different rotations. */
+        # bool extractFromRangeImageWithBestRotation (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size);
+        # 
+        # /* Get the dominant rotations of the current descriptor
+        # * \param rotations the returned rotations
+        # * \param strength values describing how pronounced the corresponding rotations are
+        # */
+        # void getRotations (std::vector<float>& rotations, std::vector<float>& strengths) const;
+        # 
+        # /* Get the feature with a different rotation around the normal
+        # * You are responsible for deleting the new features!
+        # * \param range_image the source from which the feature is extracted
+        # * \param rotations list of angles (in radians)
+        # * \param rvps returned features
+        # */
+        # void getRotatedVersions (const RangeImage& range_image, const std::vector<float>& rotations, std::vector<Narf*>& features) const;
+        # 
+        # //! Calculate descriptor distance, value in [0,1] with 0 meaning identical and 1 every cell above maximum distance
+        # inline float getDescriptorDistance (const Narf& other) const;
+        # 
+        # //! How many points on each beam of the gradient star are used to calculate the descriptor?
+        # inline int getNoOfBeamPoints () const { return (static_cast<int> (pcl_lrint (ceil (0.5f * float (surface_patch_pixel_size_))))); }
+        # 
+        # //! Copy the descriptor and pose to the point struct Narf36
+        # inline void copyToNarf36 (Narf36& narf36) const;
+        # 
+        # /** Write to file */
+        # void saveBinary (const std::string& filename) const;
+        # 
+        # /** Write to output stream */
+        # void saveBinary (std::ostream& file) const;
+        # 
+        # /** Read from file */
+        # void loadBinary (const std::string& filename);
+        # /** Read from input stream */
+        # void loadBinary (std::istream& file);
+        # 
+        # //! Create the descriptor from the already set other members
+        # bool extractDescriptor (int descriptor_size);
+        # 
+        # // =====GETTERS=====
+        # //! Getter (const) for the descriptor
+        # inline const float* getDescriptor () const { return descriptor_;}
+        # //! Getter for the descriptor
+        # inline float* getDescriptor () { return descriptor_;}
+        # //! Getter (const) for the descriptor length
+        # inline const int& getDescriptorSize () const { return descriptor_size_;}
+        # //! Getter for the descriptor length
+        # inline int& getDescriptorSize () { return descriptor_size_;}
+        # //! Getter (const) for the position
+        # inline const Eigen::Vector3f& getPosition () const { return position_;}
+        # //! Getter for the position
+        # inline Eigen::Vector3f& getPosition () { return position_;}
+        # //! Getter (const) for the 6DoF pose
+        # inline const Eigen::Affine3f& getTransformation () const { return transformation_;}
+        # //! Getter for the 6DoF pose
+        # inline Eigen::Affine3f& getTransformation () { return transformation_;}
+        # //! Getter (const) for the pixel size of the surface patch (only one dimension)
+        # inline const int& getSurfacePatchPixelSize () const { return surface_patch_pixel_size_;}
+        # //! Getter for the pixel size of the surface patch (only one dimension)
+        # inline int& getSurfacePatchPixelSize () { return surface_patch_pixel_size_;}
+        # //! Getter (const) for the world size of the surface patch
+        # inline const float& getSurfacePatchWorldSize () const { return surface_patch_world_size_;}
+        # //! Getter for the world size of the surface patch
+        # inline float& getSurfacePatchWorldSize () { return surface_patch_world_size_;}
+        # //! Getter (const) for the rotation of the surface patch
+        # inline const float& getSurfacePatchRotation () const { return surface_patch_rotation_;}
+        # //! Getter for the rotation of the surface patch
+        # inline float& getSurfacePatchRotation () { return surface_patch_rotation_;}
+        # //! Getter (const) for the surface patch
+        # inline const float* getSurfacePatch () const { return surface_patch_;}
+        # //! Getter for the surface patch
+        # inline float* getSurfacePatch () { return surface_patch_;}
+        # //! Method to erase the surface patch and free the memory
+        # inline void freeSurfacePatch () { delete[] surface_patch_; surface_patch_=NULL; surface_patch_pixel_size_=0; }
+        # 
+        # // =====SETTERS=====
+        # //! Setter for the descriptor
+        # inline void setDescriptor (float* descriptor) { descriptor_ = descriptor;}
+        # //! Setter for the surface patch
+        # inline void setSurfacePatch (float* surface_patch) { surface_patch_ = surface_patch;}
+        # 
+        # // =====PUBLIC MEMBER VARIABLES=====
+        # 
+        # // =====PUBLIC STRUCTS=====
+        # struct FeaturePointRepresentation : public PointRepresentation<Narf*>
+        # {
+        #     typedef Narf* PointT;
+        #     FeaturePointRepresentation(int nr_dimensions) { this->nr_dimensions_ = nr_dimensions; }
+        #     /** \brief Empty destructor */
+        #     virtual ~FeaturePointRepresentation () {}
+        #     virtual void copyToFloatArray (const PointT& p, float* out) const { memcpy(out, p->getDescriptor(), sizeof(*p->getDescriptor())*this->nr_dimensions_); }
+        # };
+
+
+###
+
+# narf_descriptor.h
+# namespace pcl
+#     // Forward declarations
+#     class RangeImage;
+##
+# narf_descriptor.h
+# namespace pcl
+# /** @b Computes NARF feature descriptors for points in a range image
+# * See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard
+# *     Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries
+# *     In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011. 
+# * \author Bastian Steder
+# * \ingroup features
+# */
+# class PCL_EXPORTS NarfDescriptor : public Feature<PointWithRange,Narf36>
+        # public:
+        # typedef boost::shared_ptr<NarfDescriptor> Ptr;
+        # typedef boost::shared_ptr<const NarfDescriptor> ConstPtr;
+        # // =====TYPEDEFS=====
+        # typedef Feature<PointWithRange,Narf36> BaseClass;
+        # 
+        # // =====STRUCTS/CLASSES=====
+        # struct Parameters
+        # {
+        #   Parameters() : support_size(-1.0f), rotation_invariant(true) {}
+        #   float support_size;
+        #   bool rotation_invariant;
+        # };
+        # 
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # NarfDescriptor (const RangeImage* range_image=NULL, const std::vector<int>* indices=NULL);
+        # /** Destructor */
+        # virtual ~NarfDescriptor();
+        # 
+        # // =====METHODS=====
+        # //! Set input data
+        # void setRangeImage (const RangeImage* range_image, const std::vector<int>* indices=NULL);
+        # 
+        # //! Overwrite the compute function of the base class
+        # void compute (cpp.PointCloud[Out]& output);
+        # 
+        # // =====GETTER=====
+        # //! Get a reference to the parameters struct
+        # Parameters& getParameters () { return parameters_;}
+
+
+###
+
+# normal_3d.h
+# cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+#     cdef cppclass NormalEstimation[I, N, O]:
+#         NormalEstimation()
+# 
+#   template <typename PointT> inline void
+#   computePointNormal (const pcl::PointCloud<PointT> &cloud,
+#                       Eigen::Vector4f &plane_parameters, float &curvature)
+#   /** \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+#     * and return the estimated plane parameters together with the surface curvature.
+#     * \param cloud the input point cloud
+#     * \param indices the point cloud indices that need to be used
+#     * \param plane_parameters the plane parameters as: a, b, c, d (ax + by + cz + d = 0)
+#     * \param curvature the estimated surface curvature as a measure of
+#     * \f[
+#     * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+#     * \f]
+#     * \ingroup features
+#     */
+#   template <typename PointT> inline void
+#   computePointNormal (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices,
+#                       Eigen::Vector4f &plane_parameters, float &curvature)
+#
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param normal the plane normal to be flipped
+#     * \ingroup features
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               Eigen::Matrix<Scalar, 4, 1>& normal)
+# 
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param normal the plane normal to be flipped
+#     * \ingroup features
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               Eigen::Matrix<Scalar, 3, 1>& normal)
+#   
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param nx the resultant X component of the plane normal
+#     * \param ny the resultant Y component of the plane normal
+#     * \param nz the resultant Z component of the plane normal
+#     * \ingroup features
+#     */
+#   template <typename PointT> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               float &nx, float &ny, float &nz)
+#
+
+# template <typename PointInT, typename PointOutT>
+# class NormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+    cdef cppclass NormalEstimation[In, Out](Feature[In, Out]):
+        NormalEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudConstPtr PointCloudConstPtr;
+        
+        # * \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+        # * and return the estimated plane parameters together with the surface curvature.
+        # * \param cloud the input point cloud
+        # * \param indices the point cloud indices that need to be used
+        # * \param plane_parameters the plane parameters as: a, b, c, d (ax + by + cz + d = 0)
+        # * \param curvature the estimated surface curvature as a measure of
+        # * \f[
+        # * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+        # * \f]
+        # inline void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, Eigen::Vector4f &plane_parameters, float &curvature)
+        # void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, eigen3.Vector4f &plane_parameters, float &curvature)
+        
+        # * \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+        # * and return the estimated plane parameters together with the surface curvature.
+        # * \param cloud the input point cloud
+        # * \param indices the point cloud indices that need to be used
+        # * \param nx the resultant X component of the plane normal
+        # * \param ny the resultant Y component of the plane normal
+        # * \param nz the resultant Z component of the plane normal
+        # * \param curvature the estimated surface curvature as a measure of
+        # * \f[
+        # * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+        # * \f]
+        # inline void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, float &nx, float &ny, float &nz, float &curvature)
+        void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, float &nx, float &ny, float &nz, float &curvature)
+        
+        # * \brief Provide a pointer to the input dataset
+        # * \param cloud the const boost shared pointer to a PointCloud message
+        # virtual inline void setInputCloud (const PointCloudConstPtr &cloud)
+        # * \brief Set the viewpoint.
+        # * \param vpx the X coordinate of the viewpoint
+        # * \param vpy the Y coordinate of the viewpoint
+        # * \param vpz the Z coordinate of the viewpoint
+        inline void setViewPoint (float vpx, float vpy, float vpz)
+        
+        # * \brief Get the viewpoint.
+        # * \param [out] vpx x-coordinate of the view point
+        # * \param [out] vpy y-coordinate of the view point
+        # * \param [out] vpz z-coordinate of the view point
+        # * \note this method returns the currently used viewpoint for normal flipping.
+        # * If the viewpoint is set manually using the setViewPoint method, this method will return the set view point coordinates.
+        # * If an input cloud is set, it will return the sensor origin otherwise it will return the origin (0, 0, 0)
+        inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        
+        # * \brief sets whether the sensor origin or a user given viewpoint should be used. After this method, the 
+        # * normal estimation method uses the sensor origin of the input cloud.
+        # * to use a user defined view point, use the method setViewPoint
+        inline void useSensorOriginAsViewPoint ()
+        
+ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+
+###
+
+# template <typename PointInT>
+# class NormalEstimation<PointInT, Eigen::MatrixXf>: public NormalEstimation<PointInT, pcl::Normal>
+# cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+#     cdef cppclass NormalEstimation[In, Eigen::MatrixXf](NormalEstimation[In, pcl::Normal]):
+#         NormalEstimation ()
+#     public:
+#       using NormalEstimation<PointInT, pcl::Normal>::indices_;
+#       using NormalEstimation<PointInT, pcl::Normal>::input_;
+#       using NormalEstimation<PointInT, pcl::Normal>::surface_;
+#       using NormalEstimation<PointInT, pcl::Normal>::k_;
+#       using NormalEstimation<PointInT, pcl::Normal>::search_parameter_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpx_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpy_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpz_;
+#       using NormalEstimation<PointInT, pcl::Normal>::computePointNormal;
+#       using NormalEstimation<PointInT, pcl::Normal>::compute;
+###
+
+# normal_3d_omp.h
+# template <typename PointInT, typename PointOutT>
+# class NormalEstimationOMP: public NormalEstimation<PointInT, PointOutT>
+cdef extern from "pcl/features/normal_3d_omp.h" namespace "pcl":
+    cdef cppclass NormalEstimationOMP[In, Out](NormalEstimation[In, Out]):
+        NormalEstimationOMP ()
+        NormalEstimationOMP (unsigned int nr_threads)
+        # public:
+        # using NormalEstimation<PointInT, PointOutT>::feature_name_;
+        # using NormalEstimation<PointInT, PointOutT>::getClassName;
+        # using NormalEstimation<PointInT, PointOutT>::indices_;
+        # using NormalEstimation<PointInT, PointOutT>::input_;
+        # using NormalEstimation<PointInT, PointOutT>::k_;
+        # using NormalEstimation<PointInT, PointOutT>::search_parameter_;
+        # using NormalEstimation<PointInT, PointOutT>::surface_;
+        # using NormalEstimation<PointInT, PointOutT>::getViewPoint;
+        # typedef typename NormalEstimation<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        #     * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # */
+        inline void setNumberOfThreads (unsigned int nr_threads)
+###
+
+# template <typename PointInT>
+# class NormalEstimationOMP<PointInT, Eigen::MatrixXf>: public NormalEstimationOMP<PointInT, pcl::Normal>
+#     public:
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::indices_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::search_parameter_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::k_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::input_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::surface_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::getViewPoint;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::threads_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::compute;
+# 
+#       /** \brief Default constructor.
+#         */
+#       NormalEstimationOMP () : NormalEstimationOMP<PointInT, pcl::Normal> () {}
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       NormalEstimationOMP (unsigned int nr_threads) : NormalEstimationOMP<PointInT, pcl::Normal> (nr_threads) {}
+# 
+
+
+###
+
+# normal_based_signature.h
+# template <typename PointT, typename PointNT, typename PointFeature>
+# class NormalBasedSignatureEstimation : public FeatureFromNormals<PointT, PointNT, PointFeature>
+cdef extern from "pcl/features/normal_based_signature.h" namespace "pcl":
+    cdef cppclass NormalBasedSignatureEstimation[In, NT, Feature](FeatureFromNormals[In,  NT, Feature]):
+        NormalBasedSignatureEstimation ()
+        # public:
+        # using Feature<PointT, PointFeature>::input_;
+        # using Feature<PointT, PointFeature>::tree_;
+        # using Feature<PointT, PointFeature>::search_radius_;
+        # using PCLBase<PointT>::indices_;
+        # using FeatureFromNormals<PointT, PointNT, PointFeature>::normals_;
+        # typedef pcl::PointCloud<PointFeature> FeatureCloud;
+        # typedef typename boost::shared_ptr<NormalBasedSignatureEstimation<PointT, PointNT, PointFeature> > Ptr;
+        # typedef typename boost::shared_ptr<const NormalBasedSignatureEstimation<PointT, PointNT, PointFeature> > ConstPtr;
+        # /** \brief Setter method for the N parameter - the length of the columns used for the Discrete Fourier Transform. 
+        # * \param[in] n the length of the columns used for the Discrete Fourier Transform. 
+        inline void setN (size_t n)
+        # /** \brief Returns the N parameter - the length of the columns used for the Discrete Fourier Transform. */
+        # inline size_t getN ()
+        # /** \brief Setter method for the M parameter - the length of the rows used for the Discrete Cosine Transform.
+        # * \param[in] m the length of the rows used for the Discrete Cosine Transform.
+        inline void setM (size_t m)
+        # /** \brief Returns the M parameter - the length of the rows used for the Discrete Cosine Transform */
+        inline size_t getM ()
+        # /** \brief Setter method for the N' parameter - the number of columns to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        # * \param[in] n_prime the number of columns from the matrix of DFT and DCT that will be contained in the output
+        inline void setNPrime (size_t n_prime)
+        # /** \brief Returns the N' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        inline size_t getNPrime ()
+        # * \brief Setter method for the M' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        # * \param[in] m_prime the number of rows from the matrix of DFT and DCT that will be contained in the output
+        inline void setMPrime (size_t m_prime)
+        # * \brief Returns the M' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        inline size_t getMPrime ()
+        # * \brief Setter method for the scale parameter - used to determine the radius of the sampling disc around the
+        # * point of interest - linked to the smoothing scale of the input cloud
+        inline void setScale (float scale)
+        # * \brief Returns the scale parameter - used to determine the radius of the sampling disc around the
+        # * point of interest - linked to the smoothing scale of the input cloud
+        inline float getScale ()
+###
+
+# pfh.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PFHSignature125>
+# class PFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/pfh.h" namespace "pcl":
+    cdef cppclass PFHEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PFHEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # * \brief Set the maximum internal cache size. Defaults to 2GB worth of entries.
+        # * \param[in] cache_size maximum cache size 
+        inline void setMaximumCacheSize (unsigned int cache_size)
+        # /** \brief Get the maximum internal cache size. */
+        inline unsigned int getMaximumCacheSize ()
+        # * \brief Set whether to use an internal cache mechanism for removing redundant calculations or not. 
+        # * \note Depending on how the point cloud is ordered and how the nearest
+        # * neighbors are estimated, using a cache could have a positive or a
+        # * negative influence. Please test with and without a cache on your
+        # * data, and choose whatever works best!
+        # * See \ref setMaximumCacheSize for setting the maximum cache size
+        # * \param[in] use_cache set to true to use the internal cache, false otherwise
+        inline void setUseInternalCache (bool use_cache)
+        # /** \brief Get whether the internal cache is used or not for computing the PFH features. */
+        inline bool getUseInternalCache ()
+        # * \brief Compute the 4-tuple representation containing the three angles and one distance between two points
+        # * represented by Cartesian coordinates and normals.
+        # * \note For explanations about the features, please see the literature mentioned above (the order of the
+        # * features might be different).
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals (assuming normalized vectors) at each point in cloud
+        # * \param[in] p_idx the index of the first point (source)
+        # * \param[in] q_idx the index of the second point (target)
+        # * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+        # * \param[out] f2 the second angular feature (angle between nq_idx and v)
+        # * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+        # * \param[out] f4 the distance feature (p_idx - q_idx)
+        # * \note For efficiency reasons, we assume that the point data passed to the method is finite.
+        bool computePairFeatures (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals, 
+                                    int p_idx, int q_idx, float &f1, float &f2, float &f3, float &f4);
+        # * \brief Estimate the PFH (Point Feature Histograms) individual signatures of the three angular (f1, f2, f3)
+        # * features for a given point based on its spatial neighborhood of 3D points with normals
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        # * \param[in] indices the k-neighborhood point indices in the dataset
+        # * \param[in] nr_split the number of subdivisions for each angular feature interval
+        # * \param[out] pfh_histogram the resultant (combinatorial) PFH histogram representing the feature at the query point
+        # void computePointPFHSignature (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals, 
+        #                         const vector[int] &indices, int nr_split, Eigen::VectorXf &pfh_histogram);
+
+
+###
+
+# template <typename PointInT, typename PointNT>
+# class PFHEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>
+#     public:
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::pfh_histogram_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::nr_subdiv_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::k_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::indices_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::search_parameter_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::surface_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::input_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::normals_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::computePointPFHSignature;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::compute;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::feature_map_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::key_list_;
+
+###
+
+# pfhrgb.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PFHRGBSignature250>
+# class PFHRGBEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/pfhrgb.h" namespace "pcl":
+    cdef cppclass PFHRGBEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PFHRGBEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        bool computeRGBPairFeatures (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals,
+                              int p_idx, int q_idx,
+                              float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7)
+        # void computePointPFHRGBSignature (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals,
+        #                            const vector[int] &indices, int nr_split, Eigen::VectorXf &pfhrgb_histogram)
+
+
+###
+
+# ppf.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/ppf.h" namespace "pcl":
+    cdef cppclass PPFEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PPFEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+
+# template <typename PointInT, typename PointNT>
+# class PPFEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PPFEstimation<PointInT, PointNT, pcl::PPFSignature>
+#     public:
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::getClassName;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::input_;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::normals_;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::indices_;
+# 
+###
+
+# ppfrgb.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFRGBEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/ppfrgb.h" namespace "pcl":
+    cdef cppclass PPFRGBEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PPFRGBEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFRGBRegionEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+#       PPFRGBRegionEstimation ();
+#     public:
+#       using PCLBase<PointInT>::indices_;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::tree_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       typedef pcl::PointCloud<PointOutT> PointCloudOut;
+###
+
+# principal_curvatures.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PrincipalCurvatures>
+# class PrincipalCurvaturesEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/principal_curvatures.h" namespace "pcl":
+    cdef cppclass PrincipalCurvaturesEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PrincipalCurvaturesEstimation ()
+#       public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       /** \brief Perform Principal Components Analysis (PCA) on the point normals of a surface patch in the tangent
+#        *  plane of the given point normal, and return the principal curvature (eigenvector of the max eigenvalue),
+#        *  along with both the max (pc1) and min (pc2) eigenvalues
+#        * \param[in] normals the point cloud normals
+#        * \param[in] p_idx the query point at which the least-squares plane was estimated
+#        * \param[in] indices the point cloud indices that need to be used
+#        * \param[out] pcx the principal curvature X direction
+#        * \param[out] pcy the principal curvature Y direction
+#        * \param[out] pcz the principal curvature Z direction
+#        * \param[out] pc1 the max eigenvalue of curvature
+#        * \param[out] pc2 the min eigenvalue of curvature
+#        */
+#       void computePointPrincipalCurvatures (const pcl::PointCloud<PointNT> &normals,
+#                                        int p_idx, const std::vector<int> &indices,
+#                                        float &pcx, float &pcy, float &pcz, float &pc1, float &pc2);
+
+# template <typename PointInT, typename PointNT>
+# class PrincipalCurvaturesEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>
+#     public:
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::indices_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::k_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::search_parameter_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::surface_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::compute;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::input_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::normals_;
+###
+
+# range_image_border_extractor.h
+# namespace pcl
+# class RangeImage;
+# template <typename PointType>
+# class PointCloud;
+
+# class PCL_EXPORTS RangeImageBorderExtractor : public Feature<PointWithRange, BorderDescription>
+cdef extern from "pcl/features/range_image_border_extractor.h" namespace "pcl":
+    cdef cppclass RangeImageBorderExtractor(Feature[cpp.PointWithRange, cpp.BorderDescription]):
+        RangeImageBorderExtractor ()
+        RangeImageBorderExtractor (const pcl_r_img.RangeImage range_image)
+        # =====CONSTRUCTOR & DESTRUCTOR=====
+        # Constructor
+        # RangeImageBorderExtractor (const RangeImage* range_image = NULL)
+        # /** Destructor */
+        # ~RangeImageBorderExtractor ();
+        # 
+        
+        # public:
+        # // =====PUBLIC STRUCTS=====
+        # Stores some information extracted from the neighborhood of a point
+        # struct LocalSurface
+        # {
+        #   LocalSurface () : 
+        #     normal (), neighborhood_mean (), eigen_values (), normal_no_jumps (), 
+        #     neighborhood_mean_no_jumps (), eigen_values_no_jumps (), max_neighbor_distance_squared () {}
+        # 
+        #   Eigen::Vector3f normal;
+        #   Eigen::Vector3f neighborhood_mean;
+        #   Eigen::Vector3f eigen_values;
+        #   Eigen::Vector3f normal_no_jumps;
+        #   Eigen::Vector3f neighborhood_mean_no_jumps;
+        #   Eigen::Vector3f eigen_values_no_jumps;
+        #   float max_neighbor_distance_squared;
+        # };
+        
+        # Stores the indices of the shadow border corresponding to obstacle borders
+        # struct ShadowBorderIndices 
+        # {
+        #   ShadowBorderIndices () : left (-1), right (-1), top (-1), bottom (-1) {}
+        #   int left, right, top, bottom;
+        # };
+        
+        # Parameters used in this class
+        # struct Parameters
+        # {
+        #   Parameters () : max_no_of_threads(1), pixel_radius_borders (3), pixel_radius_plane_extraction (2), pixel_radius_border_direction (2), 
+        #                  minimum_border_probability (0.8f), pixel_radius_principal_curvature (2) {}
+        #   int max_no_of_threads;
+        #   int pixel_radius_borders;
+        #   int pixel_radius_plane_extraction;
+        #   int pixel_radius_border_direction;
+        #   float minimum_border_probability;
+        #   int pixel_radius_principal_curvature;
+        # };
+        
+        # =====STATIC METHODS=====
+        # brief Take the information from BorderTraits to calculate the local direction of the border
+        # param border_traits contains the information needed to calculate the border angle
+        # 
+        # static inline float getObstacleBorderAngle (const BorderTraits& border_traits);
+        
+        # // =====METHODS=====
+        # /** \brief Provide a pointer to the range image
+        #   * \param range_image a pointer to the range_image
+        # void setRangeImage (const RangeImage* range_image);
+        void setRangeImage (const pcl_r_img.RangeImage range_image)
+        
+        # brief Erase all data calculated for the current range image
+        void clearData ()
+        
+        # brief Get the 2D directions in the range image from the border directions - probably mainly useful for 
+        # visualization 
+        # float* getAnglesImageForBorderDirections ();
+        # float[] getAnglesImageForBorderDirections ()
+        
+        # brief Get the 2D directions in the range image from the surface change directions - probably mainly useful for visualization 
+        # float* getAnglesImageForSurfaceChangeDirections ();
+        # float[] getAnglesImageForSurfaceChangeDirections ()
+        
+        # /** Overwrite the compute function of the base class */
+        # void compute (PointCloudOut& output);
+        # void compute (cpp.PointCloud[Out]& output)
+        
+        # =====GETTER=====
+        # Parameters& getParameters () { return (parameters_); }
+        # Parameters& getParameters ()
+        # 
+        # bool hasRangeImage () const { return range_image_ != NULL; }
+        bool hasRangeImage ()
+        
+        # const RangeImage& getRangeImage () const { return *range_image_; }
+        const pcl_r_img.RangeImage getRangeImage ()
+        
+        # float* getBorderScoresLeft ()   { extractBorderScoreImages (); return border_scores_left_; }
+        # float* getBorderScoresRight ()  { extractBorderScoreImages (); return border_scores_right_; }
+        # float* getBorderScoresTop ()    { extractBorderScoreImages (); return border_scores_top_; }
+        # float* getBorderScoresBottom () { extractBorderScoreImages (); return border_scores_bottom_; }
+        # 
+        # LocalSurface** getSurfaceStructure () { extractLocalSurfaceStructure (); return surface_structure_; }
+        # PointCloudOut& getBorderDescriptions () { classifyBorders (); return *border_descriptions_; }
+        # ShadowBorderIndices** getShadowBorderInformations () { findAndEvaluateShadowBorders (); return shadow_border_informations_; }
+        # Eigen::Vector3f** getBorderDirections () { calculateBorderDirections (); return border_directions_; }
+        # float* getSurfaceChangeScores () { calculateSurfaceChanges (); return surface_change_scores_; }
+        # Eigen::Vector3f* getSurfaceChangeDirections () { calculateSurfaceChanges (); return surface_change_directions_; }
+
+
+###
+
+# rift.h
+# template <typename PointInT, typename GradientT, typename PointOutT>
+# class RIFTEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/rift.h" namespace "pcl":
+    cdef cppclass RIFTEstimation[In, GradientT, Out](Feature[In, Out]):
+        RIFTEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<GradientT> PointCloudGradient;
+        # typedef typename PointCloudGradient::Ptr PointCloudGradientPtr;
+        # typedef typename PointCloudGradient::ConstPtr PointCloudGradientConstPtr;
+        # typedef typename boost::shared_ptr<RIFTEstimation<PointInT, GradientT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const RIFTEstimation<PointInT, GradientT, PointOutT> > ConstPtr;
+        
+        # brief Provide a pointer to the input gradient data
+        # param[in] gradient a pointer to the input gradient data
+        # inline void setInputGradient (const PointCloudGradientConstPtr &gradient)
+        
+        # /** \brief Returns a shared pointer to the input gradient data */
+        # inline PointCloudGradientConstPtr getInputGradient () const 
+        
+        # brief Set the number of bins to use in the distance dimension of the RIFT descriptor
+        # param[in] nr_distance_bins the number of bins to use in the distance dimension of the RIFT descriptor
+        # inline void setNrDistanceBins (int nr_distance_bins)
+        
+        # /** \brief Returns the number of bins in the distance dimension of the RIFT descriptor. */
+        # inline int getNrDistanceBins () const
+        
+        # /** \brief Set the number of bins to use in the gradient orientation dimension of the RIFT descriptor
+        # * \param[in] nr_gradient_bins the number of bins to use in the gradient orientation dimension of the RIFT descriptor
+        # inline void setNrGradientBins (int nr_gradient_bins)
+        
+        # /** \brief Returns the number of bins in the gradient orientation dimension of the RIFT descriptor. */
+        # inline int getNrGradientBins () const
+        
+        # /** \brief Estimate the Rotation Invariant Feature Transform (RIFT) descriptor for a given point based on its 
+        # * spatial neighborhood of 3D points and the corresponding intensity gradient vector field
+        # * \param[in] cloud the dataset containing the Cartesian coordinates of the points
+        # * \param[in] gradient the dataset containing the intensity gradient at each point in \a cloud
+        # * \param[in] p_idx the index of the query point in \a cloud (i.e. the center of the neighborhood)
+        # * \param[in] radius the radius of the RIFT feature
+        # * \param[in] indices the indices of the points that comprise \a p_idx's neighborhood in \a cloud
+        # * \param[in] squared_distances the squared distances from the query point to each point in the neighborhood
+        # * \param[out] rift_descriptor the resultant RIFT descriptor
+        # void computeRIFT (const PointCloudIn &cloud, const PointCloudGradient &gradient, int p_idx, float radius,
+        #            const std::vector<int> &indices, const std::vector<float> &squared_distances, 
+        #            Eigen::MatrixXf &rift_descriptor);
+
+
+# ctypedef
+# 
+###
+
+# template <typename PointInT, typename GradientT>
+# class RIFTEstimation<PointInT, GradientT, Eigen::MatrixXf>: public RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >
+#     public:
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::getClassName;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::surface_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::indices_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::tree_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::search_radius_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::gradient_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::nr_gradient_bins_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::nr_distance_bins_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::compute;
+###
+
+# shot.h
+# template <typename PointInT, typename PointNT, typename PointOutT, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimationBase : public FeatureFromNormals<PointInT, PointNT, PointOutT>,
+#                            public FeatureWithLocalReferenceFrames<PointInT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTEstimationBase[In, NT, Out, RET](Feature[In, Out]):
+        SHOTEstimationBase ()
+#     public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#     protected:
+#       /** \brief Empty constructor.
+#         * \param[in] nr_shape_bins the number of bins in the shape histogram
+#         */
+#       SHOTEstimationBase (int nr_shape_bins = 10) :
+#         nr_shape_bins_ (nr_shape_bins),
+#         shot_ (),
+#         sqradius_ (0), radius3_4_ (0), radius1_4_ (0), radius1_2_ (0),
+#         nr_grid_sector_ (32),
+#         maxAngularSectors_ (28),
+#         descLength_ (0)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+#     public:
+#        /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#          * \param[in] index the index of the point in indices_
+#          * \param[in] indices the k-neighborhood point indices in surface_
+#          * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#          * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#          */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot) = 0;
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT352, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimation : public SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTEstimation[In, NT, Out, RFT](SHOTEstimationBase[In, NT, Out, RFT]):
+        SHOTEstimation ()
+#     public:
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::indices_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::k_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::surface_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::input_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::normals_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<..., pcl::SHOT, ...> IS DEPRECATED, USE SHOTEstimation<..., pcl::SHOT352, ...> INSTEAD")
+# <PointInT, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>
+# cdef extern from "pcl/features/shot.h" namespace "pcl":
+#    cdef cppclass PCL_DEPRECATED_CLASS[In, NT, RFT](SHOTEstimation[In, NT, pcl::SHOT, RFT]):
+#        SHOTEstimation ()
+#     public:
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::normals_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudIn PointCloudIn;
+#
+#       /** \brief Empty constructor.
+#         * \param[in] nr_shape_bins the number of bins in the shape histogram
+#         */
+#       SHOTEstimation (int nr_shape_bins = 10) : SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+# 
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class SHOTEstimation<PointInT, PointNT, Eigen::MatrixXf, PointRFT> : public SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>
+#     public:
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::feature_name_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::getClassName;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::indices_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::k_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::search_parameter_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::search_radius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::surface_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::input_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::normals_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::descLength_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::sqradius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius3_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius1_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius1_2_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTEstimation (int nr_shape_bins = 10) : SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT> ()
+#       {
+#         feature_name_ = "SHOTEstimation";
+#         nr_shape_bins_ = nr_shape_bins;
+#       };
+# 
+#       /** \brief Base method for feature estimation for all points given in
+#         * <setInputCloud (), setIndices ()> using the surface in setSearchSurface ()
+#         * and the spatial locator in setSearchMethod ()
+#         * \param[out] output the resultant point cloud model dataset containing the estimated features
+#         */
+#       void
+#       computeEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+#       {
+#         pcl::SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::computeEigen (output);
+#       }
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       //virtual void
+#       //computePointSHOT (const int index,
+#                         //const std::vector<int> &indices,
+#                         //const std::vector<float> &sqr_dists,
+#                         //Eigen::VectorXf &shot);
+# 
+#       void computeFeatureEigen (pcl::PointCloud<Eigen::MatrixXf> &output);
+# 
+#     
+#       /** \brief Make the compute (&PointCloudOut); inaccessible from outside the class
+#         * \param[out] output the output point cloud
+#         */
+#       void compute (pcl::PointCloud<pcl::SHOT352> &) { assert(0); }
+#   };
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT1344, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTColorEstimation : public SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTColorEstimation[In, NT, Out, RFT](SHOTEstimationBase[In, NT, Out, RFT]):
+        SHOTColorEstimation ()
+        #       SHOTColorEstimation (bool describe_shape = true,
+        #                            bool describe_color = true)
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::feature_name_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::getClassName;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::indices_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::k_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_parameter_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_radius_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::surface_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::input_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::normals_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::maxAngularSectors_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::interpolateSingleChannel;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::shot_;
+        #       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+        #       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # 
+        #       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+        #         * \param[in] index the index of the point in indices_
+        #         * \param[in] indices the k-neighborhood point indices in surface_
+        #         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+        #         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+        #         */
+        #       virtual void
+        #       computePointSHOT (const int index,
+        #                         const std::vector<int> &indices,
+        #                         const std::vector<float> &sqr_dists,
+        #                         Eigen::VectorXf &shot);
+        #     public:
+        #       /** \brief Converts RGB triplets to CIELab space.
+        #         * \param[in] R the red channel
+        #         * \param[in] G the green channel
+        #         * \param[in] B the blue channel
+        #         * \param[out] L the lightness
+        #         * \param[out] A the first color-opponent dimension
+        #         * \param[out] B2 the second color-opponent dimension
+        #         */
+        #       static void
+        #       RGB2CIELAB (unsigned char R, unsigned char G, unsigned char B, float &L, float &A, float &B2);
+        # 
+        #       static float sRGB_LUT[256];
+        #       static float sXYZ_LUT[4000];
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class SHOTColorEstimation<PointInT, PointNT, Eigen::MatrixXf, PointRFT> : public SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>
+# cdef extern from "pcl/features/shot.h" namespace "pcl":
+#     cdef cppclass SHOTColorEstimation[In, NT, Out, RFT](SHOTColorEstimation[In, NT, Out, RFT]):
+#         SHOTColorEstimation ()
+#     public:
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::feature_name_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::getClassName;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::indices_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::k_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::search_parameter_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::search_radius_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::surface_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::input_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::normals_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::descLength_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_grid_sector_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_shape_bins_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::sqradius_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius3_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius1_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius1_2_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::maxAngularSectors_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::interpolateSingleChannel;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::shot_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::b_describe_shape_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::b_describe_color_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_color_bins_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         */
+#       SHOTColorEstimation (bool describe_shape = true,
+#                            bool describe_color = true,
+#                            int nr_shape_bins = 10,
+#                            int nr_color_bins = 30)
+#         : SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT> (describe_shape, describe_color)
+#       {
+#         feature_name_ = "SHOTColorEstimation";
+#         nr_shape_bins_ = nr_shape_bins;
+#         nr_color_bins_ = nr_color_bins;
+#       };
+# 
+#       /** \brief Base method for feature estimation for all points given in
+#         * <setInputCloud (), setIndices ()> using the surface in setSearchSurface ()
+#         * and the spatial locator in setSearchMethod ()
+#         * \param[out] output the resultant point cloud model dataset containing the estimated features
+#         */
+#       void
+#       computeEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+#       {
+#         pcl::SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::computeEigen (output);
+#       }
+# 
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<pcl::PointXYZRGBA,...,pcl::SHOT,...> IS DEPRECATED, USE SHOTEstimation<pcl::PointXYZRGBA,...,pcl::SHOT352,...> FOR SHAPE AND SHOTColorEstimation<pcl::PointXYZRGBA,...,pcl::SHOT1344,...> FOR SHAPE+COLOR INSTEAD")
+#   <pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#   : public SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> 
+#     public:
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using FeatureFromNormals<pcl::PointXYZRGBA, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::shot_;
+# 
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         * \param[in] nr_shape_bins
+#         * \param[in] nr_color_bins
+#         */
+#       SHOTEstimation (bool describe_shape = true,
+#                       bool describe_color = false,
+#                       const int nr_shape_bins = 10,
+#                       const int nr_color_bins = 30)
+#         : SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins),
+#           b_describe_shape_ (describe_shape),
+#           b_describe_color_ (describe_color),
+#           nr_color_bins_ (nr_color_bins)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+#       /** \brief Quadrilinear interpolation; used when color and shape descriptions are both activated
+#         * \param[in] indices the neighborhood point indices
+#         * \param[in] sqr_dists the neighborhood point distances
+#         * \param[in] index the index of the point in indices_
+#         * \param[out] binDistanceShape the resultant distance shape histogram
+#         * \param[out] binDistanceColor the resultant color shape histogram
+#         * \param[in] nr_bins_shape the number of bins in the shape histogram
+#         * \param[in] nr_bins_color the number of bins in the color histogram
+#         * \param[out] shot the resultant SHOT histogram
+#         */
+#       void
+#       interpolateDoubleChannel (const std::vector<int> &indices,
+#                                 const std::vector<float> &sqr_dists,
+#                                 const int index,
+#                                 std::vector<double> &binDistanceShape,
+#                                 std::vector<double> &binDistanceColor,
+#                                 const int nr_bins_shape,
+#                                 const int nr_bins_color,
+#                                 Eigen::VectorXf &shot);
+# 
+#       /** \brief Converts RGB triplets to CIELab space.
+#         * \param[in] R the red channel
+#         * \param[in] G the green channel
+#         * \param[in] B the blue channel
+#         * \param[out] L the lightness
+#         * \param[out] A the first color-opponent dimension
+#         * \param[out] B2 the second color-opponent dimension
+#         */
+#       static void
+#       RGB2CIELAB (unsigned char R, unsigned char G, unsigned char B, float &L, float &A, float &B2);
+# 
+#       /** \brief Compute shape descriptor. */
+#       bool b_describe_shape_;
+# 
+#       /** \brief Compute color descriptor. */
+#       bool b_describe_color_;
+# 
+#       /** \brief The number of bins in each color histogram. */
+#       int nr_color_bins_;
+# 
+#     public:
+#       static float sRGB_LUT[256];
+#       static float sXYZ_LUT[4000];
+#   };
+
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<pcl::PointXYZRGBA,...,Eigen::MatrixXf,...> IS DEPRECATED, USE SHOTColorEstimation<pcl::PointXYZRGBA,...,Eigen::MatrixXf,...> FOR SHAPE AND SHAPE+COLOR INSTEAD")
+# <pcl::PointXYZRGBA, PointNT, Eigen::MatrixXf, PointRFT>
+# : public SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#     public:
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::shot_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_shape_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_color_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_color_bins_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         * \param[in] nr_shape_bins
+#         * \param[in] nr_color_bins
+#         */
+#       SHOTEstimation (bool describe_shape = true,
+#                       bool describe_color = false,
+#                       const int nr_shape_bins = 10,
+#                       const int nr_color_bins = 30)
+#         : SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (describe_shape, describe_color, nr_shape_bins, nr_color_bins) {};
+# 
+###
+
+# shot_lrf.h
+#  template<typename PointInT, typename PointOutT = ReferenceFrame>
+#  class SHOTLocalReferenceFrameEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/shot_lrf.h" namespace "pcl":
+    cdef cppclass SHOTLocalReferenceFrameEstimation[In, Out](Feature[In, Out]):
+        PrincipalCurvaturesEstimation ()
+        # protected:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # //using Feature<PointInT, PointOutT>::searchForNeighbors;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * \brief Computes disambiguated local RF for a point index
+        # * \param[in] cloud input point cloud
+        # * \param[in] search_radius the neighborhood radius
+        # * \param[in] central_point the point from the input_ cloud at which the local RF is computed
+        # * \param[in] indices the neighbours indices
+        # * \param[in] dists the squared distances to the neighbours
+        # * \param[out] rf reference frame to compute
+        # float getLocalRF (const int &index, Eigen::Matrix3f &rf)
+        # * \brief Feature estimation method.
+        # \param[out] output the resultant features
+        # virtual void computeFeature (PointCloudOut &output)
+        # * \brief Feature estimation method.
+        # * \param[out] output the resultant features
+        # virtual void computeFeatureEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+###
+
+# template <typename PointInT, typename PointNT>
+# class PrincipalCurvaturesEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>
+#     public:
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::indices_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::k_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::search_parameter_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::surface_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::compute;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::input_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::normals_;
+###
+
+# shot_lrf_omp.h
+# template<typename PointInT, typename PointOutT = ReferenceFrame>
+# class SHOTLocalReferenceFrameEstimationOMP : public SHOTLocalReferenceFrameEstimation<PointInT, PointOutT>
+cdef extern from "pcl/features/shot_lrf_omp.h" namespace "pcl":
+    cdef cppclass SHOTLocalReferenceFrameEstimationOMP[In, Out](SHOTLocalReferenceFrameEstimation[In, Out]):
+        SHOTLocalReferenceFrameEstimationOMP ()
+        # public:
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (unsigned int nr_threads)
+
+###
+
+# shot_omp.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT352, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimationOMP : public SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot_omp.h" namespace "pcl":
+    cdef cppclass SHOTEstimationOMP[In, NT, Out, RFT](SHOTEstimation[In, NT, Out, RFT]):
+        SHOTEstimationOMP ()
+        # SHOTEstimationOMP (unsigned int nr_threads = - 1)
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::fake_surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # 
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        #  * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        inline void setNumberOfThreads (unsigned int nr_threads)
+        
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT1344, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTColorEstimationOMP : public SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>
+#     public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::b_describe_shape_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::b_describe_color_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_color_bins_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTColorEstimationOMP (bool describe_shape = true,
+#                               bool describe_color = true,
+#                               unsigned int nr_threads = - 1)
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void setNumberOfThreads (unsigned int nr_threads)
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimationOMP, "SHOTEstimationOMP<..., pcl::SHOT, ...> IS DEPRECATED, USE SHOTEstimationOMP<..., pcl::SHOT352, ...> INSTEAD")
+# <PointInT, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>
+#     public:
+#       using Feature<PointInT, pcl::SHOT>::feature_name_;
+#       using Feature<PointInT, pcl::SHOT>::getClassName;
+#       using Feature<PointInT, pcl::SHOT>::input_;
+#       using Feature<PointInT, pcl::SHOT>::indices_;
+#       using Feature<PointInT, pcl::SHOT>::k_;
+#       using Feature<PointInT, pcl::SHOT>::search_parameter_;
+#       using Feature<PointInT, pcl::SHOT>::search_radius_;
+#       using Feature<PointInT, pcl::SHOT>::surface_;
+#       using Feature<PointInT, pcl::SHOT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudIn PointCloudIn;
+#       /** \brief Empty constructor. */
+#       SHOTEstimationOMP (unsigned int nr_threads = - 1, int nr_shape_bins = 10)
+#         : SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins), threads_ ()
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void setNumberOfThreads (unsigned int nr_threads)
+# 
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimationOMP, "SHOTEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT,...> IS DEPRECATED, USE SHOTEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT352,...> FOR SHAPE AND SHOTColorEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT1344,...> FOR SHAPE+COLOR INSTEAD")
+# <pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#       public:
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using FeatureFromNormals<pcl::PointXYZRGBA, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_shape_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_color_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_color_bins_;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTEstimationOMP (bool describeShape = true,
+#                          bool describeColor = false,
+#                          unsigned int nr_threads = - 1,
+#                          const int nr_shape_bins = 10,
+#                          const int nr_color_bins = 30)
+#         : SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (describeShape, describeColor, nr_shape_bins, nr_color_bins),
+#           threads_ ()
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void
+#       setNumberOfThreads (unsigned int nr_threads)
+###
+
+# spin_image.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class SpinImageEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/spin_image.h" namespace "pcl":
+    cdef cppclass SpinImageEstimation[In, NT, Out](Feature[In, Out]):
+        SpinImageEstimation ()
+        # SpinImageEstimation (unsigned int image_width = 8,
+        #                    double support_angle_cos = 0.0,   // when 0, this is bogus, so not applied
+        #                    unsigned int min_pts_neighb = 0);
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::fake_surface_;
+        # using PCLBase<PointInT>::input_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # typedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename boost::shared_ptr<SpinImageEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const SpinImageEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # /** \brief Sets spin-image resolution.
+        #  * \param[in] bin_count spin-image resolution, number of bins along one dimension
+        void setImageWidth (unsigned int bin_count)
+        # /** \brief Sets the maximum angle for the point normal to get to support region.
+        #   * \param[in] support_angle_cos minimal allowed cosine of the angle between 
+        #   *   the normals of input point and search surface point for the point 
+        #   *   to be retained in the support
+        void setSupportAngle (double support_angle_cos)
+        # /** \brief Sets minimal points count for spin image computation.
+        #   * \param[in] min_pts_neighb min number of points in the support to correctly estimate 
+        #   *   spin-image. If at some point the support contains less points, exception is thrown
+        void setMinPointCountInNeighbourhood (unsigned int min_pts_neighb)
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        #  * the input XYZ dataset given by \ref setInputCloud
+        #  * \attention The input normals given by \ref setInputNormals have to match
+        #  * the input point cloud given by \ref setInputCloud. This behavior is
+        #  * different than feature estimation methods that extend \ref
+        #  * FeatureFromNormals, which match the normals with the search surface.
+        #  * \param[in] normals the const boost shared pointer to a PointCloud of normals. 
+        #  * By convention, L2 norm of each normal should be 1. 
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # /** \brief Sets single vector a rotation axis for all input points.
+        #   * It could be useful e.g. when the vertical axis is known.
+        #   * \param[in] axis unit-length vector that serves as rotation axis for reference frame
+        # void setRotationAxis (const PointNT& axis)
+        # /** \brief Sets array of vectors as rotation axes for input points.
+        #  * Useful e.g. when one wants to use tangents instead of normals as rotation axes
+        #  * \param[in] axes unit-length vectors that serves as rotation axes for 
+        #  *   the corresponding input points' reference frames
+        # void setInputRotationAxes (const PointCloudNConstPtr& axes)
+        # /** \brief Sets input normals as rotation axes (default setting). */
+        void useNormalsAsRotationAxis () 
+        # /** \brief Sets/unsets flag for angular spin-image domain.
+        #   * Angular spin-image differs from the vanilla one in the way that not 
+        #   * the points are collected in the bins but the angles between their
+        #   * normals and the normal to the reference point. For further
+        #   * information please see 
+        #   * Endres, F., Plagemann, C., Stachniss, C., & Burgard, W. (2009). 
+        #   * Unsupervised Discovery of Object Classes from Range Data using Latent Dirichlet Allocation. 
+        #   * In Robotics: Science and Systems. Seattle, USA.
+        #   * \param[in] is_angular true for angular domain, false for point domain
+        void setAngularDomain (bool is_angular = true)
+        # /** \brief Sets/unsets flag for radial spin-image structure.
+        #   * 
+        #   * Instead of rectangular coordinate system for reference frame 
+        #   * polar coordinates are used. Binning is done depending on the distance and 
+        #   * inclination angle from the reference point
+        #   * \param[in] is_radial true for radial spin-image structure, false for rectangular
+        # */
+        void setRadialStructure (bool is_radial = true)
+
+
+####
+
+# template <typename PointInT, typename PointNT>
+# class SpinImageEstimation<PointInT, PointNT, Eigen::MatrixXf> : public SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >
+# cdef extern from "pcl/features/spin_image.h" namespace "pcl":
+#    cdef cppclass SpinImageEstimation[In, NT, Eigen::MatrixXf](SpinImageEstimation[In, NT, pcl::Histogram<153>]):
+#       SpinImageEstimation ()
+#       public:
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::indices_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::search_radius_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::k_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::surface_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::fake_surface_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::compute;
+# 
+#       /** \brief Constructs empty spin image estimator.
+#         * 
+#         * \param[in] image_width spin-image resolution, number of bins along one dimension
+#         * \param[in] support_angle_cos minimal allowed cosine of the angle between 
+#         *   the normals of input point and search surface point for the point 
+#         *   to be retained in the support
+#         * \param[in] min_pts_neighb min number of points in the support to correctly estimate 
+#         *   spin-image. If at some point the support contains less points, exception is thrown
+#         */
+#       SpinImageEstimation (unsigned int image_width = 8,
+#                            double support_angle_cos = 0.0,   // when 0, this is bogus, so not applied
+#                            unsigned int min_pts_neighb = 0) : 
+#       SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> > (image_width, support_angle_cos, min_pts_neighb) {}
+###
+
+# statistical_multiscale_interest_region_extraction.h
+# template <typename PointT>
+# class StatisticalMultiscaleInterestRegionExtraction : public PCLBase<PointT>
+cdef extern from "pcl/features/statistical_multiscale_interest_region_extraction.h" namespace "pcl":
+    cdef cppclass StatisticalMultiscaleInterestRegionExtraction[T](cpp.PCLBase[T]):
+        StatisticalMultiscaleInterestRegionExtraction ()
+        # public:
+        # typedef boost::shared_ptr <std::vector<int> > IndicesPtr;
+        # typedef typename boost::shared_ptr<StatisticalMultiscaleInterestRegionExtraction<PointT> > Ptr;
+        # typedef typename boost::shared_ptr<const StatisticalMultiscaleInterestRegionExtraction<PointT> > ConstPtr;
+        
+        # brief Method that generates the underlying nearest neighbor graph based on the input point cloud
+        void generateCloudGraph ()
+        
+        # brief The method to be called in order to run the algorithm and produce the resulting
+        # set of regions of interest
+        # void computeRegionsOfInterest (list[IndicesPtr_t]& rois)
+        
+        # brief Method for setting the scale parameters for the algorithm
+        # param scale_values vector of scales to determine the size of each scaling step
+        inline void setScalesVector (vector[float] &scale_values)
+        
+        # brief Method for getting the scale parameters vector */
+        inline vector[float] getScalesVector ()
+###
+
+# usc.h
+# template <typename PointInT, typename PointOutT, typename PointRFT = pcl::ReferenceFrame>
+# class UniqueShapeContext : public Feature<PointInT, PointOutT>,
+#                            public FeatureWithLocalReferenceFrames<PointInT, PointRFT>
+# cdef extern from "pcl/features/usc.h" namespace "pcl":
+#     cdef cppclass UniqueShapeContext[In, Out, RFT](Feature[In, Out], FeatureWithLocalReferenceFrames[In, RFT]):
+#        VFHEstimation ()
+#        public:
+#        using Feature<PointInT, PointOutT>::feature_name_;
+#        using Feature<PointInT, PointOutT>::getClassName;
+#        using Feature<PointInT, PointOutT>::indices_;
+#        using Feature<PointInT, PointOutT>::search_parameter_;
+#        using Feature<PointInT, PointOutT>::search_radius_;
+#        using Feature<PointInT, PointOutT>::surface_;
+#        using Feature<PointInT, PointOutT>::fake_surface_;
+#        using Feature<PointInT, PointOutT>::input_;
+#        using Feature<PointInT, PointOutT>::searchForNeighbors;
+#        using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#        typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#        typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#        typedef typename boost::shared_ptr<UniqueShapeContext<PointInT, PointOutT, PointRFT> > Ptr;
+#        typedef typename boost::shared_ptr<const UniqueShapeContext<PointInT, PointOutT, PointRFT> > ConstPtr;
+#        /** \brief Constructor. */
+#        UniqueShapeContext () :
+#       /** \brief Set the number of bins along the azimuth
+#         * \param[in] bins the number of bins along the azimuth
+#       inline void setAzimuthBins (size_t bins)
+#       /** \return The number of bins along the azimuth. */
+#       inline size_t getAzimuthBins () const
+#       /** \brief Set the number of bins along the elevation
+#         * \param[in] bins the number of bins along the elevation
+#         */
+#       inline void setElevationBins (size_t bins)
+#       /** \return The number of bins along the elevation */
+#       inline size_t getElevationBins () const
+#       /** \brief Set the number of bins along the radii
+#         * \param[in] bins the number of bins along the radii
+#       inline void setRadiusBins (size_t bins)
+#       /** \return The number of bins along the radii direction. */
+#       inline size_t getRadiusBins () const
+#       /** The minimal radius value for the search sphere (rmin) in the original paper
+#         * \param[in] radius the desired minimal radius
+#       inline void setMinimalRadius (double radius)
+#       /** \return The minimal sphere radius. */
+#       inline double
+#       getMinimalRadius () const
+#       /** This radius is used to compute local point density
+#         * density = number of points within this radius
+#         * \param[in] radius Value of the point density search radius
+#       inline void setPointDensityRadius (double radius)
+#       /** \return The point density search radius. */
+#       inline double getPointDensityRadius () const
+#       /** Set the local RF radius value
+#         * \param[in] radius the desired local RF radius
+#       inline void setLocalRadius (double radius)
+#       /** \return The local RF radius. */
+#       inline double getLocalRadius () const
+#
+###
+
+# usc.h
+# template <typename PointInT, typename PointRFT>
+# class UniqueShapeContext<PointInT, Eigen::MatrixXf, PointRFT> : public UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>
+# cdef extern from "pcl/features/usc.h" namespace "pcl":
+#     cdef cppclass UniqueShapeContext[In, Eigen::MatrixXf, RET](UniqueShapeContext[In, pcl::SHOT, RET]):
+#       UniqueShapeContext ()
+#       public:
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::indices_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::descriptor_length_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::compute;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::computePointDescriptor;
+###
+
+# vfh.h
+# template<typename PointInT, typename PointNT, typename PointOutT = pcl::VFHSignature308>
+# class VFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/vfh.h" namespace "pcl":
+    cdef cppclass VFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        VFHEstimation ()
+        # public:
+        # /** \brief Estimate the SPFH (Simple Point Feature Histograms) signatures of the angular
+        #   * (f1, f2, f3) and distance (f4) features for a given point from its neighborhood
+        #   * \param[in] centroid_p the centroid point
+        #   * \param[in] centroid_n the centroid normal
+        #   * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        #   * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        #   * \param[in] indices the k-neighborhood point indices in the dataset
+        # void computePointSPFHSignature (const Eigen::Vector4f &centroid_p, const Eigen::Vector4f &centroid_n,
+        #                            const pcl::PointCloud<PointInT> &cloud, const pcl::PointCloud<PointNT> &normals,
+        #                            const std::vector<int> &indices);
+        # 
+        # /** \brief Set the viewpoint.
+        #   * \param[in] vpx the X coordinate of the viewpoint
+        #   * \param[in] vpy the Y coordinate of the viewpoint
+        #   * \param[in] vpz the Z coordinate of the viewpoint
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # /** \brief Get the viewpoint. */
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        # 
+        # /** \brief Set use_given_normal_
+        #   * \param[in] use Set to true if you want to use the normal passed to setNormalUse(normal)
+        #   */
+        # inline void setUseGivenNormal (bool use)
+        # 
+        # /** \brief Set the normal to use
+        #   * \param[in] normal Sets the normal to be used in the VFH computation. It is is used
+        #   * to build the Darboux Coordinate system.
+        #   */
+        # inline void setNormalToUse (const Eigen::Vector3f &normal)
+        # 
+        # /** \brief Set use_given_centroid_
+        #   * \param[in] use Set to true if you want to use the centroid passed through setCentroidToUse(centroid)
+        #   */
+        # inline void setUseGivenCentroid (bool use)
+        # 
+        # /** \brief Set centroid_to_use_
+        #   * \param[in] centroid Centroid to be used in the VFH computation. It is used to compute the distances
+        #   * from all points to this centroid.
+        #   */
+        # inline void setCentroidToUse (const Eigen::Vector3f &centroid)
+        # 
+        # /** \brief set normalize_bins_
+        #   * \param[in] normalize If true, the VFH bins are normalized using the total number of points
+        #   */
+        # inline void setNormalizeBins (bool normalize)
+        # 
+        # /** \brief set normalize_distances_
+        #   * \param[in] normalize If true, the 4th component of VFH (shape distribution component) get normalized
+        #   * by the maximum size between the centroid and the point cloud
+        #   */
+        # inline void setNormalizeDistance (bool normalize)
+        # 
+        # /** \brief set size_component_
+        #   * \param[in] fill_size True if the 4th component of VFH (shape distribution component) needs to be filled.
+        #   * Otherwise, it is set to zero.
+        #   */
+        # inline void setFillSizeComponent (bool fill_size)
+        # 
+        # /** \brief Overloaded computed method from pcl::Feature.
+        #   * \param[out] output the resultant point cloud model dataset containing the estimated features
+        #   */
+        # void compute (cpp.PointCloud[Out] &output);
+
+
+ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+# Template
+# # enum CoordinateFrame
+# # CAMERA_FRAME = 0,
+# # LASER_FRAME = 1
+# Start
+# cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+#     ctypedef enum CoordinateFrame2 "pcl::RangeImage::CoordinateFrame":
+#         COORDINATEFRAME_CAMERA "pcl::RangeImage::CAMERA_FRAME"
+#         COORDINATEFRAME_LASER "pcl::RangeImage::LASER_FRAME"
+###
+
+# integral_image_normal.h
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#         cdef enum BorderPolicy:
+#             BORDER_POLICY_IGNORE
+#             BORDER_POLICY_MIRROR
+# NG : IntegralImageNormalEstimation use Template
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#     ctypedef enum BorderPolicy2 "pcl::IntegralImageNormalEstimation::BorderPolicy":
+#         BORDERPOLICY_IGNORE "pcl::IntegralImageNormalEstimation::BORDER_POLICY_IGNORE"
+#         BORDERPOLICY_MIRROR "pcl::IntegralImageNormalEstimation::BORDER_POLICY_MIRROR"
+###
+
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#         cdef enum NormalEstimationMethod:
+#             COVARIANCE_MATRIX
+#             AVERAGE_3D_GRADIENT
+#             AVERAGE_DEPTH_CHANGE
+#             SIMPLE_3D_GRADIENT
+# 
+# NG : IntegralImageNormalEstimation use Template
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+#     ctypedef enum NormalEstimationMethod2 "pcl::IntegralImageNormalEstimation::NormalEstimationMethod":
+#         ESTIMATIONMETHOD_COVARIANCE_MATRIX "pcl::IntegralImageNormalEstimation::COVARIANCE_MATRIX"
+#         ESTIMATIONMETHOD_AVERAGE_3D_GRADIENT "pcl::IntegralImageNormalEstimation::AVERAGE_3D_GRADIENT"
+#         ESTIMATIONMETHOD_AVERAGE_DEPTH_CHANGE "pcl::IntegralImageNormalEstimation::AVERAGE_DEPTH_CHANGE"
+#         ESTIMATIONMETHOD_SIMPLE_3D_GRADIENT "pcl::IntegralImageNormalEstimation::SIMPLE_3D_GRADIENT"
+# NG : (Test Cython 0.24.1)
+# define __PYX_VERIFY_RETURN_INT/__PYX_VERIFY_RETURN_INT_EXC etc... , Convert Error "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::NormalEstimationMethod"
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#     ctypedef enum NormalEstimationMethod2 "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::NormalEstimationMethod":
+#         ESTIMATIONMETHOD_COVARIANCE_MATRIX "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::COVARIANCE_MATRIX"
+#         ESTIMATIONMETHOD_AVERAGE_3D_GRADIENT "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::AVERAGE_3D_GRADIENT"
+#         ESTIMATIONMETHOD_AVERAGE_DEPTH_CHANGE "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::AVERAGE_DEPTH_CHANGE"
+#         ESTIMATIONMETHOD_SIMPLE_3D_GRADIENT "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::SIMPLE_3D_GRADIENT"
+###
+
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_features_172.pxd b/pcl/pcl_features_172.pxd
new file mode 100644
index 0000000..138ae72
--- /dev/null
+++ b/pcl/pcl_features_172.pxd
@@ -0,0 +1,3819 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_kdtree_172 as pclkdt
+cimport pcl_range_image_172 as pcl_r_img
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# feature.h
+# class Feature : public PCLBase<PointInT>
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass Feature[In, Out](cpp.PCLBase[In]):
+        Feature ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::input_;
+        # ctypedef PCLBase<PointInT> BaseClass;
+        # ctypedef boost::shared_ptr< Feature<PointInT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const Feature<PointInT, PointOutT> > ConstPtr;
+        # ctypedef typename pcl::search::Search<PointInT> KdTree;
+        # ctypedef typename pcl::search::Search<PointInT>::Ptr KdTreePtr;
+        # ctypedef pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # ctypedef boost::function<int (size_t, double, std::vector<int> &, std::vector<float> &)> SearchMethod;
+        # ctypedef boost::function<int (const PointCloudIn &cloud, size_t index, double, std::vector<int> &, std::vector<float> &)> SearchMethodSurface;
+        # public:
+        # inline void setSearchSurface (const cpp.PointCloudPtr_t &)
+        # inline cpp.PointCloudPtr_t getSearchSurface () const
+        void setSearchSurface (const In &)
+        In getSearchSurface () const
+        
+        # inline void setSearchMethod (const KdTreePtr &tree)
+        # void setSearchMethod (pclkdt.KdTreePtr_t tree)
+        # void setSearchMethod (pclkdt.KdTreeFLANNPtr_t tree)
+        # void setSearchMethod (pclkdt.KdTreeFLANNConstPtr_t &tree)
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # inline KdTreePtr getSearchMethod () const
+        # pclkdt.KdTreePtr_t getSearchMethod ()
+        # pclkdt.KdTreeFLANNPtr_t getSearchMethod ()
+        # pclkdt.KdTreeFLANNConstPtr_t getSearchMethod ()
+        
+        double getSearchParameter ()
+        void setKSearch (int search)
+        int getKSearch () const
+        void setRadiusSearch (double radius)
+        double getRadiusSearch ()
+        
+        # void compute (PointCloudOut &output);
+        # void compute (cpp.PointCloudPtr_t output)
+        # void compute (cpp.PointCloud_PointXYZI_Ptr_t output)
+        # void compute (cpp.PointCloud_PointXYZRGB_Ptr_t output)
+        # void compute (cpp.PointCloud_PointXYZRGBA_Ptr_t output)
+        void compute (cpp.PointCloud[Out] &output)
+        
+        # void computeEigen (cpp.PointCloud[Eigen::MatrixXf] &output);
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class FeatureFromNormals : public Feature<PointInT, PointOutT>
+# cdef cppclass FeatureFromNormals(Feature[In, Out]):
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureFromNormals[In, NT, Out](Feature[In, Out]):
+        FeatureFromNormals()
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # ctypedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # ctypedef typename PointCloudN::Ptr PointCloudNPtr;
+        # ctypedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # ctypedef boost::shared_ptr< FeatureFromNormals<PointInT, PointNT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const FeatureFromNormals<PointInT, PointNT, PointOutT> > ConstPtr;
+        # // Members derived from the base class
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of
+        #         * the XYZ dataset.
+        # * In case of search surface is set to be different from the input cloud,
+        # * normals should correspond to the search surface, not the input cloud!
+        # * \param[in] normals the const boost shared pointer to a PointCloud of normals.
+        # * By convention, L2 norm of each normal should be 1.
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        void setInputNormals (cpp.PointCloud_Normal_Ptr_t normals)
+        
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals ()
+
+
+###
+
+# 3dsc.h
+# class ShapeContext3DEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/3dsc.h" namespace "pcl":
+    cdef cppclass ShapeContext3DEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        ShapeContext3DEstimation(bool)
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::searchForNeighbors;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        ##
+        # brief Set the number of bins along the azimuth to \a bins.
+        # param[in] bins the number of bins along the azimuth
+        void setAzimuthBins (size_t bins)
+        # return the number of bins along the azimuth
+        size_t getAzimuthBins () 
+        # brief Set the number of bins along the elevation to \a bins.
+        # param[in] bins the number of bins along the elevation
+        void setElevationBins (size_t )
+        # return The number of bins along the elevation
+        size_t getElevationBins ()
+        # brief Set the number of bins along the radii to \a bins.
+        # param[in] bins the number of bins along the radii
+        void setRadiusBins (size_t )
+        # return The number of bins along the radii direction
+        size_t getRadiusBins ()
+        # brief The minimal radius value for the search sphere (rmin) in the original paper 
+        # param[in] radius the desired minimal radius
+        void setMinimalRadius (double radius)
+        # return The minimal sphere radius
+        double getMinimalRadius ()
+        # brief This radius is used to compute local point density 
+        # density = number of points within this radius
+        # param[in] radius value of the point density search radius
+        void setPointDensityRadius (double radius)
+        # return The point density search radius
+        double getPointDensityRadius ()
+        
+###
+
+# feature.h
+# cdef extern from "pcl/features/feature.h" namespace "pcl":
+#     cdef inline void solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix,
+#                                             const Eigen::Vector4f &point,
+#                                             Eigen::Vector4f &plane_parameters, float &curvature);
+#     cdef inline void solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix,
+#                         float &nx, float &ny, float &nz, float &curvature);
+# template <typename PointInT, typename PointLT, typename PointOutT>
+# class FeatureFromLabels : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureFromLabels[In, LT, Out](Feature[In, Out]):
+        FeatureFromLabels()
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # ctypedef typename PointCloudL::Ptr PointCloudNPtr;
+        # ctypedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # ctypedef boost::shared_ptr< FeatureFromLabels<PointInT, PointLT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const FeatureFromLabels<PointInT, PointLT, PointOutT> > ConstPtr;
+        # // Members derived from the base class
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::k_;
+        # /** \brief Provide a pointer to the input dataset that contains the point labels of
+        #   * the XYZ dataset.
+        #   * In case of search surface is set to be different from the input cloud,
+        #   * labels should correspond to the search surface, not the input cloud!
+        #   * \param[in] labels the const boost shared pointer to a PointCloud of labels.
+        #   */
+        # inline void setInputLabels (const PointCloudLConstPtr &labels)
+        # inline PointCloudLConstPtr getInputLabels () const
+###
+
+### Inheritance class ###
+
+# > 1.7.2
+# board.h
+# namespace pcl
+# /** \brief BOARDLocalReferenceFrameEstimation implements the BOrder Aware Repeatable Directions algorithm
+# * for local reference frame estimation as described here:
+# *  - A. Petrelli, L. Di Stefano,
+# *    "On the repeatability of the local reference frame for partial shape matching",
+# *    13th International Conference on Computer Vision (ICCV), 2011
+# *
+# * \author Alioscia Petrelli (original), Tommaso Cavallari (PCL port)
+# * \ingroup features
+# */
+# template<typename PointInT, typename PointNT, typename PointOutT = ReferenceFrame>
+# class BOARDLocalReferenceFrameEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/board.h" namespace "pcl":
+    cdef cppclass BOARDLocalReferenceFrameEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        BOARDLocalReferenceFrameEstimation()
+        # public:
+        # typedef boost::shared_ptr<BOARDLocalReferenceFrameEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const BOARDLocalReferenceFrameEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # /** \brief Constructor. */
+        # BOARDLocalReferenceFrameEstimation () :
+        #   tangent_radius_ (0.0f),
+        #   find_holes_ (false),
+        #   margin_thresh_ (0.85f),
+        #   check_margin_array_size_ (24),
+        #   hole_size_prob_thresh_ (0.2f),
+        #   steep_thresh_ (0.1f),
+        #   check_margin_array_ (),
+        #   margin_array_min_angle_ (),
+        #   margin_array_max_angle_ (),
+        #   margin_array_min_angle_normal_ (),
+        #   margin_array_max_angle_normal_ ()
+        # {
+        #   feature_name_ = "BOARDLocalReferenceFrameEstimation";
+        #   setCheckMarginArraySize (check_margin_array_size_);
+        # }
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~BOARDLocalReferenceFrameEstimation () {}
+        # 
+        # //Getters/Setters
+        # /** \brief Set the maximum distance of the points used to estimate the x_axis and y_axis of the BOARD Reference Frame for a given point.
+        #   *
+        #   * \param[in] radius The search radius for x and y axes. If not set or set to 0 the parameter given with setRadiusSearch is used.
+        #   */
+        # inline void setTangentRadius (float radius)
+        # 
+        # /** \brief Get the maximum distance of the points used to estimate the x_axis and y_axis of the BOARD Reference Frame for a given point.
+        #   *
+        #   * \return The search radius for x and y axes. If set to 0 the parameter given with setRadiusSearch is used.
+        #   */
+        # inline float getTangentRadius () const
+        # 
+        # /** \brief Sets whether holes in the margin of the support, for each point, are searched and accounted for in the estimation of the 
+        # *          Reference Frame or not.
+        # *
+        # * \param[in] find_holes Enable/Disable the search for holes in the support.
+        # */
+        # inline void setFindHoles (bool find_holes)
+        # 
+        # /** \brief Gets whether holes in the margin of the support, for each point, are searched and accounted for in the estimation of the 
+        # *          Reference Frame or not.
+        # *
+        # * \return The search for holes in the support is enabled/disabled.
+        # */
+        # inline bool getFindHoles () const
+        # 
+        # /** \brief Sets the percentage of the search radius (or tangent radius if set) after which a point is considered part of the support margin.
+        # *
+        # * \param[in] margin_thresh the percentage of the search radius after which a point is considered a margin point.
+        # */
+        # inline void setMarginThresh (float margin_thresh)
+        # 
+        # /** \brief Gets the percentage of the search radius (or tangent radius if set) after which a point is considered part of the support margin.
+        # *
+        # * \return The percentage of the search radius after which a point is considered a margin point.
+        # */
+        # inline float getMarginThresh () const
+        # 
+        # /** \brief Sets the number of slices in which is divided the margin for the search of missing regions.
+        # *
+        # * \param[in] size the number of margin slices.
+        # */
+        # void setCheckMarginArraySize (int size)
+        # 
+        # /** \brief Gets the number of slices in which is divided the margin for the search of missing regions.
+        # *
+        # * \return the number of margin slices.
+        # */
+        # inline int getCheckMarginArraySize () const
+        # 
+        # /** \brief Given the angle width of a hole in the support margin, sets the minimum percentage of a circumference this angle 
+        # *         must cover to be considered a missing region in the support and hence used for the estimation of the Reference Frame.
+        # * \param[in] prob_thresh the minimum percentage of a circumference after which a hole is considered in the calculation
+        # */
+        # inline void setHoleSizeProbThresh (float prob_thresh)
+        # 
+        # /** \brief Given the angle width of a hole in the support margin, gets the minimum percentage of a circumference this angle 
+        # *         must cover to be considered a missing region in the support and hence used for the estimation of the Reference Frame.
+        # * \return the minimum percentage of a circumference after which a hole is considered in the calculation
+        # */
+        # inline float getHoleSizeProbThresh () const
+        # 
+        # /** \brief Sets the minimum steepness that the normals of the points situated on the borders of the hole, with reference
+        # *         to the normal of the best point found by the algorithm, must have in order to be considered in the calculation of the Reference Frame.
+        # * \param[in] steep_thresh threshold that defines if a missing region contains a point with the most different normal.
+        # */
+        # inline void setSteepThresh (float steep_thresh)
+        # 
+        # /** \brief Gets the minimum steepness that the normals of the points situated on the borders of the hole, with reference
+        # *         to the normal of the best point found by the algorithm, must have in order to be considered in the calculation of the Reference Frame.
+        # * \return threshold that defines if a missing region contains a point with the most different normal.
+        # */
+        # inline float getSteepThresh () const
+
+
+###
+
+# cppf.h
+# namespace pcl
+#   /** \brief
+#     * \param[in] p1 
+#     * \param[in] n1
+#     * \param[in] p2 
+#     * \param[in] n2
+#     * \param[in] c1
+#     * \param[in] c2
+#     * \param[out] f1
+#     * \param[out] f2
+#     * \param[out] f3
+#     * \param[out] f4
+#     * \param[out] f5
+#     * \param[out] f6
+#     * \param[out] f7
+#     * \param[out] f8
+#     * \param[out] f9
+#     * \param[out] f10
+#     */
+#   computeCPPFPairFeature (const Eigen::Vector4f &p1, const Eigen::Vector4f &n1, const Eigen::Vector4i &c1,
+#                             const Eigen::Vector4f &p2, const Eigen::Vector4f &n2, const Eigen::Vector4i &c2,
+#                             float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7, float &f8, float &f9, float &f10);
+# 
+##
+# cppf.h
+# namespace pcl
+# /** \brief Class that calculates the "surflet" features for each pair in the given
+# * pointcloud. Please refer to the following publication for more details:
+# *    C. Choi, Henrik Christensen
+# *    3D Pose Estimation of Daily Objects Using an RGB-D Camera
+# *    Proceedings of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)
+# *    2012
+# *
+# * PointOutT is meant to be pcl::CPPFSignature - contains the 10 values of the Surflet
+# * feature and in addition, alpha_m for the respective pair - optimization proposed by
+# * the authors (see above)
+# *
+# * \author Martin Szarski, Alexandru-Eugen Ichim
+# */
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class CPPFEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+# cdef extern from "pcl/features/cppf.h" namespace "pcl":
+#     cdef cppclass CPPFEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+#         CPPFEstimation()
+        # public:
+        # typedef boost::shared_ptr<CPPFEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const CPPFEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # 
+        # /** \brief Empty Constructor. */
+        # CPPFEstimation ();
+
+
+###
+
+# crh.h
+# namespace pcl
+# /** \brief CRHEstimation estimates the Camera Roll Histogram (CRH) descriptor for a given
+# * point cloud dataset containing XYZ data and normals, as presented in:
+# *   - CAD-Model Recognition and 6 DOF Pose Estimation
+# *     A. Aldoma, N. Blodow, D. Gossow, S. Gedikli, R.B. Rusu, M. Vincze and G. Bradski
+# *     ICCV 2011, 3D Representation and Recognition (3dRR11) workshop
+# *     Barcelona, Spain, (2011)
+# *
+# * The suggested PointOutT is pcl::Histogram<90>. //dc (real) + 44 complex numbers (real, imaginary) + nyquist (real)
+# *
+# * \author Aitor Aldoma
+# * \ingroup features
+# */
+# template<typename PointInT, typename PointNT, typename PointOutT = pcl::Histogram<90> >
+# class CRHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/crh.h" namespace "pcl":
+    cdef cppclass CRHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        CRHEstimation()
+        # public:
+        # typedef boost::shared_ptr<CRHEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const CRHEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # 
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # 
+        # /** \brief Constructor. */
+        # CRHEstimation () : vpx_ (0), vpy_ (0), vpz_ (0), nbins_ (90)
+        # 
+        # /** \brief Set the viewpoint.
+        # * \param[in] vpx the X coordinate of the viewpoint
+        # * \param[in] vpy the Y coordinate of the viewpoint
+        # * \param[in] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # /** \brief Get the viewpoint. 
+        # * \param[out] vpx the X coordinate of the viewpoint
+        # * \param[out] vpy the Y coordinate of the viewpoint
+        # * \param[out] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        # inline void setCentroid (Eigen::Vector4f & centroid)
+
+
+###
+
+# don.h
+# namespace pcl
+# /** \brief A Difference of Normals (DoN) scale filter implementation for point cloud data.
+# * For each point in the point cloud two normals estimated with a differing search radius (sigma_s, sigma_l)
+# * are subtracted, the difference of these normals provides a scale-based feature which
+# * can be further used to filter the point cloud, somewhat like the Difference of Guassians
+# * in image processing, but instead on surfaces. Best results are had when the two search
+# * radii are related as sigma_l=10*sigma_s, the octaves between the two search radii
+# * can be though of as a filter bandwidth. For appropriate values and thresholds it
+# * can be used for surface edge extraction.
+# * \attention The input normals given by setInputNormalsSmall and setInputNormalsLarge have
+# * to match the input point cloud given by setInputCloud. This behavior is different than
+# * feature estimation methods that extend FeatureFromNormals, which match the normals
+# * with the search surface.
+# * \note For more information please see
+# *    <b>Yani Ioannou. Automatic Urban Modelling using Mobile Urban LIDAR Data.
+# *    Thesis (Master, Computing), Queen's University, March, 2010.</b>
+# * \author Yani Ioannou.
+# * \ingroup features
+# */
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class DifferenceOfNormalsEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/don.h" namespace "pcl":
+    cdef cppclass DifferenceOfNormalsEstimation[In, NT, Out](Feature[In, Out]):
+        DifferenceOfNormalsEstimation()
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using PCLBase<PointInT>::input_;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # typedef boost::shared_ptr<DifferenceOfNormalsEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const DifferenceOfNormalsEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # /**
+        # * Creates a new Difference of Normals filter.
+        # */
+        # DifferenceOfNormalsEstimation ()
+        # virtual ~DifferenceOfNormalsEstimation ()
+        # 
+        # /**
+        # * Set the normals calculated using a smaller search radius (scale) for the DoN operator.
+        # * @param normals the smaller radius (scale) of the DoN filter.
+        # */
+        # inline void setNormalScaleSmall (const PointCloudNConstPtr &normals)
+        # 
+        # /**
+        # * Set the normals calculated using a larger search radius (scale) for the DoN operator.
+        # * @param normals the larger radius (scale) of the DoN filter.
+        # */
+        # inline void setNormalScaleLarge (const PointCloudNConstPtr &normals)
+        # 
+        # /**
+        # * Computes the DoN vector for each point in the input point cloud and outputs the vector cloud to the given output.
+        # * @param output the cloud to output the DoN vector cloud to.
+        # */
+        # virtual void computeFeature (PointCloudOut &output);
+        # 
+        # /**
+        # * Initialize for computation of features.
+        # * @return true if parameters (input normals, input) are sufficient to perform computation.
+        # */
+        # virtual bool initCompute ();
+
+
+###
+
+# gfpfh.h
+# namespace pcl
+# /** \brief @b GFPFHEstimation estimates the Global Fast Point Feature Histogram (GFPFH) descriptor for a given point
+#   * cloud dataset containing points and labels.
+#   * @note If you use this code in any academic work, please cite:
+#   * <ul>
+#   * <li> R.B. Rusu, A. Holzbach, M. Beetz.
+#   *      Detecting and Segmenting Objects for Mobile Manipulation.
+#   *      In the S3DV Workshop of the 12th International Conference on Computer Vision (ICCV),
+#   *      2009.
+#   * </li>
+#   * </ul>
+#   * \author Radu B. Rusu
+#   * \ingroup features
+#   */
+# template <typename PointInT, typename PointLT, typename PointOutT>
+# class GFPFHEstimation : public FeatureFromLabels<PointInT, PointLT, PointOutT>
+cdef extern from "pcl/features/gfpfh.h" namespace "pcl":
+    cdef cppclass GFPFHEstimation[In, LT, Out](FeatureFromLabels[In, LT, Out]):
+        DifferenceOfNormalsEstimation()
+        # public:
+        # typedef boost::shared_ptr<GFPFHEstimation<PointInT, PointLT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const GFPFHEstimation<PointInT, PointLT, PointOutT> > ConstPtr;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::feature_name_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::getClassName;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::indices_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::k_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::search_parameter_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::surface_;
+        # 
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::input_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::labels_;
+        # 
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # 
+        # /** \brief Empty constructor. */
+        # GFPFHEstimation () : octree_leaf_size_ (0.01), number_of_classes_ (16), descriptor_size_ (PointOutT::descriptorSize ())
+        # 
+        # /** \brief Set the size of the octree leaves.
+        #   */
+        # inline void setOctreeLeafSize (double size)
+        # 
+        # /** \brief Get the sphere radius used for determining the neighbors. */
+        # inline double getOctreeLeafSize ()
+        # 
+        # /** \brief Return the empty label value. */
+        # inline uint32_t emptyLabel () const
+        # 
+        # /** \brief Return the number of different classes. */
+        # inline uint32_t getNumberOfClasses () const
+        # 
+        # /** \brief Set the number of different classes.
+        #  * \param n number of different classes.
+        #  */
+        # inline void setNumberOfClasses (uint32_t n)
+        # 
+        # /** \brief Return the size of the descriptor. */
+        # inline int descriptorSize () const
+        # 
+        # /** \brief Overloaded computed method from pcl::Feature.
+        #   * \param[out] output the resultant point cloud model dataset containing the estimated features
+        #   */
+        # void compute (PointCloudOut &output);
+
+
+###
+
+# linear_least_squares_normal.h
+# namespace pcl
+# /** \brief Surface normal estimation on dense data using a least-squares estimation based on a first-order Taylor approximation.
+# * \author Stefan Holzer, Cedric Cagniart
+# */
+# template <typename PointInT, typename PointOutT>
+# class LinearLeastSquaresNormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/linear_least_squares_normal.h" namespace "pcl":
+    cdef cppclass LinearLeastSquaresNormalEstimation[In, Out](Feature[In, Out]):
+        LinearLeastSquaresNormalEstimation()
+        # public:
+        # typedef boost::shared_ptr<LinearLeastSquaresNormalEstimation<PointInT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const LinearLeastSquaresNormalEstimation<PointInT, PointOutT> > ConstPtr;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # 
+        # /** \brief Constructor */
+        # LinearLeastSquaresNormalEstimation () :
+        #   use_depth_dependent_smoothing_(false),
+        #   max_depth_change_factor_(1.0f),
+        #   normal_smoothing_size_(9.0f)
+        # 
+        # /** \brief Destructor */
+        # virtual ~LinearLeastSquaresNormalEstimation ();
+        # 
+        # /** \brief Computes the normal at the specified position. 
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[out] normal the output estimated normal 
+        # */
+        # void computePointNormal (const int pos_x, const int pos_y, PointOutT &normal)
+        # 
+        # /** \brief Set the normal smoothing size
+        # * \param[in] normal_smoothing_size factor which influences the size of the area used to smooth normals 
+        # * (depth dependent if useDepthDependentSmoothing is true)
+        # */
+        # void setNormalSmoothingSize (float normal_smoothing_size)
+        # 
+        # /** \brief Set whether to use depth depending smoothing or not
+        #  * \param[in] use_depth_dependent_smoothing decides whether the smoothing is depth dependent
+        #  */
+        # void setDepthDependentSmoothing (bool use_depth_dependent_smoothing)
+        # 
+        # /** \brief The depth change threshold for computing object borders
+        #  * \param[in] max_depth_change_factor the depth change threshold for computing object borders based on 
+        #  * depth changes
+        #  */
+        # void setMaxDepthChangeFactor (float max_depth_change_factor)
+        # 
+        # /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # virtual inline void setInputCloud (const typename PointCloudIn::ConstPtr &cloud) 
+
+
+###
+
+# pcl 1.7 package base ng(linux)
+# (source code build ok?)
+# moment_of_inertia_estimation.h
+# namespace pcl
+# /** 
+#   * Implements the method for extracting features based on moment of inertia.
+#   * It also calculates AABB, OBB and eccentricity of the projected cloud.
+#   */
+# template <typename PointT>
+# class PCL_EXPORTS MomentOfInertiaEstimation : public pcl::PCLBase <PointT>
+# cdef extern from "pcl/features/moment_of_inertia_estimation.h" namespace "pcl":
+#     cdef cppclass MomentOfInertiaEstimation[PointT](cpp.PCLBase[PointT]):
+#         MomentOfInertiaEstimation()
+        # /** \brief Constructor that sets default values for member variables. */
+        # MomentOfInertiaEstimation ();
+        # public:
+        # typedef typename pcl::PCLBase <PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PCLBase <PointT>::PointIndicesConstPtr PointIndicesConstPtr;
+        # public:
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # void setInputCloud (const cpp.PCLBase[PointT]& cloud)
+        # 
+        # \brief Provide a pointer to the vector of indices that represents the input data.
+        # \param[in] indices a pointer to the vector of indices that represents the input data.
+        # virtual void setIndices (const IndicesPtr& indices);
+        # void setIndices (const IndicesPtr& indices)
+        # 
+        # /** \brief Provide a pointer to the vector of indices that represents the input data.
+        # * \param[in] indices a pointer to the vector of indices that represents the input data.
+        # */
+        # void setIndices (const IndicesConstPtr& indices)
+        # 
+        # /** \brief Provide a pointer to the vector of indices that represents the input data.
+        # * \param[in] indices a pointer to the vector of indices that represents the input data.
+        # */
+        # virtual void setIndices (const PointIndicesConstPtr& indices);
+        # void setIndices (const PointIndicesConstPtr& indices)
+        # 
+        # /** \brief Set the indices for the points laying within an interest region of 
+        #   * the point cloud.
+        #   * \note you shouldn't call this method on unorganized point clouds!
+        #   * \param[in] row_start the offset on rows
+        #   * \param[in] col_start the offset on columns
+        #   * \param[in] nb_rows the number of rows to be considered row_start included
+        #   * \param[in] nb_cols the number of columns to be considered col_start included
+        #   */
+        # virtual void setIndices (size_t row_start, size_t col_start, size_t nb_rows, size_t nb_cols);
+        # void setIndices (size_t row_start, size_t col_start, size_t nb_rows, size_t nb_cols)
+        # 
+        # /** \brief This method allows to set the angle step. It is used for the rotation
+        # * of the axis which is used for moment of inertia/eccentricity calculation.
+        # * \param[in] step angle step
+        # */
+        # void setAngleStep (const float step);
+        # void setAngleStep (const float step)
+        # 
+        # /** \brief Returns the angle step. */
+        # float getAngleStep () const;
+        # float getAngleStep ()
+        # 
+        # /** \brief This method allows to set the normalize_ flag. If set to false, then
+        # * point_mass_ will be used to scale the moment of inertia values. Otherwise,
+        # * point_mass_ will be set to 1 / number_of_points. Default value is true.
+        # * \param[in] need_to_normalize desired value
+        # */
+        # void setNormalizePointMassFlag (bool need_to_normalize);
+        # void setNormalizePointMassFlag (bool need_to_normalize)
+        # 
+        # /** \brief Returns the normalize_ flag. */
+        # bool getNormalizePointMassFlag () const;
+        # bool getNormalizePointMassFlag ()
+        # 
+        # /** \brief This method allows to set point mass that will be used for
+        # * moment of inertia calculation. It is needed to scale moment of inertia values.
+        # * default value is 0.0001.
+        # * \param[in] point_mass point mass
+        # */
+        # void setPointMass (const float point_mass);
+        # void setPointMass (const float point_mass)
+        # 
+        # /** \brief Returns the mass of point. */
+        # float getPointMass () const;
+        # float getPointMass ()
+        # 
+        # /** \brief This method launches the computation of all features. After execution
+        # * it sets is_valid_ flag to true and each feature can be accessed with the
+        # * corresponding get method.
+        # */
+        # void compute ();
+        # void compute ()
+        # 
+        # /** \brief This method gives access to the computed axis aligned bounding box. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] min_point min point of the AABB
+        # * \param[out] max_point max point of the AABB
+        # */
+        # bool getAABB (PointT& min_point, PointT& max_point) const;
+        # bool getAABB (PointT& min_point, PointT& max_point)
+        # 
+        # /** \brief This method gives access to the computed oriented bounding box. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * Note that in order to get the OBB, each vertex of the given AABB (specified with min_point and max_point)
+        # * must be rotated with the given rotational matrix (rotation transform) and then positioned.
+        # * Also pay attention to the fact that this is not the minimal possible bounding box. This is the bounding box
+        # * which is oriented in accordance with the eigen vectors.
+        # * \param[out] min_point min point of the OBB
+        # * \param[out] max_point max point of the OBB
+        # * \param[out] position position of the OBB
+        # * \param[out] rotational_matrix this matrix represents the rotation transform
+        # */
+        # bool getOBB (PointT& min_point, PointT& max_point, PointT& position, Eigen::Matrix3f& rotational_matrix) const;
+        # bool getOBB (PointT& min_point, PointT& max_point, PointT& position, eigen3.Matrix3f& rotational_matrix)
+        # 
+        # /** \brief This method gives access to the computed eigen values. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] major major eigen value
+        # * \param[out] middle middle eigen value
+        # * \param[out] minor minor eigen value
+        # */
+        # bool getEigenValues (float& major, float& middle, float& minor) const;
+        # bool getEigenValues (float& major, float& middle, float& minor)
+        # 
+        # /** \brief This method gives access to the computed eigen vectors. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] major axis which corresponds to the eigen vector with the major eigen value
+        # * \param[out] middle axis which corresponds to the eigen vector with the middle eigen value
+        # * \param[out] minor axis which corresponds to the eigen vector with the minor eigen value
+        # */
+        # bool getEigenVectors (Eigen::Vector3f& major, Eigen::Vector3f& middle, Eigen::Vector3f& minor) const;
+        # bool getEigenVectors (eigen3.Vector3f& major, eigen3.Vector3f& middle, eigen3.Vector3f& minor)
+        # 
+        # /** \brief This method gives access to the computed moments of inertia. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] moment_of_inertia computed moments of inertia
+        # */
+        # bool getMomentOfInertia (std::vector <float>& moment_of_inertia) const;
+        # bool getMomentOfInertia (vector [float]& moment_of_inertia)
+        # 
+        # /** \brief This method gives access to the computed ecentricities. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] eccentricity computed eccentricities
+        # */
+        # bool getEccentricity (std::vector <float>& eccentricity) const;
+        # bool getEccentricity (vector [float]& eccentricity)
+        # 
+        # /** \brief This method gives access to the computed mass center. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * Note that when mass center of a cloud is computed, mass point is always considered equal 1.
+        # * \param[out] mass_center computed mass center
+        # */
+        # bool getMassCenter (Eigen::Vector3f& mass_center) const;
+        # bool getMassCenter (eigen3.Vector3f& mass_center)
+
+
+# ctypedef MomentOfInertiaEstimation[cpp.PointXYZ] MomentOfInertiaEstimation_t
+# ctypedef MomentOfInertiaEstimation[cpp.PointXYZI] MomentOfInertiaEstimation_PointXYZI_t
+# ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGB] MomentOfInertiaEstimation_PointXYZRGB_t
+# ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGBA] MomentOfInertiaEstimation_PointXYZRGBA_t
+# ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZ]] MomentOfInertiaEstimationPtr_t
+# ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZI]] MomentOfInertiaEstimation_PointXYZI_Ptr_t
+# ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGB]] MomentOfInertiaEstimation_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGBA]] MomentOfInertiaEstimation_PointXYZRGBA_Ptr_t
+###
+
+# our_cvfh.h
+# namespace pcl
+# /** \brief OURCVFHEstimation estimates the Oriented, Unique and Repetable Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given
+#  * point cloud dataset given XYZ data and normals, as presented in:
+#  *     - OUR-CVFH Oriented, Unique and Repeatable Clustered Viewpoint Feature Histogram for Object Recognition and 6DOF Pose Estimation
+#  *     A. Aldoma, F. Tombari, R.B. Rusu and M. Vincze
+#  *     DAGM-OAGM 2012
+#  *     Graz, Austria
+#  * The suggested PointOutT is pcl::VFHSignature308.
+#  * \author Aitor Aldoma
+#  * \ingroup features
+#  */
+# template<typename PointInT, typename PointNT, typename PointOutT = pcl::VFHSignature308>
+# class OURCVFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/our_cvfh.h" namespace "pcl":
+    cdef cppclass OURCVFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        OURCVFHEstimation()
+        # public:
+        # typedef boost::shared_ptr<OURCVFHEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const OURCVFHEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # 
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::search::Search<PointNormal>::Ptr KdTreePtr;
+        # typedef typename pcl::PointCloud<PointInT>::Ptr PointInTPtr;
+        # /** \brief Empty constructor. */
+        # OURCVFHEstimation () :
+        # vpx_ (0), vpy_ (0), vpz_ (0), leaf_size_ (0.005f), normalize_bins_ (false), curv_threshold_ (0.03f), cluster_tolerance_ (leaf_size_ * 3),
+        #     eps_angle_threshold_ (0.125f), min_points_ (50), radius_normals_ (leaf_size_ * 3), centroids_dominant_orientations_ (),
+        #     dominant_normals_ ()
+        # 
+        # /** \brief Creates an affine transformation from the RF axes
+        # * \param[in] evx the x-axis
+        # * \param[in] evy the y-axis
+        # * \param[in] evz the z-axis
+        # * \param[out] transformPC the resulting transformation
+        # * \param[in] center_mat 4x4 matrix concatenated to the resulting transformation
+        # */
+        # inline Eigen::Matrix4f createTransFromAxes (Eigen::Vector3f & evx, Eigen::Vector3f & evy, Eigen::Vector3f & evz, Eigen::Affine3f & transformPC, Eigen::Matrix4f & center_mat)
+        # 
+        # /** \brief Computes SGURF and the shape distribution based on the selected SGURF
+        # * \param[in] processed the input cloud
+        # * \param[out] output the resulting signature
+        # * \param[in] cluster_indices the indices of the stable cluster
+        # */
+        # void computeRFAndShapeDistribution (PointInTPtr & processed, PointCloudOut &output, std::vector<pcl::PointIndices> & cluster_indices);
+        # 
+        # /** \brief Computes SGURF
+        # * \param[in] centroid the centroid of the cluster
+        # * \param[in] normal_centroid the average of the normals
+        # * \param[in] processed the input cloud
+        # * \param[out] transformations the transformations aligning the cloud to the SGURF axes
+        # * \param[out] grid the cloud transformed internally
+        # * \param[in] indices the indices of the stable cluster
+        # */
+        # bool sgurf (Eigen::Vector3f & centroid, Eigen::Vector3f & normal_centroid, PointInTPtr & processed, std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > & transformations, PointInTPtr & grid, pcl::PointIndices & indices);
+        # 
+        # /** \brief Removes normals with high curvature caused by real edges or noisy data
+        # * \param[in] cloud pointcloud to be filtered
+        # * \param[in] indices_to_use
+        # * \param[out] indices_out the indices of the points with higher curvature than threshold
+        # * \param[out] indices_in the indices of the remaining points after filtering
+        # * \param[in] threshold threshold value for curvature
+        # */
+        # void filterNormalsWithHighCurvature (const pcl::PointCloud<PointNT> & cloud, std::vector<int> & indices_to_use, std::vector<int> &indices_out, std::vector<int> &indices_in, float threshold);
+        # 
+        # /** \brief Set the viewpoint.
+        # * \param[in] vpx the X coordinate of the viewpoint
+        # * \param[in] vpy the Y coordinate of the viewpoint
+        # * \param[in] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # /** \brief Set the radius used to compute normals
+        # * \param[in] radius_normals the radius
+        # */
+        # inline void setRadiusNormals (float radius_normals)
+        # 
+        # /** \brief Get the viewpoint. 
+        # * \param[out] vpx the X coordinate of the viewpoint
+        # * \param[out] vpy the Y coordinate of the viewpoint
+        # * \param[out] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        # 
+        # /** \brief Get the centroids used to compute different CVFH descriptors
+        # * \param[out] centroids vector to hold the centroids
+        # */
+        # inline void getCentroidClusters (std::vector<Eigen::Vector3f> & centroids)
+        # 
+        # /** \brief Get the normal centroids used to compute different CVFH descriptors
+        # * \param[out] centroids vector to hold the normal centroids
+        # */
+        # inline void getCentroidNormalClusters (std::vector<Eigen::Vector3f> & centroids)
+        # 
+        # /** \brief Sets max. Euclidean distance between points to be added to the cluster 
+        # * \param[in] d the maximum Euclidean distance
+        # */
+        # inline void setClusterTolerance (float d)
+        # 
+        # /** \brief Sets max. deviation of the normals between two points so they can be clustered together
+        # * \param[in] d the maximum deviation
+        # */
+        # inline void setEPSAngleThreshold (float d)
+        # 
+        # /** \brief Sets curvature threshold for removing normals
+        # * \param[in] d the curvature threshold
+        # */
+        # inline void setCurvatureThreshold (float d)
+        # 
+        # /** \brief Set minimum amount of points for a cluster to be considered
+        # * \param[in] min the minimum amount of points to be set
+        # */
+        # inline void setMinPoints (size_t min)
+        # 
+        # /** \brief Sets wether if the signatures should be normalized or not
+        # * \param[in] normalize true if normalization is required, false otherwise
+        # */
+        # inline void setNormalizeBins (bool normalize)
+        # 
+        # /** \brief Gets the indices of the original point cloud used to compute the signatures
+        # * \param[out] indices vector of point indices
+        # */
+        # inline void getClusterIndices (std::vector<pcl::PointIndices> & indices)
+        # 
+        # /** \brief Gets the number of non-disambiguable axes that correspond to each centroid
+        # * \param[out] cluster_axes vector mapping each centroid to the number of signatures
+        # */
+        # inline void getClusterAxes (std::vector<short> & cluster_axes)
+        # 
+        # /** \brief Sets the refinement factor for the clusters
+        # * \param[in] rc the factor used to decide if a point is used to estimate a stable cluster
+        # */
+        # void setRefineClusters (float rc)
+        # 
+        # /** \brief Returns the transformations aligning the point cloud to the corresponding SGURF
+        # * \param[out] trans vector of transformations
+        # */
+        # void getTransforms (std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > & trans)
+        # 
+        # /** \brief Returns a boolean vector indicating of the transformation obtained by getTransforms() represents
+        # * a valid SGURF
+        # * \param[out] valid vector of booleans
+        # */
+        # void getValidTransformsVec (std::vector<bool> & valid)
+        # 
+        # /** \brief Sets the min axis ratio between the SGURF axes to decide if disambiguition is feasible
+        # * \param[in] f the ratio between axes
+        # */
+        # void setAxisRatio (float f)
+        # 
+        # /** \brief Sets the min disambiguition axis value to generate several SGURFs for the cluster when disambiguition is difficult
+        # * \param[in] f the min axis value
+        # */
+        # void setMinAxisValue (float f)
+        # 
+        # /** \brief Overloaded computed method from pcl::Feature.
+        # * \param[out] output the resultant point cloud model dataset containing the estimated features
+        # */
+        # void compute (PointCloudOut &output);
+
+
+####
+
+# pfh_tools.h
+# namespace pcl
+#   /** \brief Compute the 4-tuple representation containing the three angles and one distance between two points
+#     * represented by Cartesian coordinates and normals.
+#     * \note For explanations about the features, please see the literature mentioned above (the order of the
+#     * features might be different).
+#     * \param[in] p1 the first XYZ point
+#     * \param[in] n1 the first surface normal
+#     * \param[in] p2 the second XYZ point
+#     * \param[in] n2 the second surface normal
+#     * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+#     * \param[out] f2 the second angular feature (angle between nq_idx and v)
+#     * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+#     * \param[out] f4 the distance feature (p_idx - q_idx)
+#     *
+#     * \note For efficiency reasons, we assume that the point data passed to the method is finite.
+#     * \ingroup features
+#     */
+#   PCL_EXPORTS bool 
+#   computePairFeatures (const Eigen::Vector4f &p1, const Eigen::Vector4f &n1, 
+#                        const Eigen::Vector4f &p2, const Eigen::Vector4f &n2, 
+#                        float &f1, float &f2, float &f3, float &f4);
+# 
+#   PCL_EXPORTS bool
+#   computeRGBPairFeatures (const Eigen::Vector4f &p1, const Eigen::Vector4f &n1, const Eigen::Vector4i &colors1,
+#                           const Eigen::Vector4f &p2, const Eigen::Vector4f &n2, const Eigen::Vector4i &colors2,
+#                           float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7);
+# 
+###
+
+# apt-get package ng(1.7 base?)
+# rops_estimation.h
+# namespace pcl
+# /** \brief
+# * This class implements the method for extracting RoPS features presented in the article
+# * "Rotational Projection Statistics for 3D Local Surface Description and Object Recognition" by
+# * Yulan Guo, Ferdous Sohel, Mohammed Bennamoun, Min Lu and Jianwei Wan.
+# */
+# template <typename PointInT, typename PointOutT>
+# class PCL_EXPORTS ROPSEstimation : public pcl::Feature <PointInT, PointOutT>
+# cdef extern from "pcl/features/rops_estimation.h" namespace "pcl":
+#     cdef cppclass ROPSEstimation[In, Out](Feature[In, Out]):
+#         ROPSEstimation()
+        # public:
+        # using Feature <PointInT, PointOutT>::input_;
+        # using Feature <PointInT, PointOutT>::indices_;
+        # using Feature <PointInT, PointOutT>::surface_;
+        # using Feature <PointInT, PointOutT>::tree_;
+        # typedef typename pcl::Feature <PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::Feature <PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # public:
+        # /** \brief Simple constructor. */
+        # ROPSEstimation ();
+        # 
+        # /** \brief Virtual destructor. */
+        # virtual ~ROPSEstimation ();
+        # 
+        # /** \brief Allows to set the number of partition bins that is used for distribution matrix calculation.
+        # * \param[in] number_of_bins number of partition bins
+        # */
+        # void setNumberOfPartitionBins (unsigned int number_of_bins);
+        # 
+        # /** \brief Returns the nmber of partition bins. */
+        # unsigned int getNumberOfPartitionBins () const;
+        # 
+        # /** \brief This method sets the number of rotations.
+        # * \param[in] number_of_rotations number of rotations
+        # */
+        # void setNumberOfRotations (unsigned int number_of_rotations);
+        # 
+        # /** \brief returns the number of rotations. */
+        # unsigned int getNumberOfRotations () const;
+        # 
+        # /** \brief Allows to set the support radius that is used to crop the local surface of the point.
+        # * \param[in] support_radius support radius
+        # */
+        # void setSupportRadius (float support_radius);
+        # 
+        # /** \brief Returns the support radius. */
+        # float getSupportRadius () const;
+        # 
+        # /** \brief This method sets the triangles of the mesh.
+        # * \param[in] triangles list of triangles of the mesh
+        # */
+        # void setTriangles (const std::vector <pcl::Vertices>& triangles);
+        # 
+        # /** \brief Returns the triangles of the mesh.
+        # * \param[out] triangles triangles of tthe mesh
+        # */
+        # void getTriangles (std::vector <pcl::Vertices>& triangles) const;
+
+
+###
+
+# rsd.h
+# namespace pcl
+#   /** \brief Transform a list of 2D matrices into a point cloud containing the values in a vector (Histogram<N>).
+#     * Can be used to transform the 2D histograms obtained in \ref RSDEstimation into a point cloud.
+#     * @note The template paramter N should be (greater or) equal to the product of the number of rows and columns.
+#     * \param[in] histograms2D the list of neighborhood 2D histograms
+#     * \param[out] histogramsPC the dataset containing the linearized matrices
+#     * \ingroup features
+#     */
+#   template <int N> void getFeaturePointCloud (const std::vector<Eigen::MatrixXf, Eigen::aligned_allocator<Eigen::MatrixXf> > &histograms2D, PointCloud<Histogram<N> > &histogramsPC)
+# 
+#   /** \brief Estimate the Radius-based Surface Descriptor (RSD) for a given point based on its spatial neighborhood of 3D points with normals
+#     * \param[in] surface the dataset containing the XYZ points
+#     * \param[in] normals the dataset containing the surface normals at each point in the dataset
+#     * \param[in] indices the neighborhood point indices in the dataset (first point is used as the reference)
+#     * \param[in] max_dist the upper bound for the considered distance interval
+#     * \param[in] nr_subdiv the number of subdivisions for the considered distance interval
+#     * \param[in] plane_radius maximum radius, above which everything can be considered planar
+#     * \param[in] radii the output point of a type that should have r_min and r_max fields
+#     * \param[in] compute_histogram if not false, the full neighborhood histogram is provided, usable as a point signature
+#     * \ingroup features
+#     */
+#   template <typename PointInT, typename PointNT, typename PointOutT> Eigen::MatrixXf
+#   computeRSD (boost::shared_ptr<const pcl::PointCloud<PointInT> > &surface, boost::shared_ptr<const pcl::PointCloud<PointNT> > &normals,
+#              const std::vector<int> &indices, double max_dist,
+#              int nr_subdiv, double plane_radius, PointOutT &radii, bool compute_histogram = false);
+# 
+#   /** \brief Estimate the Radius-based Surface Descriptor (RSD) for a given point based on its spatial neighborhood of 3D points with normals
+#     * \param[in] normals the dataset containing the surface normals at each point in the dataset
+#     * \param[in] indices the neighborhood point indices in the dataset (first point is used as the reference)
+#     * \param[in] sqr_dists the squared distances from the first to all points in the neighborhood
+#     * \param[in] max_dist the upper bound for the considered distance interval
+#     * \param[in] nr_subdiv the number of subdivisions for the considered distance interval
+#     * \param[in] plane_radius maximum radius, above which everything can be considered planar
+#     * \param[in] radii the output point of a type that should have r_min and r_max fields
+#     * \param[in] compute_histogram if not false, the full neighborhood histogram is provided, usable as a point signature
+#     * \ingroup features
+#     */
+#   template <typename PointNT, typename PointOutT> Eigen::MatrixXf
+#   computeRSD (boost::shared_ptr<const pcl::PointCloud<PointNT> > &normals,
+#              const std::vector<int> &indices, const std::vector<float> &sqr_dists, double max_dist,
+#              int nr_subdiv, double plane_radius, PointOutT &radii, bool compute_histogram = false);
+# 
+##
+# rsd.h
+# namespace pcl
+# /** \brief @b RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves)
+# * for a given point cloud dataset containing points and normals.
+# *
+# * @note If you use this code in any academic work, please cite:
+# *
+# * <ul>
+# * <li> Z.C. Marton , D. Pangercic , N. Blodow , J. Kleinehellefort, M. Beetz
+# *      General 3D Modelling of Novel Objects from a Single View
+# *      In Proceedings of the 2010 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)
+# *      Taipei, Taiwan, October 18-22, 2010
+# * </li>
+# * <li> Z.C. Marton, D. Pangercic, N. Blodow, Michael Beetz.
+# *      Combined 2D-3D Categorization and Classification for Multimodal Perception Systems.
+# *      In The International Journal of Robotics Research, Sage Publications
+# *      pages 1378--1402, Volume 30, Number 11, September 2011.
+# * </li>
+# * </ul>
+# *
+# * @note The code is stateful as we do not expect this class to be multicore parallelized.
+# * \author Zoltan-Csaba Marton
+# * \ingroup features
+# */
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class RSDEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+# Note : Travis CI error (not found rsd.h)
+# cdef extern from "pcl/features/rsd.h" namespace "pcl":
+#     cdef cppclass RSDEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+#         RSDEstimation()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # typedef typename boost::shared_ptr<RSDEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const RSDEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # RSDEstimation () : nr_subdiv_ (5), plane_radius_ (0.2), save_histograms_ (false)
+        # 
+        # /** \brief Set the number of subdivisions for the considered distance interval.
+        #  * \param[in] nr_subdiv the number of subdivisions
+        #  */
+        # inline void setNrSubdivisions (int nr_subdiv)
+        # 
+        # /** \brief Get the number of subdivisions for the considered distance interval. */
+        # inline int getNrSubdivisions () const
+        # 
+        # /** \brief Set the maximum radius, above which everything can be considered planar.
+        # * \note the order of magnitude should be around 10-20 times the search radius (0.2 works well for typical datasets).
+        # * \note on accurate 3D data (e.g. openni sernsors) a search radius as low as 0.01 still gives good results.
+        # * \param[in] plane_radius the new plane radius
+        # */
+        # inline void setPlaneRadius (double plane_radius)
+        # 
+        # /** \brief Get the maximum radius, above which everything can be considered planar. */
+        # inline double getPlaneRadius () const
+        # 
+        # /** \brief Disables the setting of the number of k nearest neighbors to use for the feature estimation. */
+        # inline void setKSearch (int) 
+        # 
+        # /** \brief Set whether the full distance-angle histograms should be saved.
+        # * @note Obtain the list of histograms by getHistograms ()
+        # * \param[in] save set to true if histograms should be saved
+        # */
+        # inline void setSaveHistograms (bool save)
+        # 
+        # /** \brief Returns whether the full distance-angle histograms are being saved. */
+        # inline bool getSaveHistograms () const
+        # 
+        # /** \brief Returns a pointer to the list of full distance-angle histograms for all points. */
+        # inline boost::shared_ptr<std::vector<Eigen::MatrixXf, Eigen::aligned_allocator<Eigen::MatrixXf> > > getHistograms () const { return (histograms_); }
+
+
+###
+
+# 3dsc.h
+# class ShapeContext3DEstimation<PointInT, PointNT, Eigen::MatrixXf> : public ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>
+# cdef extern from "pcl/features/3dsc.h" namespace "pcl":
+#     cdef cppclass ShapeContext3DEstimation[T, N, M]:
+#         ShapeContext3DEstimation(bool)
+#         # public:
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::feature_name_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::indices_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::descriptor_length_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::normals_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::input_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::compute;
+###
+
+# class BoundaryEstimation: public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/boundary.h" namespace "pcl":
+    cdef cppclass BoundaryEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        BoundaryEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        ##
+        # brief Check whether a point is a boundary point in a planar patch of projected points given by indices.
+        # note A coordinate system u-v-n must be computed a-priori using \a getCoordinateSystemOnPlane
+        # param[in] cloud a pointer to the input point cloud
+        # param[in] q_idx the index of the query point in \a cloud
+        # param[in] indices the estimated point neighbors of the query point
+        # param[in] u the u direction
+        # param[in] v the v direction
+        # param[in] angle_threshold the threshold angle (default \f$\pi / 2.0\f$)
+        # bool isBoundaryPoint (const cpp.PointCloud[In] &cloud, 
+        #                int q_idx, const vector[int] &indices, 
+        #                const Eigen::Vector4f &u, const Eigen::Vector4f &v, const float angle_threshold);
+        # brief Check whether a point is a boundary point in a planar patch of projected points given by indices.
+        # note A coordinate system u-v-n must be computed a-priori using \a getCoordinateSystemOnPlane
+        # param[in] cloud a pointer to the input point cloud
+        # param[in] q_point a pointer to the querry point
+        # param[in] indices the estimated point neighbors of the query point
+        # param[in] u the u direction
+        # param[in] v the v direction
+        # param[in] angle_threshold the threshold angle (default \f$\pi / 2.0\f$)
+        # bool isBoundaryPoint (const cpp.PointCloud[In] &cloud, 
+        #                const [In] &q_point, 
+        #                const vector[int] &indices, 
+        #                const Eigen::Vector4f &u, const Eigen::Vector4f &v, const float angle_threshold);
+        # brief Set the decision boundary (angle threshold) that marks points as boundary or regular. 
+        # (default \f$\pi / 2.0\f$) 
+        # param[in] angle the angle threshold
+        inline void setAngleThreshold (float angle)
+        inline float getAngleThreshold ()
+        # brief Get a u-v-n coordinate system that lies on a plane defined by its normal
+        # param[in] p_coeff the plane coefficients (containing the plane normal)
+        # param[out] u the resultant u direction
+        # param[out] v the resultant v direction
+        # inline void getCoordinateSystemOnPlane (const PointNT &p_coeff, 
+        #                           Eigen::Vector4f &u, Eigen::Vector4f &v)
+
+###
+
+# class CVFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+# cdef extern from "pcl/features/cvfh.h" namespace "pcl":
+#     cdef cppclass CVFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+#         CVFHEstimation()
+#         # public:
+#         # using Feature<PointInT, PointOutT>::feature_name_;
+#         # using Feature<PointInT, PointOutT>::getClassName;
+#         # using Feature<PointInT, PointOutT>::indices_;
+#         # using Feature<PointInT, PointOutT>::k_;
+#         # using Feature<PointInT, PointOutT>::search_radius_;
+#         # using Feature<PointInT, PointOutT>::surface_;
+#         # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#         # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#         # ctypedef typename pcl::search::Search<PointNormal>::Ptr KdTreePtr;
+#         # ctypedef typename pcl::NormalEstimation<PointNormal, PointNormal> NormalEstimator;
+#         # ctypedef typename pcl::VFHEstimation<PointInT, PointNT, pcl::VFHSignature308> VFHEstimator;
+#         ##
+#         # brief Removes normals with high curvature caused by real edges or noisy data
+#         # param[in] cloud pointcloud to be filtered
+#         # param[out] indices_out the indices of the points with higher curvature than threshold
+#         # param[out] indices_in the indices of the remaining points after filtering
+#         # param[in] threshold threshold value for curvature
+#         void filterNormalsWithHighCurvature (
+#                                               const cpp.PointCloud[NT] & cloud, 
+#                                               vector[int] &indices, vector[int] &indices2,
+#                                               vector[int] &, float);
+#         # brief Set the viewpoint.
+#         # param[in] vpx the X coordinate of the viewpoint
+#         # param[in] vpy the Y coordinate of the viewpoint
+#         # param[in] vpz the Z coordinate of the viewpoint
+#         inline void setViewPoint (float x, float y, float z)
+#         # brief Set the radius used to compute normals
+#         # param[in] radius_normals the radius
+#         inline void setRadiusNormals (float radius)
+#         # brief Get the viewpoint. 
+#         # param[out] vpx the X coordinate of the viewpoint
+#         # param[out] vpy the Y coordinate of the viewpoint
+#         # param[out] vpz the Z coordinate of the viewpoint
+#         inline void getViewPoint (float &x, float &y, float &z)
+#         # brief Get the centroids used to compute different CVFH descriptors
+#         # param[out] centroids vector to hold the centroids
+#         # inline void getCentroidClusters (vector[Eigen::Vector3f] &)
+#         # brief Get the normal centroids used to compute different CVFH descriptors
+#         # param[out] centroids vector to hold the normal centroids
+#         # inline void getCentroidNormalClusters (vector[Eigen::Vector3f] &)
+#         # brief Sets max. Euclidean distance between points to be added to the cluster 
+#         # param[in] d the maximum Euclidean distance 
+#         inline void setClusterTolerance (float tolerance)
+#         # brief Sets max. deviation of the normals between two points so they can be clustered together
+#         # param[in] d the maximum deviation 
+#         inline void setEPSAngleThreshold (float angle)
+#         # brief Sets curvature threshold for removing normals
+#         # param[in] d the curvature threshold 
+#         inline void setCurvatureThreshold (float curve)
+#         # brief Set minimum amount of points for a cluster to be considered
+#         # param[in] min the minimum amount of points to be set 
+#         inline void setMinPoints (size_t points)
+#         # brief Sets wether if the CVFH signatures should be normalized or not
+#         # param[in] normalize true if normalization is required, false otherwise 
+#         inline void setNormalizeBins (bool bins)
+#         # brief Overloaded computed method from pcl::Feature.
+#         # param[out] output the resultant point cloud model dataset containing the estimated features
+#         # void compute (PointCloudOut &);
+
+
+###
+
+# esf.h
+# class ESFEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/esf.h" namespace "pcl":
+    cdef cppclass ESFEstimation[In, Out](Feature[In, Out]):
+        ESFEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # ctypedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # void compute (cpp.PointCloud[Out] &output)
+###
+
+# template <typename PointInT, typename PointRFT>
+# class FeatureWithLocalReferenceFrames
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureWithLocalReferenceFrames[T, REF]:
+        FeatureWithLocalReferenceFrames ()
+        # public:
+        # ctypedef cpp.PointCloud[RFT] PointCloudLRF;
+        # ctypedef typename PointCloudLRF::Ptr PointCloudLRFPtr;
+        # ctypedef typename PointCloudLRF::ConstPtr PointCloudLRFConstPtr;
+        # inline void setInputReferenceFrames (const PointCloudLRFConstPtr &frames)
+        # inline PointCloudLRFConstPtr getInputReferenceFrames () const
+        # protected:
+        # /** \brief A boost shared pointer to the local reference frames. */
+        # PointCloudLRFConstPtr frames_;
+        # /** \brief The user has never set the frames. */
+        # bool frames_never_defined_;
+        # /** \brief Check if frames_ has been correctly initialized and compute it if needed.
+        # * \param input the subclass' input cloud dataset.
+        # * \param lrf_estimation a pointer to a local reference frame estimation class to be used as default.
+        # * \return true if frames_ has been correctly initialized.
+        # */
+        # typedef typename Feature<PointInT, PointRFT>::Ptr LRFEstimationPtr;
+        # virtual bool
+        # initLocalReferenceFrames (const size_t& indices_size,
+        #                           const LRFEstimationPtr& lrf_estimation = LRFEstimationPtr());
+###
+
+# fpfh
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::FPFHSignature33>
+# class FPFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/fpfh.h" namespace "pcl":
+    cdef cppclass FPFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        FPFHEstimation()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * represented by Cartesian coordinates and normals.
+        # * \note For explanations about the features, please see the literature mentioned above (the order of the
+        # * features might be different).
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals (assuming normalized vectors) at each point in cloud
+        # * \param[in] p_idx the index of the first point (source)
+        # * \param[in] q_idx the index of the second point (target)
+        # * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+        # * \param[out] f2 the second angular feature (angle between nq_idx and v)
+        # * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+        # * \param[out] f4 the distance feature (p_idx - q_idx)
+        # bool 
+        # computePairFeatures (const pcl::PointCloud<PointInT> &cloud, const pcl::PointCloud<PointNT> &normals, 
+        #                    int p_idx, int q_idx, float &f1, float &f2, float &f3, float &f4);
+        # * \brief Estimate the SPFH (Simple Point Feature Histograms) individual signatures of the three angular
+        # * (f1, f2, f3) features for a given point based on its spatial neighborhood of 3D points with normals
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        # * \param[in] p_idx the index of the query point (source)
+        # * \param[in] row the index row in feature histogramms
+        # * \param[in] indices the k-neighborhood point indices in the dataset
+        # * \param[out] hist_f1 the resultant SPFH histogram for feature f1
+        # * \param[out] hist_f2 the resultant SPFH histogram for feature f2
+        # * \param[out] hist_f3 the resultant SPFH histogram for feature f3
+        # void 
+        # computePointSPFHSignature (const pcl::PointCloud<PointInT> &cloud, 
+        #                          const pcl::PointCloud<PointNT> &normals, int p_idx, int row, 
+        #                          const std::vector<int> &indices, 
+        #                          Eigen::MatrixXf &hist_f1, Eigen::MatrixXf &hist_f2, Eigen::MatrixXf &hist_f3);
+        # * \brief Weight the SPFH (Simple Point Feature Histograms) individual histograms to create the final FPFH
+        # * (Fast Point Feature Histogram) for a given point based on its 3D spatial neighborhood
+        # * \param[in] hist_f1 the histogram feature vector of \a f1 values over the given patch
+        # * \param[in] hist_f2 the histogram feature vector of \a f2 values over the given patch
+        # * \param[in] hist_f3 the histogram feature vector of \a f3 values over the given patch
+        # * \param[in] indices the point indices of p_idx's k-neighborhood in the point cloud
+        # * \param[in] dists the distances from p_idx to all its k-neighbors
+        # * \param[out] fpfh_histogram the resultant FPFH histogram representing the feature at the query point
+        # void 
+        # weightPointSPFHSignature (const Eigen::MatrixXf &hist_f1, 
+        #                         const Eigen::MatrixXf &hist_f2, 
+        #                         const Eigen::MatrixXf &hist_f3, 
+        #                         const std::vector<int> &indices, 
+        #                         const std::vector<float> &dists, 
+        #                         Eigen::VectorXf &fpfh_histogram);
+        # * \brief Set the number of subdivisions for each angular feature interval.
+        # * \param[in] nr_bins_f1 number of subdivisions for the first angular feature
+        # * \param[in] nr_bins_f2 number of subdivisions for the second angular feature
+        # * \param[in] nr_bins_f3 number of subdivisions for the third angular feature
+        inline void setNrSubdivisions (int , int , int )
+         # * \brief Get the number of subdivisions for each angular feature interval. 
+        # * \param[out] nr_bins_f1 number of subdivisions for the first angular feature
+        # * \param[out] nr_bins_f2 number of subdivisions for the second angular feature
+        # * \param[out] nr_bins_f3 number of subdivisions for the third angular feature
+        inline void getNrSubdivisions (int &, int &, int &)
+###
+
+# template <typename PointInT, typename PointNT>
+# class FPFHEstimation<PointInT, PointNT, Eigen::MatrixXf> : public FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>
+# cdef extern from "pcl/features/feature.h" namespace "pcl":
+#     cdef cppclass FPFHEstimation[T, NT]:
+#         FPFHEstimation()
+#         # public:
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::k_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::nr_bins_f1_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::nr_bins_f2_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::nr_bins_f3_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::hist_f1_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::hist_f2_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::hist_f3_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::indices_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::search_parameter_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::input_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::compute;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::fpfh_histogram_;
+
+###
+
+# fpfh_omp
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class FPFHEstimationOMP : public FPFHEstimation<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/fpfh_omp.h" namespace "pcl":
+    cdef cppclass FPFHEstimationOMP[In, NT, Out](FPFHEstimation[In, NT, Out]):
+        FPFHEstimationOMP ()
+        # FPFHEstimationOMP (unsigned int )
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f1_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f2_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f3_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::weightPointSPFHSignature;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * \brief Initialize the scheduler and set the number of threads to use.
+        # * \param[in] nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        inline void setNumberOfThreads (unsigned threads)
+        # public:
+        # * \brief The number of subdivisions for each angular feature interval. */
+        # int nr_bins_f1_, nr_bins_f2_, nr_bins_f3_;
+
+###
+
+# integral_image_normal.h
+# template <typename PointInT, typename PointOutT>
+# class IntegralImageNormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+    cdef cppclass IntegralImageNormalEstimation[In, Out](Feature[In, Out]):
+        IntegralImageNormalEstimation ()
+        # public:
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # 
+        # * \brief Set the regions size which is considered for normal estimation.
+        # * \param[in] width the width of the search rectangle
+        # * \param[in] height the height of the search rectangle
+        void setRectSize (const int width, const int height)
+        
+        # * \brief Sets the policy for handling borders.
+        # * \param[in] border_policy the border policy.
+        # minipcl
+        # void setBorderPolicy (BorderPolicy border_policy)
+        # * \brief Computes the normal at the specified position.
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[in] point_index the position index of the point
+        # * \param[out] normal the output estimated normal
+        void computePointNormal (const int pos_x, const int pos_y, const unsigned point_index, Out &normal)
+        
+        # * \brief Computes the normal at the specified position with mirroring for border handling.
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[in] point_index the position index of the point
+        # * \param[out] normal the output estimated normal
+        void computePointNormalMirror (const int pos_x, const int pos_y, const unsigned point_index, Out &normal)
+        
+        # * \brief The depth change threshold for computing object borders
+        # * \param[in] max_depth_change_factor the depth change threshold for computing object borders based on
+        # * depth changes
+        void setMaxDepthChangeFactor (float max_depth_change_factor)
+        
+        # * \brief Set the normal smoothing size
+        # * \param[in] normal_smoothing_size factor which influences the size of the area used to smooth normals
+        # * (depth dependent if useDepthDependentSmoothing is true)
+        void setNormalSmoothingSize (float normal_smoothing_size)
+        
+        # TODO : use minipcl.cpp/h
+        # * \brief Set the normal estimation method. The current implemented algorithms are:
+        # * <ul>
+        # *   <li><b>COVARIANCE_MATRIX</b> - creates 9 integral images to compute the normal for a specific point
+        # *   from the covariance matrix of its local neighborhood.</li>
+        # *   <li><b>AVERAGE_3D_GRADIENT</b> - creates 6 integral images to compute smoothed versions of
+        # *   horizontal and vertical 3D gradients and computes the normals using the cross-product between these
+        # *   two gradients.
+        # *   <li><b>AVERAGE_DEPTH_CHANGE</b> -  creates only a single integral image and computes the normals
+        # *   from the average depth changes.
+        # * </ul>
+        # * \param[in] normal_estimation_method the method used for normal estimation
+        # void setNormalEstimationMethod (NormalEstimationMethod2 normal_estimation_method)
+       
+        # brief Set whether to use depth depending smoothing or not
+        # param[in] use_depth_dependent_smoothing decides whether the smoothing is depth dependent
+        void setDepthDependentSmoothing (bool use_depth_dependent_smoothing)
+        
+        # brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        # \param[in] cloud the const boost shared pointer to a PointCloud message
+        # void setInputCloud (const typename PointCloudIn::ConstPtr &cloud)
+        void setInputCloud (In cloud)
+        
+        # brief Returns a pointer to the distance map which was computed internally
+        inline float* getDistanceMap ()
+        
+        # * \brief Set the viewpoint.
+        # * \param vpx the X coordinate of the viewpoint
+        # * \param vpy the Y coordinate of the viewpoint
+        # * \param vpz the Z coordinate of the viewpoint
+        inline void setViewPoint (float vpx, float vpy, float vpz)
+        
+        # * \brief Get the viewpoint.
+        # * \param [out] vpx x-coordinate of the view point
+        # * \param [out] vpy y-coordinate of the view point
+        # * \param [out] vpz z-coordinate of the view point
+        # * \note this method returns the currently used viewpoint for normal flipping.
+        # * If the viewpoint is set manually using the setViewPoint method, this method will return the set view point coordinates.
+        # * If an input cloud is set, it will return the sensor origin otherwise it will return the origin (0, 0, 0)
+        inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        
+        # * \brief sets whether the sensor origin or a user given viewpoint should be used. After this method, the 
+        # * normal estimation method uses the sensor origin of the input cloud.
+        # * to use a user defined view point, use the method setViewPoint
+        inline void useSensorOriginAsViewPoint ()
+
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal]) IntegralImageNormalEstimation_PointXYZI_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal](Feature[cpp.PointXYZRGB, cpp.Normal]) IntegralImageNormalEstimation_PointXYZRGB_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal](Feature[cpp.PointXYZRGBA, cpp.Normal]) IntegralImageNormalEstimation_PointXYZRGBA_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal])] IntegralImageNormalEstimationPtr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal])] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal](Feature[cpp.PointXYZRGB, cpp.Normal])] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal](Feature[cpp.PointXYZRGBA, cpp.Normal])] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+###
+
+# integral_image2D.h
+# template <class DataType, unsigned Dimension>
+# class IntegralImage2D
+cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+    cdef cppclass IntegralImage2D[Type, Dim]:
+        # IntegralImage2D ()
+        IntegralImage2D (bool flag)
+        # public:
+        # static const unsigned second_order_size = (Dimension * (Dimension + 1)) >> 1;
+        # ctypedef Eigen::Matrix<typename IntegralImageTypeTraits<DataType>::IntegralType, Dimension, 1> ElementType;
+        # ctypedef Eigen::Matrix<typename IntegralImageTypeTraits<DataType>::IntegralType, second_order_size, 1> SecondOrderType;
+        # void setSecondOrderComputation (bool compute_second_order_integral_images);
+        # * \brief Set the input data to compute the integral image for
+        #   * \param[in] data the input data
+        #   * \param[in] width the width of the data
+        #   * \param[in] height the height of the data
+        #   * \param[in] element_stride the element stride of the data
+        #   * \param[in] row_stride the row stride of the data
+        # void setInput (const DataType * data, unsigned width, unsigned height, unsigned element_stride, unsigned row_stride)
+        # * \brief Compute the first order sum within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        # inline ElementType getFirstOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the first order sum within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        # inline ElementType getFirstOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+        # /** \brief Compute the second order sum within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        # inline SecondOrderType getSecondOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the second order sum within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        # inline SecondOrderType getSecondOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+        # /** \brief Compute the number of finite elements within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        inline unsigned getFiniteElementsCount (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the number of finite elements within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        inline unsigned getFiniteElementsCountSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+###
+
+# template <class DataType>
+# class IntegralImage2D <DataType, 1>
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+#     cdef cppclass IntegralImage2D[Type]:
+#         # IntegralImage2D ()
+#         IntegralImage2D (bool flag)
+#         # public:
+#         # static const unsigned second_order_size = 1;
+#         # ctypedef typename IntegralImageTypeTraits<DataType>::IntegralType ElementType;
+#         # ctypedef typename IntegralImageTypeTraits<DataType>::IntegralType SecondOrderType;
+#         # /** \brief Set the input data to compute the integral image for
+#         #   * \param[in] data the input data
+#         #   * \param[in] width the width of the data
+#         #   * \param[in] height the height of the data
+#         #   * \param[in] element_stride the element stride of the data
+#         #   * \param[in] row_stride the row stride of the data
+#         #   */
+#         # void setInput (const DataType * data, unsigned width, unsigned height, unsigned element_stride, unsigned row_stride);
+#         # /** \brief Compute the first order sum within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         # inline ElementType getFirstOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the first order sum within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         #   */
+#         # inline ElementType getFirstOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+#         # /** \brief Compute the second order sum within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         # inline SecondOrderType getSecondOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the second order sum within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         # inline SecondOrderType getSecondOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+#         # /** \brief Compute the number of finite elements within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         inline unsigned getFiniteElementsCount (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the number of finite elements within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         #   */
+#         inline unsigned getFiniteElementsCountSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+
+###
+
+# intensity_gradient.h
+# template <typename PointInT, typename PointNT, typename PointOutT, typename IntensitySelectorT = pcl::common::IntensityFieldAccessor<PointInT> >
+# class IntensityGradientEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/intensity_gradient.h" namespace "pcl":
+    cdef cppclass IntensityGradientEstimation[In, NT, Out, Intensity](FeatureFromNormals[In, NT, Out]):
+        IntensityGradientEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (int nr_threads)
+###
+
+# template <typename PointInT, typename PointNT>
+# class IntensityGradientEstimation<PointInT, PointNT, Eigen::MatrixXf>: public IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>
+# cdef extern from "pcl/features/intensity_gradient.h" namespace "pcl":
+#     cdef cppclass IntensityGradientEstimation[In, NT]:
+#         IntensityGradientEstimation ()
+#         # public:
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::indices_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::normals_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::input_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::surface_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::k_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::search_parameter_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::compute;
+
+###
+
+# intensity_spin.h
+# template <typename PointInT, typename PointOutT>
+# class IntensitySpinEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/intensity_spin.h" namespace "pcl":
+    cdef cppclass IntensitySpinEstimation[In, Out](Feature[In, Out]):
+        IntensitySpinEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # ctypedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        ##
+        # /** \brief Estimate the intensity-domain spin image descriptor for a given point based on its spatial
+        #   * neighborhood of 3D points and their intensities. 
+        #   * \param[in] cloud the dataset containing the Cartesian coordinates and intensity values of the points
+        #   * \param[in] radius the radius of the feature
+        #   * \param[in] sigma the standard deviation of the Gaussian smoothing kernel to use during the soft histogram update
+        #   * \param[in] k the number of neighbors to use from \a indices and \a squared_distances
+        #   * \param[in] indices the indices of the points that comprise the query point's neighborhood
+        #   * \param[in] squared_distances the squared distances from the query point to each point in the neighborhood
+        #   * \param[out] intensity_spin_image the resultant intensity-domain spin image descriptor
+        #   */
+        # void computeIntensitySpinImage (const PointCloudIn &cloud, 
+        #                            float radius, float sigma, int k, 
+        #                            const std::vector<int> &indices, 
+        #                            const std::vector<float> &squared_distances, 
+        #                            Eigen::MatrixXf &intensity_spin_image);
+
+        # /** \brief Set the number of bins to use in the distance dimension of the spin image
+        #   * \param[in] nr_distance_bins the number of bins to use in the distance dimension of the spin image
+        #   */
+        # inline void setNrDistanceBins (size_t nr_distance_bins) { nr_distance_bins_ = static_cast<int> (nr_distance_bins); };
+        # /** \brief Returns the number of bins in the distance dimension of the spin image. */
+        # inline int getNrDistanceBins ()
+        # /** \brief Set the number of bins to use in the intensity dimension of the spin image.
+        #   * \param[in] nr_intensity_bins the number of bins to use in the intensity dimension of the spin image
+        #   */
+        # inline void setNrIntensityBins (size_t nr_intensity_bins)
+        # /** \brief Returns the number of bins in the intensity dimension of the spin image. */
+        # inline int getNrIntensityBins ()
+        # /** \brief Set the standard deviation of the Gaussian smoothing kernel to use when constructing the spin images.  
+        #   * \param[in] sigma the standard deviation of the Gaussian smoothing kernel to use when constructing the spin images
+        # inline void setSmoothingBandwith (float sigma)
+        # /** \brief Returns the standard deviation of the Gaussian smoothing kernel used to construct the spin images.  */
+        # inline float getSmoothingBandwith ()
+        # /** \brief Estimate the intensity-domain descriptors at a set of points given by <setInputCloud (), setIndices ()>
+        #   *  using the surface in setSearchSurface (), and the spatial locator in setSearchMethod ().
+        #   * \param[out] output the resultant point cloud model dataset that contains the intensity-domain spin image features
+        # void computeFeature (PointCloudOut &output);
+        # /** \brief The number of distance bins in the descriptor. */
+        # int nr_distance_bins_;
+        # /** \brief The number of intensity bins in the descriptor. */
+        # int nr_intensity_bins_;
+        # /** \brief The standard deviation of the Gaussian smoothing kernel used to construct the spin images. */
+        # float sigma_;
+
+###
+
+# template <typename PointInT>
+# class IntensitySpinEstimation<PointInT, Eigen::MatrixXf>: public IntensitySpinEstimation<PointInT, pcl::Histogram<20> >
+# cdef extern from "pcl/features/intensity_spin.h" namespace "pcl":
+#     cdef cppclass IntensitySpinEstimation[In](IntensitySpinEstimation[In]):
+#         IntensitySpinEstimation ()
+#         # public:
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::getClassName;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::input_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::indices_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::surface_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::search_radius_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::nr_intensity_bins_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::nr_distance_bins_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::tree_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::sigma_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::compute;
+###
+
+# moment_invariants.h
+# template <typename PointInT, typename PointOutT>
+# class MomentInvariantsEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/moment_invariants.h" namespace "pcl":
+    cdef cppclass MomentInvariantsEstimation[In, Out](Feature[In, Out]):
+        MomentInvariantsEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # /** \brief Compute the 3 moment invariants (j1, j2, j3) for a given set of points, using their indices.
+        # * \param[in] cloud the input point cloud
+        # * \param[in] indices the point cloud indices that need to be used
+        # * \param[out] j1 the resultant first moment invariant
+        # * \param[out] j2 the resultant second moment invariant
+        # * \param[out] j3 the resultant third moment invariant
+        # */
+        # void computePointMomentInvariants (const pcl::PointCloud<PointInT> &cloud, 
+        #                             const std::vector<int> &indices, 
+        #                             float &j1, float &j2, float &j3);
+        # * \brief Compute the 3 moment invariants (j1, j2, j3) for a given set of points, using their indices.
+        # * \param[in] cloud the input point cloud
+        # * \param[out] j1 the resultant first moment invariant
+        # * \param[out] j2 the resultant second moment invariant
+        # * \param[out] j3 the resultant third moment invariant
+        # void computePointMomentInvariants (const pcl::PointCloud<PointInT> &cloud, 
+        #                             float &j1, float &j2, float &j3);
+###
+
+# template <typename PointInT>
+# class MomentInvariantsEstimation<PointInT, Eigen::MatrixXf>: public MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>
+# cdef extern from "pcl/features/moment_invariants.h" namespace "pcl":
+#     cdef cppclass MomentInvariantsEstimation[In, Out](MomentInvariantsEstimation[In]):
+#         MomentInvariantsEstimation ()
+#         public:
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::k_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::indices_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::search_parameter_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::surface_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::input_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::compute;
+###
+
+# multiscale_feature_persistence.h
+# template <typename PointSource, typename PointFeature>
+# class MultiscaleFeaturePersistence : public PCLBase<PointSource>
+cdef extern from "pcl/features/multiscale_feature_persistence.h" namespace "pcl":
+    cdef cppclass MultiscaleFeaturePersistence[Source, Feature](cpp.PCLBase[Source]):
+        MultiscaleFeaturePersistence ()
+        # public:
+        # typedef pcl::PointCloud<PointFeature> FeatureCloud;
+        # typedef typename pcl::PointCloud<PointFeature>::Ptr FeatureCloudPtr;
+        # typedef typename pcl::Feature<PointSource, PointFeature>::Ptr FeatureEstimatorPtr;
+        # typedef boost::shared_ptr<const pcl::PointRepresentation <PointFeature> > FeatureRepresentationConstPtr;
+        # using pcl::PCLBase<PointSource>::input_;
+        # 
+        # /** \brief Method that calls computeFeatureAtScale () for each scale parameter */
+        # void computeFeaturesAtAllScales ();
+        
+        # /** \brief Central function that computes the persistent features
+        #  * \param output_features a cloud containing the persistent features
+        #  * \param output_indices vector containing the indices of the points in the input cloud
+        #  * that have persistent features, under a one-to-one correspondence with the output_features cloud
+        #  */
+        # void determinePersistentFeatures (FeatureCloud &output_features, boost::shared_ptr<std::vector<int> > &output_indices);
+        
+        # /** \brief Method for setting the scale parameters for the algorithm
+        #  * \param scale_values vector of scales to determine the characteristic of each scaling step
+        #  */
+        inline void setScalesVector (vector[float] &scale_values)
+        
+        # /** \brief Method for getting the scale parameters vector */
+        inline vector[float] getScalesVector ()
+        
+        # /** \brief Setter method for the feature estimator
+        #  * \param feature_estimator pointer to the feature estimator instance that will be used
+        #  * \note the feature estimator instance should already have the input data given beforehand
+        #  * and everything set, ready to be given the compute () command
+        #  */
+        # inline void setFeatureEstimator (FeatureEstimatorPtr feature_estimator)
+        
+        # /** \brief Getter method for the feature estimator */
+        # inline FeatureEstimatorPtr getFeatureEstimator ()
+        
+        # \brief Provide a pointer to the feature representation to use to convert features to k-D vectors.
+        # \param feature_representation the const boost shared pointer to a PointRepresentation
+        # inline void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation)
+        
+        # \brief Get a pointer to the feature representation used when converting features into k-D vectors. */
+        # inline FeatureRepresentationConstPtr const getPointRepresentation ()
+        
+        # \brief Sets the alpha parameter
+        # \param alpha value to replace the current alpha with
+        inline void setAlpha (float alpha)
+        
+        # /** \brief Get the value of the alpha parameter */
+        inline float getAlpha ()
+        
+        # /** \brief Method for setting the distance metric that will be used for computing the difference between feature vectors
+        # * \param distance_metric the new distance metric chosen from the NormType enum
+        # inline void setDistanceMetric (NormType distance_metric)
+        
+        # /** \brief Returns the distance metric that is currently used to calculate the difference between feature vectors */
+        # inline NormType getDistanceMetric ()
+###
+
+# narf.h
+# namespace pcl 
+# {
+#   // Forward declarations
+#   class RangeImage;
+#   struct InterestPoint;
+# 
+# #define NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE 10
+# narf.h
+# namespace pcl 
+# /**
+# * \brief NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data.
+# * Please refer to pcl/features/narf_descriptor.h if you want the class derived from pcl Feature.
+# * See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard
+# *     Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries
+# *     In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011. 
+# * \author Bastian Steder
+# * \ingroup features
+# */
+# class PCL_EXPORTS Narf
+        # public:
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # //! Constructor
+        # Narf();
+        # //! Copy Constructor
+        # Narf(const Narf& other);
+        # //! Destructor
+        # ~Narf();
+        # 
+        # // =====Operators=====
+        # //! Assignment operator
+        # const Narf& operator=(const Narf& other);
+        # 
+        # // =====STATIC=====
+        # /** The maximum number of openmp threads that can be used in this class */
+        # static int max_no_of_threads;
+        # 
+        # /** Add features extracted at the given interest point and add them to the list */
+        # static void extractFromRangeImageAndAddToList (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Same as above */
+        # static void extractFromRangeImageAndAddToList (const RangeImage& range_image, float image_x, float image_y, int descriptor_size,float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Get a list of features from the given interest points. */
+        # static void extractForInterestPoints (const RangeImage& range_image, const PointCloud<InterestPoint>& interest_points, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Extract an NARF for every point in the range image. */
+        # static void extractForEveryRangeImagePointAndAddToList (const RangeImage& range_image, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # // =====PUBLIC METHODS=====
+        # /** Method to extract a NARF feature from a certain 3D point using a range image.
+        # *  pose determines the coordinate system of the feature, whereas it transforms a point from the world into the feature system.
+        # *  This means the interest point at which the feature is extracted will be the inverse application of pose onto (0,0,0).
+        # *  descriptor_size_ determines the size of the descriptor,
+        # *  support_size determines the support size of the feature, meaning the size in the world it covers */
+        # bool extractFromRangeImage (const RangeImage& range_image, const Eigen::Affine3f& pose, int descriptor_size, float support_size,int surface_patch_world_size=NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE);
+        # 
+        # //! Same as above, but determines the transformation from the surface in the range image
+        # bool extractFromRangeImage (const RangeImage& range_image, float x, float y, int descriptor_size, float support_size);
+        # 
+        # //! Same as above
+        # bool extractFromRangeImage (const RangeImage& range_image, const InterestPoint& interest_point, int descriptor_size, float support_size);
+        # 
+        # //! Same as above
+        # bool extractFromRangeImage (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size);
+        # 
+        # /** Same as above, but using the rotational invariant version by choosing the best extracted rotation around the normal.
+        # *  Use extractFromRangeImageAndAddToList if you want to enable the system to return multiple features with different rotations. */
+        # bool extractFromRangeImageWithBestRotation (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size);
+        # 
+        # /* Get the dominant rotations of the current descriptor
+        # * \param rotations the returned rotations
+        # * \param strength values describing how pronounced the corresponding rotations are
+        # */
+        # void getRotations (std::vector<float>& rotations, std::vector<float>& strengths) const;
+        # 
+        # /* Get the feature with a different rotation around the normal
+        # * You are responsible for deleting the new features!
+        # * \param range_image the source from which the feature is extracted
+        # * \param rotations list of angles (in radians)
+        # * \param rvps returned features
+        # */
+        # void getRotatedVersions (const RangeImage& range_image, const std::vector<float>& rotations, std::vector<Narf*>& features) const;
+        # 
+        # //! Calculate descriptor distance, value in [0,1] with 0 meaning identical and 1 every cell above maximum distance
+        # inline float getDescriptorDistance (const Narf& other) const;
+        # 
+        # //! How many points on each beam of the gradient star are used to calculate the descriptor?
+        # inline int getNoOfBeamPoints () const { return (static_cast<int> (pcl_lrint (ceil (0.5f * float (surface_patch_pixel_size_))))); }
+        # 
+        # //! Copy the descriptor and pose to the point struct Narf36
+        # inline void copyToNarf36 (Narf36& narf36) const;
+        # 
+        # /** Write to file */
+        # void saveBinary (const std::string& filename) const;
+        # 
+        # /** Write to output stream */
+        # void saveBinary (std::ostream& file) const;
+        # 
+        # /** Read from file */
+        # void loadBinary (const std::string& filename);
+        # /** Read from input stream */
+        # void loadBinary (std::istream& file);
+        # 
+        # //! Create the descriptor from the already set other members
+        # bool extractDescriptor (int descriptor_size);
+        # 
+        # // =====GETTERS=====
+        # //! Getter (const) for the descriptor
+        # inline const float* getDescriptor () const { return descriptor_;}
+        # //! Getter for the descriptor
+        # inline float* getDescriptor () { return descriptor_;}
+        # //! Getter (const) for the descriptor length
+        # inline const int& getDescriptorSize () const { return descriptor_size_;}
+        # //! Getter for the descriptor length
+        # inline int& getDescriptorSize () { return descriptor_size_;}
+        # //! Getter (const) for the position
+        # inline const Eigen::Vector3f& getPosition () const { return position_;}
+        # //! Getter for the position
+        # inline Eigen::Vector3f& getPosition () { return position_;}
+        # //! Getter (const) for the 6DoF pose
+        # inline const Eigen::Affine3f& getTransformation () const { return transformation_;}
+        # //! Getter for the 6DoF pose
+        # inline Eigen::Affine3f& getTransformation () { return transformation_;}
+        # //! Getter (const) for the pixel size of the surface patch (only one dimension)
+        # inline const int& getSurfacePatchPixelSize () const { return surface_patch_pixel_size_;}
+        # //! Getter for the pixel size of the surface patch (only one dimension)
+        # inline int& getSurfacePatchPixelSize () { return surface_patch_pixel_size_;}
+        # //! Getter (const) for the world size of the surface patch
+        # inline const float& getSurfacePatchWorldSize () const { return surface_patch_world_size_;}
+        # //! Getter for the world size of the surface patch
+        # inline float& getSurfacePatchWorldSize () { return surface_patch_world_size_;}
+        # //! Getter (const) for the rotation of the surface patch
+        # inline const float& getSurfacePatchRotation () const { return surface_patch_rotation_;}
+        # //! Getter for the rotation of the surface patch
+        # inline float& getSurfacePatchRotation () { return surface_patch_rotation_;}
+        # //! Getter (const) for the surface patch
+        # inline const float* getSurfacePatch () const { return surface_patch_;}
+        # //! Getter for the surface patch
+        # inline float* getSurfacePatch () { return surface_patch_;}
+        # //! Method to erase the surface patch and free the memory
+        # inline void freeSurfacePatch () { delete[] surface_patch_; surface_patch_=NULL; surface_patch_pixel_size_=0; }
+        # 
+        # // =====SETTERS=====
+        # //! Setter for the descriptor
+        # inline void setDescriptor (float* descriptor) { descriptor_ = descriptor;}
+        # //! Setter for the surface patch
+        # inline void setSurfacePatch (float* surface_patch) { surface_patch_ = surface_patch;}
+        # 
+        # // =====PUBLIC MEMBER VARIABLES=====
+        # 
+        # // =====PUBLIC STRUCTS=====
+        # struct FeaturePointRepresentation : public PointRepresentation<Narf*>
+        # {
+        #     typedef Narf* PointT;
+        #     FeaturePointRepresentation(int nr_dimensions) { this->nr_dimensions_ = nr_dimensions; }
+        #     /** \brief Empty destructor */
+        #     virtual ~FeaturePointRepresentation () {}
+        #     virtual void copyToFloatArray (const PointT& p, float* out) const { memcpy(out, p->getDescriptor(), sizeof(*p->getDescriptor())*this->nr_dimensions_); }
+        # };
+
+
+###
+
+# narf_descriptor.h
+# namespace pcl
+#     // Forward declarations
+#     class RangeImage;
+##
+# narf_descriptor.h
+# namespace pcl
+# /** @b Computes NARF feature descriptors for points in a range image
+# * See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard
+# *     Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries
+# *     In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011. 
+# * \author Bastian Steder
+# * \ingroup features
+# */
+# class PCL_EXPORTS NarfDescriptor : public Feature<PointWithRange,Narf36>
+        # public:
+        # typedef boost::shared_ptr<NarfDescriptor> Ptr;
+        # typedef boost::shared_ptr<const NarfDescriptor> ConstPtr;
+        # // =====TYPEDEFS=====
+        # typedef Feature<PointWithRange,Narf36> BaseClass;
+        # 
+        # // =====STRUCTS/CLASSES=====
+        # struct Parameters
+        # {
+        #   Parameters() : support_size(-1.0f), rotation_invariant(true) {}
+        #   float support_size;
+        #   bool rotation_invariant;
+        # };
+        # 
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # NarfDescriptor (const RangeImage* range_image=NULL, const std::vector<int>* indices=NULL);
+        # /** Destructor */
+        # virtual ~NarfDescriptor();
+        # 
+        # // =====METHODS=====
+        # //! Set input data
+        # void setRangeImage (const RangeImage* range_image, const std::vector<int>* indices=NULL);
+        # 
+        # //! Overwrite the compute function of the base class
+        # void compute (cpp.PointCloud[Out]& output);
+        # 
+        # // =====GETTER=====
+        # //! Get a reference to the parameters struct
+        # Parameters& getParameters () { return parameters_;}
+
+
+###
+
+# normal_3d.h
+# cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+#     cdef cppclass NormalEstimation[I, N, O]:
+#         NormalEstimation()
+# 
+#   template <typename PointT> inline void
+#   computePointNormal (const pcl::PointCloud<PointT> &cloud,
+#                       Eigen::Vector4f &plane_parameters, float &curvature)
+#   /** \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+#     * and return the estimated plane parameters together with the surface curvature.
+#     * \param cloud the input point cloud
+#     * \param indices the point cloud indices that need to be used
+#     * \param plane_parameters the plane parameters as: a, b, c, d (ax + by + cz + d = 0)
+#     * \param curvature the estimated surface curvature as a measure of
+#     * \f[
+#     * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+#     * \f]
+#     * \ingroup features
+#     */
+#   template <typename PointT> inline void
+#   computePointNormal (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices,
+#                       Eigen::Vector4f &plane_parameters, float &curvature)
+#
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param normal the plane normal to be flipped
+#     * \ingroup features
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               Eigen::Matrix<Scalar, 4, 1>& normal)
+# 
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param normal the plane normal to be flipped
+#     * \ingroup features
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               Eigen::Matrix<Scalar, 3, 1>& normal)
+#   
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param nx the resultant X component of the plane normal
+#     * \param ny the resultant Y component of the plane normal
+#     * \param nz the resultant Z component of the plane normal
+#     * \ingroup features
+#     */
+#   template <typename PointT> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               float &nx, float &ny, float &nz)
+#
+
+# template <typename PointInT, typename PointOutT>
+# class NormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+    cdef cppclass NormalEstimation[In, Out](Feature[In, Out]):
+        NormalEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudConstPtr PointCloudConstPtr;
+        
+        # * \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+        # * and return the estimated plane parameters together with the surface curvature.
+        # * \param cloud the input point cloud
+        # * \param indices the point cloud indices that need to be used
+        # * \param plane_parameters the plane parameters as: a, b, c, d (ax + by + cz + d = 0)
+        # * \param curvature the estimated surface curvature as a measure of
+        # * \f[
+        # * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+        # * \f]
+        # inline void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, Eigen::Vector4f &plane_parameters, float &curvature)
+        # void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, eigen3.Vector4f &plane_parameters, float &curvature)
+        
+        # * \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+        # * and return the estimated plane parameters together with the surface curvature.
+        # * \param cloud the input point cloud
+        # * \param indices the point cloud indices that need to be used
+        # * \param nx the resultant X component of the plane normal
+        # * \param ny the resultant Y component of the plane normal
+        # * \param nz the resultant Z component of the plane normal
+        # * \param curvature the estimated surface curvature as a measure of
+        # * \f[
+        # * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+        # * \f]
+        # inline void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, float &nx, float &ny, float &nz, float &curvature)
+        void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, float &nx, float &ny, float &nz, float &curvature)
+        
+        # * \brief Provide a pointer to the input dataset
+        # * \param cloud the const boost shared pointer to a PointCloud message
+        # virtual inline void setInputCloud (const PointCloudConstPtr &cloud)
+        # * \brief Set the viewpoint.
+        # * \param vpx the X coordinate of the viewpoint
+        # * \param vpy the Y coordinate of the viewpoint
+        # * \param vpz the Z coordinate of the viewpoint
+        inline void setViewPoint (float vpx, float vpy, float vpz)
+        
+        # * \brief Get the viewpoint.
+        # * \param [out] vpx x-coordinate of the view point
+        # * \param [out] vpy y-coordinate of the view point
+        # * \param [out] vpz z-coordinate of the view point
+        # * \note this method returns the currently used viewpoint for normal flipping.
+        # * If the viewpoint is set manually using the setViewPoint method, this method will return the set view point coordinates.
+        # * If an input cloud is set, it will return the sensor origin otherwise it will return the origin (0, 0, 0)
+        inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        
+        # * \brief sets whether the sensor origin or a user given viewpoint should be used. After this method, the 
+        # * normal estimation method uses the sensor origin of the input cloud.
+        # * to use a user defined view point, use the method setViewPoint
+        inline void useSensorOriginAsViewPoint ()
+        
+ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+
+###
+
+# template <typename PointInT>
+# class NormalEstimation<PointInT, Eigen::MatrixXf>: public NormalEstimation<PointInT, pcl::Normal>
+# cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+#     cdef cppclass NormalEstimation[In, Eigen::MatrixXf](NormalEstimation[In, pcl::Normal]):
+#         NormalEstimation ()
+#     public:
+#       using NormalEstimation<PointInT, pcl::Normal>::indices_;
+#       using NormalEstimation<PointInT, pcl::Normal>::input_;
+#       using NormalEstimation<PointInT, pcl::Normal>::surface_;
+#       using NormalEstimation<PointInT, pcl::Normal>::k_;
+#       using NormalEstimation<PointInT, pcl::Normal>::search_parameter_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpx_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpy_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpz_;
+#       using NormalEstimation<PointInT, pcl::Normal>::computePointNormal;
+#       using NormalEstimation<PointInT, pcl::Normal>::compute;
+###
+
+# normal_3d_omp.h
+# template <typename PointInT, typename PointOutT>
+# class NormalEstimationOMP: public NormalEstimation<PointInT, PointOutT>
+cdef extern from "pcl/features/normal_3d_omp.h" namespace "pcl":
+    cdef cppclass NormalEstimationOMP[In, Out](NormalEstimation[In, Out]):
+        NormalEstimationOMP ()
+        NormalEstimationOMP (unsigned int nr_threads)
+        # public:
+        # using NormalEstimation<PointInT, PointOutT>::feature_name_;
+        # using NormalEstimation<PointInT, PointOutT>::getClassName;
+        # using NormalEstimation<PointInT, PointOutT>::indices_;
+        # using NormalEstimation<PointInT, PointOutT>::input_;
+        # using NormalEstimation<PointInT, PointOutT>::k_;
+        # using NormalEstimation<PointInT, PointOutT>::search_parameter_;
+        # using NormalEstimation<PointInT, PointOutT>::surface_;
+        # using NormalEstimation<PointInT, PointOutT>::getViewPoint;
+        # typedef typename NormalEstimation<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        #     * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # */
+        inline void setNumberOfThreads (unsigned int nr_threads)
+###
+
+# template <typename PointInT>
+# class NormalEstimationOMP<PointInT, Eigen::MatrixXf>: public NormalEstimationOMP<PointInT, pcl::Normal>
+#     public:
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::indices_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::search_parameter_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::k_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::input_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::surface_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::getViewPoint;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::threads_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::compute;
+# 
+#       /** \brief Default constructor.
+#         */
+#       NormalEstimationOMP () : NormalEstimationOMP<PointInT, pcl::Normal> () {}
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       NormalEstimationOMP (unsigned int nr_threads) : NormalEstimationOMP<PointInT, pcl::Normal> (nr_threads) {}
+# 
+
+
+###
+
+# normal_based_signature.h
+# template <typename PointT, typename PointNT, typename PointFeature>
+# class NormalBasedSignatureEstimation : public FeatureFromNormals<PointT, PointNT, PointFeature>
+cdef extern from "pcl/features/normal_based_signature.h" namespace "pcl":
+    cdef cppclass NormalBasedSignatureEstimation[In, NT, Feature](FeatureFromNormals[In,  NT, Feature]):
+        NormalBasedSignatureEstimation ()
+        # public:
+        # using Feature<PointT, PointFeature>::input_;
+        # using Feature<PointT, PointFeature>::tree_;
+        # using Feature<PointT, PointFeature>::search_radius_;
+        # using PCLBase<PointT>::indices_;
+        # using FeatureFromNormals<PointT, PointNT, PointFeature>::normals_;
+        # typedef pcl::PointCloud<PointFeature> FeatureCloud;
+        # typedef typename boost::shared_ptr<NormalBasedSignatureEstimation<PointT, PointNT, PointFeature> > Ptr;
+        # typedef typename boost::shared_ptr<const NormalBasedSignatureEstimation<PointT, PointNT, PointFeature> > ConstPtr;
+        # /** \brief Setter method for the N parameter - the length of the columns used for the Discrete Fourier Transform. 
+        # * \param[in] n the length of the columns used for the Discrete Fourier Transform. 
+        inline void setN (size_t n)
+        # /** \brief Returns the N parameter - the length of the columns used for the Discrete Fourier Transform. */
+        # inline size_t getN ()
+        # /** \brief Setter method for the M parameter - the length of the rows used for the Discrete Cosine Transform.
+        # * \param[in] m the length of the rows used for the Discrete Cosine Transform.
+        inline void setM (size_t m)
+        # /** \brief Returns the M parameter - the length of the rows used for the Discrete Cosine Transform */
+        inline size_t getM ()
+        # /** \brief Setter method for the N' parameter - the number of columns to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        # * \param[in] n_prime the number of columns from the matrix of DFT and DCT that will be contained in the output
+        inline void setNPrime (size_t n_prime)
+        # /** \brief Returns the N' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        inline size_t getNPrime ()
+        # * \brief Setter method for the M' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        # * \param[in] m_prime the number of rows from the matrix of DFT and DCT that will be contained in the output
+        inline void setMPrime (size_t m_prime)
+        # * \brief Returns the M' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        inline size_t getMPrime ()
+        # * \brief Setter method for the scale parameter - used to determine the radius of the sampling disc around the
+        # * point of interest - linked to the smoothing scale of the input cloud
+        inline void setScale (float scale)
+        # * \brief Returns the scale parameter - used to determine the radius of the sampling disc around the
+        # * point of interest - linked to the smoothing scale of the input cloud
+        inline float getScale ()
+###
+
+# pfh.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PFHSignature125>
+# class PFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/pfh.h" namespace "pcl":
+    cdef cppclass PFHEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PFHEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # * \brief Set the maximum internal cache size. Defaults to 2GB worth of entries.
+        # * \param[in] cache_size maximum cache size 
+        inline void setMaximumCacheSize (unsigned int cache_size)
+        # /** \brief Get the maximum internal cache size. */
+        inline unsigned int getMaximumCacheSize ()
+        # * \brief Set whether to use an internal cache mechanism for removing redundant calculations or not. 
+        # * \note Depending on how the point cloud is ordered and how the nearest
+        # * neighbors are estimated, using a cache could have a positive or a
+        # * negative influence. Please test with and without a cache on your
+        # * data, and choose whatever works best!
+        # * See \ref setMaximumCacheSize for setting the maximum cache size
+        # * \param[in] use_cache set to true to use the internal cache, false otherwise
+        inline void setUseInternalCache (bool use_cache)
+        # /** \brief Get whether the internal cache is used or not for computing the PFH features. */
+        inline bool getUseInternalCache ()
+        # * \brief Compute the 4-tuple representation containing the three angles and one distance between two points
+        # * represented by Cartesian coordinates and normals.
+        # * \note For explanations about the features, please see the literature mentioned above (the order of the
+        # * features might be different).
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals (assuming normalized vectors) at each point in cloud
+        # * \param[in] p_idx the index of the first point (source)
+        # * \param[in] q_idx the index of the second point (target)
+        # * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+        # * \param[out] f2 the second angular feature (angle between nq_idx and v)
+        # * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+        # * \param[out] f4 the distance feature (p_idx - q_idx)
+        # * \note For efficiency reasons, we assume that the point data passed to the method is finite.
+        bool computePairFeatures (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals, 
+                                    int p_idx, int q_idx, float &f1, float &f2, float &f3, float &f4);
+        # * \brief Estimate the PFH (Point Feature Histograms) individual signatures of the three angular (f1, f2, f3)
+        # * features for a given point based on its spatial neighborhood of 3D points with normals
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        # * \param[in] indices the k-neighborhood point indices in the dataset
+        # * \param[in] nr_split the number of subdivisions for each angular feature interval
+        # * \param[out] pfh_histogram the resultant (combinatorial) PFH histogram representing the feature at the query point
+        # void computePointPFHSignature (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals, 
+        #                         const vector[int] &indices, int nr_split, Eigen::VectorXf &pfh_histogram);
+
+
+###
+
+# template <typename PointInT, typename PointNT>
+# class PFHEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>
+#     public:
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::pfh_histogram_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::nr_subdiv_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::k_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::indices_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::search_parameter_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::surface_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::input_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::normals_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::computePointPFHSignature;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::compute;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::feature_map_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::key_list_;
+
+###
+
+# pfhrgb.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PFHRGBSignature250>
+# class PFHRGBEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/pfhrgb.h" namespace "pcl":
+    cdef cppclass PFHRGBEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PFHRGBEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        bool computeRGBPairFeatures (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals,
+                              int p_idx, int q_idx,
+                              float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7)
+        # void computePointPFHRGBSignature (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals,
+        #                            const vector[int] &indices, int nr_split, Eigen::VectorXf &pfhrgb_histogram)
+
+
+###
+
+# ppf.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/ppf.h" namespace "pcl":
+    cdef cppclass PPFEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PPFEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+
+# template <typename PointInT, typename PointNT>
+# class PPFEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PPFEstimation<PointInT, PointNT, pcl::PPFSignature>
+#     public:
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::getClassName;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::input_;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::normals_;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::indices_;
+# 
+###
+
+# ppfrgb.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFRGBEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/ppfrgb.h" namespace "pcl":
+    cdef cppclass PPFRGBEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PPFRGBEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFRGBRegionEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+#       PPFRGBRegionEstimation ();
+#     public:
+#       using PCLBase<PointInT>::indices_;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::tree_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       typedef pcl::PointCloud<PointOutT> PointCloudOut;
+###
+
+# principal_curvatures.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PrincipalCurvatures>
+# class PrincipalCurvaturesEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/principal_curvatures.h" namespace "pcl":
+    cdef cppclass PrincipalCurvaturesEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PrincipalCurvaturesEstimation ()
+#       public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       /** \brief Perform Principal Components Analysis (PCA) on the point normals of a surface patch in the tangent
+#        *  plane of the given point normal, and return the principal curvature (eigenvector of the max eigenvalue),
+#        *  along with both the max (pc1) and min (pc2) eigenvalues
+#        * \param[in] normals the point cloud normals
+#        * \param[in] p_idx the query point at which the least-squares plane was estimated
+#        * \param[in] indices the point cloud indices that need to be used
+#        * \param[out] pcx the principal curvature X direction
+#        * \param[out] pcy the principal curvature Y direction
+#        * \param[out] pcz the principal curvature Z direction
+#        * \param[out] pc1 the max eigenvalue of curvature
+#        * \param[out] pc2 the min eigenvalue of curvature
+#        */
+#       void computePointPrincipalCurvatures (const pcl::PointCloud<PointNT> &normals,
+#                                        int p_idx, const std::vector<int> &indices,
+#                                        float &pcx, float &pcy, float &pcz, float &pc1, float &pc2);
+
+# template <typename PointInT, typename PointNT>
+# class PrincipalCurvaturesEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>
+#     public:
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::indices_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::k_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::search_parameter_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::surface_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::compute;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::input_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::normals_;
+###
+
+# range_image_border_extractor.h
+# namespace pcl
+# class RangeImage;
+# template <typename PointType>
+# class PointCloud;
+
+# class PCL_EXPORTS RangeImageBorderExtractor : public Feature<PointWithRange, BorderDescription>
+cdef extern from "pcl/features/range_image_border_extractor.h" namespace "pcl":
+    cdef cppclass RangeImageBorderExtractor(Feature[cpp.PointWithRange, cpp.BorderDescription]):
+        RangeImageBorderExtractor ()
+        RangeImageBorderExtractor (const pcl_r_img.RangeImage range_image)
+        # =====CONSTRUCTOR & DESTRUCTOR=====
+        # Constructor
+        # RangeImageBorderExtractor (const RangeImage* range_image = NULL)
+        # /** Destructor */
+        # ~RangeImageBorderExtractor ();
+        # 
+        
+        # public:
+        # // =====PUBLIC STRUCTS=====
+        # Stores some information extracted from the neighborhood of a point
+        # struct LocalSurface
+        # {
+        #   LocalSurface () : 
+        #     normal (), neighborhood_mean (), eigen_values (), normal_no_jumps (), 
+        #     neighborhood_mean_no_jumps (), eigen_values_no_jumps (), max_neighbor_distance_squared () {}
+        # 
+        #   Eigen::Vector3f normal;
+        #   Eigen::Vector3f neighborhood_mean;
+        #   Eigen::Vector3f eigen_values;
+        #   Eigen::Vector3f normal_no_jumps;
+        #   Eigen::Vector3f neighborhood_mean_no_jumps;
+        #   Eigen::Vector3f eigen_values_no_jumps;
+        #   float max_neighbor_distance_squared;
+        # };
+        
+        # Stores the indices of the shadow border corresponding to obstacle borders
+        # struct ShadowBorderIndices 
+        # {
+        #   ShadowBorderIndices () : left (-1), right (-1), top (-1), bottom (-1) {}
+        #   int left, right, top, bottom;
+        # };
+        
+        # Parameters used in this class
+        # struct Parameters
+        # {
+        #   Parameters () : max_no_of_threads(1), pixel_radius_borders (3), pixel_radius_plane_extraction (2), pixel_radius_border_direction (2), 
+        #                  minimum_border_probability (0.8f), pixel_radius_principal_curvature (2) {}
+        #   int max_no_of_threads;
+        #   int pixel_radius_borders;
+        #   int pixel_radius_plane_extraction;
+        #   int pixel_radius_border_direction;
+        #   float minimum_border_probability;
+        #   int pixel_radius_principal_curvature;
+        # };
+        
+        # =====STATIC METHODS=====
+        # brief Take the information from BorderTraits to calculate the local direction of the border
+        # param border_traits contains the information needed to calculate the border angle
+        # 
+        # static inline float getObstacleBorderAngle (const BorderTraits& border_traits);
+        
+        # // =====METHODS=====
+        # /** \brief Provide a pointer to the range image
+        #   * \param range_image a pointer to the range_image
+        # void setRangeImage (const RangeImage* range_image);
+        void setRangeImage (const pcl_r_img.RangeImage range_image)
+        
+        # brief Erase all data calculated for the current range image
+        void clearData ()
+        
+        # brief Get the 2D directions in the range image from the border directions - probably mainly useful for 
+        # visualization 
+        # float* getAnglesImageForBorderDirections ();
+        # float[] getAnglesImageForBorderDirections ()
+        
+        # brief Get the 2D directions in the range image from the surface change directions - probably mainly useful for visualization 
+        # float* getAnglesImageForSurfaceChangeDirections ();
+        # float[] getAnglesImageForSurfaceChangeDirections ()
+        
+        # /** Overwrite the compute function of the base class */
+        # void compute (PointCloudOut& output);
+        # void compute (cpp.PointCloud[Out]& output)
+        
+        # =====GETTER=====
+        # Parameters& getParameters () { return (parameters_); }
+        # Parameters& getParameters ()
+        # 
+        # bool hasRangeImage () const { return range_image_ != NULL; }
+        bool hasRangeImage ()
+        
+        # const RangeImage& getRangeImage () const { return *range_image_; }
+        const pcl_r_img.RangeImage getRangeImage ()
+        
+        # float* getBorderScoresLeft ()   { extractBorderScoreImages (); return border_scores_left_; }
+        # float* getBorderScoresRight ()  { extractBorderScoreImages (); return border_scores_right_; }
+        # float* getBorderScoresTop ()    { extractBorderScoreImages (); return border_scores_top_; }
+        # float* getBorderScoresBottom () { extractBorderScoreImages (); return border_scores_bottom_; }
+        # 
+        # LocalSurface** getSurfaceStructure () { extractLocalSurfaceStructure (); return surface_structure_; }
+        # PointCloudOut& getBorderDescriptions () { classifyBorders (); return *border_descriptions_; }
+        # ShadowBorderIndices** getShadowBorderInformations () { findAndEvaluateShadowBorders (); return shadow_border_informations_; }
+        # Eigen::Vector3f** getBorderDirections () { calculateBorderDirections (); return border_directions_; }
+        # float* getSurfaceChangeScores () { calculateSurfaceChanges (); return surface_change_scores_; }
+        # Eigen::Vector3f* getSurfaceChangeDirections () { calculateSurfaceChanges (); return surface_change_directions_; }
+
+
+###
+
+# rift.h
+# template <typename PointInT, typename GradientT, typename PointOutT>
+# class RIFTEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/rift.h" namespace "pcl":
+    cdef cppclass RIFTEstimation[In, GradientT, Out](Feature[In, Out]):
+        RIFTEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<GradientT> PointCloudGradient;
+        # typedef typename PointCloudGradient::Ptr PointCloudGradientPtr;
+        # typedef typename PointCloudGradient::ConstPtr PointCloudGradientConstPtr;
+        # typedef typename boost::shared_ptr<RIFTEstimation<PointInT, GradientT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const RIFTEstimation<PointInT, GradientT, PointOutT> > ConstPtr;
+        
+        # brief Provide a pointer to the input gradient data
+        # param[in] gradient a pointer to the input gradient data
+        # inline void setInputGradient (const PointCloudGradientConstPtr &gradient)
+        
+        # /** \brief Returns a shared pointer to the input gradient data */
+        # inline PointCloudGradientConstPtr getInputGradient () const 
+        
+        # brief Set the number of bins to use in the distance dimension of the RIFT descriptor
+        # param[in] nr_distance_bins the number of bins to use in the distance dimension of the RIFT descriptor
+        # inline void setNrDistanceBins (int nr_distance_bins)
+        
+        # /** \brief Returns the number of bins in the distance dimension of the RIFT descriptor. */
+        # inline int getNrDistanceBins () const
+        
+        # /** \brief Set the number of bins to use in the gradient orientation dimension of the RIFT descriptor
+        # * \param[in] nr_gradient_bins the number of bins to use in the gradient orientation dimension of the RIFT descriptor
+        # inline void setNrGradientBins (int nr_gradient_bins)
+        
+        # /** \brief Returns the number of bins in the gradient orientation dimension of the RIFT descriptor. */
+        # inline int getNrGradientBins () const
+        
+        # /** \brief Estimate the Rotation Invariant Feature Transform (RIFT) descriptor for a given point based on its 
+        # * spatial neighborhood of 3D points and the corresponding intensity gradient vector field
+        # * \param[in] cloud the dataset containing the Cartesian coordinates of the points
+        # * \param[in] gradient the dataset containing the intensity gradient at each point in \a cloud
+        # * \param[in] p_idx the index of the query point in \a cloud (i.e. the center of the neighborhood)
+        # * \param[in] radius the radius of the RIFT feature
+        # * \param[in] indices the indices of the points that comprise \a p_idx's neighborhood in \a cloud
+        # * \param[in] squared_distances the squared distances from the query point to each point in the neighborhood
+        # * \param[out] rift_descriptor the resultant RIFT descriptor
+        # void computeRIFT (const PointCloudIn &cloud, const PointCloudGradient &gradient, int p_idx, float radius,
+        #            const std::vector<int> &indices, const std::vector<float> &squared_distances, 
+        #            Eigen::MatrixXf &rift_descriptor);
+
+
+# ctypedef
+# 
+###
+
+# template <typename PointInT, typename GradientT>
+# class RIFTEstimation<PointInT, GradientT, Eigen::MatrixXf>: public RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >
+#     public:
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::getClassName;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::surface_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::indices_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::tree_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::search_radius_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::gradient_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::nr_gradient_bins_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::nr_distance_bins_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::compute;
+###
+
+# shot.h
+# template <typename PointInT, typename PointNT, typename PointOutT, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimationBase : public FeatureFromNormals<PointInT, PointNT, PointOutT>,
+#                            public FeatureWithLocalReferenceFrames<PointInT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTEstimationBase[In, NT, Out, RET](Feature[In, Out]):
+        SHOTEstimationBase ()
+#     public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#     protected:
+#       /** \brief Empty constructor.
+#         * \param[in] nr_shape_bins the number of bins in the shape histogram
+#         */
+#       SHOTEstimationBase (int nr_shape_bins = 10) :
+#         nr_shape_bins_ (nr_shape_bins),
+#         shot_ (),
+#         sqradius_ (0), radius3_4_ (0), radius1_4_ (0), radius1_2_ (0),
+#         nr_grid_sector_ (32),
+#         maxAngularSectors_ (28),
+#         descLength_ (0)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+#     public:
+#        /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#          * \param[in] index the index of the point in indices_
+#          * \param[in] indices the k-neighborhood point indices in surface_
+#          * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#          * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#          */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot) = 0;
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT352, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimation : public SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTEstimation[In, NT, Out, RFT](SHOTEstimationBase[In, NT, Out, RFT]):
+        SHOTEstimation ()
+#     public:
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::indices_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::k_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::surface_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::input_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::normals_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<..., pcl::SHOT, ...> IS DEPRECATED, USE SHOTEstimation<..., pcl::SHOT352, ...> INSTEAD")
+# <PointInT, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>
+# cdef extern from "pcl/features/shot.h" namespace "pcl":
+#    cdef cppclass PCL_DEPRECATED_CLASS[In, NT, RFT](SHOTEstimation[In, NT, pcl::SHOT, RFT]):
+#        SHOTEstimation ()
+#     public:
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::normals_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudIn PointCloudIn;
+#
+#       /** \brief Empty constructor.
+#         * \param[in] nr_shape_bins the number of bins in the shape histogram
+#         */
+#       SHOTEstimation (int nr_shape_bins = 10) : SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+# 
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class SHOTEstimation<PointInT, PointNT, Eigen::MatrixXf, PointRFT> : public SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>
+#     public:
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::feature_name_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::getClassName;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::indices_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::k_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::search_parameter_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::search_radius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::surface_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::input_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::normals_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::descLength_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::sqradius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius3_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius1_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius1_2_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTEstimation (int nr_shape_bins = 10) : SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT> ()
+#       {
+#         feature_name_ = "SHOTEstimation";
+#         nr_shape_bins_ = nr_shape_bins;
+#       };
+# 
+#       /** \brief Base method for feature estimation for all points given in
+#         * <setInputCloud (), setIndices ()> using the surface in setSearchSurface ()
+#         * and the spatial locator in setSearchMethod ()
+#         * \param[out] output the resultant point cloud model dataset containing the estimated features
+#         */
+#       void
+#       computeEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+#       {
+#         pcl::SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::computeEigen (output);
+#       }
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       //virtual void
+#       //computePointSHOT (const int index,
+#                         //const std::vector<int> &indices,
+#                         //const std::vector<float> &sqr_dists,
+#                         //Eigen::VectorXf &shot);
+# 
+#       void computeFeatureEigen (pcl::PointCloud<Eigen::MatrixXf> &output);
+# 
+#     
+#       /** \brief Make the compute (&PointCloudOut); inaccessible from outside the class
+#         * \param[out] output the output point cloud
+#         */
+#       void compute (pcl::PointCloud<pcl::SHOT352> &) { assert(0); }
+#   };
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT1344, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTColorEstimation : public SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTColorEstimation[In, NT, Out, RFT](SHOTEstimationBase[In, NT, Out, RFT]):
+        SHOTColorEstimation ()
+        #       SHOTColorEstimation (bool describe_shape = true,
+        #                            bool describe_color = true)
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::feature_name_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::getClassName;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::indices_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::k_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_parameter_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_radius_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::surface_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::input_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::normals_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::maxAngularSectors_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::interpolateSingleChannel;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::shot_;
+        #       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+        #       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # 
+        #       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+        #         * \param[in] index the index of the point in indices_
+        #         * \param[in] indices the k-neighborhood point indices in surface_
+        #         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+        #         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+        #         */
+        #       virtual void
+        #       computePointSHOT (const int index,
+        #                         const std::vector<int> &indices,
+        #                         const std::vector<float> &sqr_dists,
+        #                         Eigen::VectorXf &shot);
+        #     public:
+        #       /** \brief Converts RGB triplets to CIELab space.
+        #         * \param[in] R the red channel
+        #         * \param[in] G the green channel
+        #         * \param[in] B the blue channel
+        #         * \param[out] L the lightness
+        #         * \param[out] A the first color-opponent dimension
+        #         * \param[out] B2 the second color-opponent dimension
+        #         */
+        #       static void
+        #       RGB2CIELAB (unsigned char R, unsigned char G, unsigned char B, float &L, float &A, float &B2);
+        # 
+        #       static float sRGB_LUT[256];
+        #       static float sXYZ_LUT[4000];
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class SHOTColorEstimation<PointInT, PointNT, Eigen::MatrixXf, PointRFT> : public SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>
+# cdef extern from "pcl/features/shot.h" namespace "pcl":
+#     cdef cppclass SHOTColorEstimation[In, NT, Out, RFT](SHOTColorEstimation[In, NT, Out, RFT]):
+#         SHOTColorEstimation ()
+#     public:
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::feature_name_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::getClassName;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::indices_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::k_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::search_parameter_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::search_radius_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::surface_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::input_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::normals_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::descLength_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_grid_sector_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_shape_bins_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::sqradius_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius3_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius1_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius1_2_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::maxAngularSectors_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::interpolateSingleChannel;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::shot_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::b_describe_shape_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::b_describe_color_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_color_bins_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         */
+#       SHOTColorEstimation (bool describe_shape = true,
+#                            bool describe_color = true,
+#                            int nr_shape_bins = 10,
+#                            int nr_color_bins = 30)
+#         : SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT> (describe_shape, describe_color)
+#       {
+#         feature_name_ = "SHOTColorEstimation";
+#         nr_shape_bins_ = nr_shape_bins;
+#         nr_color_bins_ = nr_color_bins;
+#       };
+# 
+#       /** \brief Base method for feature estimation for all points given in
+#         * <setInputCloud (), setIndices ()> using the surface in setSearchSurface ()
+#         * and the spatial locator in setSearchMethod ()
+#         * \param[out] output the resultant point cloud model dataset containing the estimated features
+#         */
+#       void
+#       computeEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+#       {
+#         pcl::SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::computeEigen (output);
+#       }
+# 
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<pcl::PointXYZRGBA,...,pcl::SHOT,...> IS DEPRECATED, USE SHOTEstimation<pcl::PointXYZRGBA,...,pcl::SHOT352,...> FOR SHAPE AND SHOTColorEstimation<pcl::PointXYZRGBA,...,pcl::SHOT1344,...> FOR SHAPE+COLOR INSTEAD")
+#   <pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#   : public SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> 
+#     public:
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using FeatureFromNormals<pcl::PointXYZRGBA, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::shot_;
+# 
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         * \param[in] nr_shape_bins
+#         * \param[in] nr_color_bins
+#         */
+#       SHOTEstimation (bool describe_shape = true,
+#                       bool describe_color = false,
+#                       const int nr_shape_bins = 10,
+#                       const int nr_color_bins = 30)
+#         : SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins),
+#           b_describe_shape_ (describe_shape),
+#           b_describe_color_ (describe_color),
+#           nr_color_bins_ (nr_color_bins)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+#       /** \brief Quadrilinear interpolation; used when color and shape descriptions are both activated
+#         * \param[in] indices the neighborhood point indices
+#         * \param[in] sqr_dists the neighborhood point distances
+#         * \param[in] index the index of the point in indices_
+#         * \param[out] binDistanceShape the resultant distance shape histogram
+#         * \param[out] binDistanceColor the resultant color shape histogram
+#         * \param[in] nr_bins_shape the number of bins in the shape histogram
+#         * \param[in] nr_bins_color the number of bins in the color histogram
+#         * \param[out] shot the resultant SHOT histogram
+#         */
+#       void
+#       interpolateDoubleChannel (const std::vector<int> &indices,
+#                                 const std::vector<float> &sqr_dists,
+#                                 const int index,
+#                                 std::vector<double> &binDistanceShape,
+#                                 std::vector<double> &binDistanceColor,
+#                                 const int nr_bins_shape,
+#                                 const int nr_bins_color,
+#                                 Eigen::VectorXf &shot);
+# 
+#       /** \brief Converts RGB triplets to CIELab space.
+#         * \param[in] R the red channel
+#         * \param[in] G the green channel
+#         * \param[in] B the blue channel
+#         * \param[out] L the lightness
+#         * \param[out] A the first color-opponent dimension
+#         * \param[out] B2 the second color-opponent dimension
+#         */
+#       static void
+#       RGB2CIELAB (unsigned char R, unsigned char G, unsigned char B, float &L, float &A, float &B2);
+# 
+#       /** \brief Compute shape descriptor. */
+#       bool b_describe_shape_;
+# 
+#       /** \brief Compute color descriptor. */
+#       bool b_describe_color_;
+# 
+#       /** \brief The number of bins in each color histogram. */
+#       int nr_color_bins_;
+# 
+#     public:
+#       static float sRGB_LUT[256];
+#       static float sXYZ_LUT[4000];
+#   };
+
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<pcl::PointXYZRGBA,...,Eigen::MatrixXf,...> IS DEPRECATED, USE SHOTColorEstimation<pcl::PointXYZRGBA,...,Eigen::MatrixXf,...> FOR SHAPE AND SHAPE+COLOR INSTEAD")
+# <pcl::PointXYZRGBA, PointNT, Eigen::MatrixXf, PointRFT>
+# : public SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#     public:
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::shot_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_shape_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_color_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_color_bins_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         * \param[in] nr_shape_bins
+#         * \param[in] nr_color_bins
+#         */
+#       SHOTEstimation (bool describe_shape = true,
+#                       bool describe_color = false,
+#                       const int nr_shape_bins = 10,
+#                       const int nr_color_bins = 30)
+#         : SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (describe_shape, describe_color, nr_shape_bins, nr_color_bins) {};
+# 
+###
+
+# shot_lrf.h
+#  template<typename PointInT, typename PointOutT = ReferenceFrame>
+#  class SHOTLocalReferenceFrameEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/shot_lrf.h" namespace "pcl":
+    cdef cppclass SHOTLocalReferenceFrameEstimation[In, Out](Feature[In, Out]):
+        PrincipalCurvaturesEstimation ()
+        # protected:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # //using Feature<PointInT, PointOutT>::searchForNeighbors;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * \brief Computes disambiguated local RF for a point index
+        # * \param[in] cloud input point cloud
+        # * \param[in] search_radius the neighborhood radius
+        # * \param[in] central_point the point from the input_ cloud at which the local RF is computed
+        # * \param[in] indices the neighbours indices
+        # * \param[in] dists the squared distances to the neighbours
+        # * \param[out] rf reference frame to compute
+        # float getLocalRF (const int &index, Eigen::Matrix3f &rf)
+        # * \brief Feature estimation method.
+        # \param[out] output the resultant features
+        # virtual void computeFeature (PointCloudOut &output)
+        # * \brief Feature estimation method.
+        # * \param[out] output the resultant features
+        # virtual void computeFeatureEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+###
+
+# template <typename PointInT, typename PointNT>
+# class PrincipalCurvaturesEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>
+#     public:
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::indices_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::k_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::search_parameter_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::surface_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::compute;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::input_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::normals_;
+###
+
+# shot_lrf_omp.h
+# template<typename PointInT, typename PointOutT = ReferenceFrame>
+# class SHOTLocalReferenceFrameEstimationOMP : public SHOTLocalReferenceFrameEstimation<PointInT, PointOutT>
+cdef extern from "pcl/features/shot_lrf_omp.h" namespace "pcl":
+    cdef cppclass SHOTLocalReferenceFrameEstimationOMP[In, Out](SHOTLocalReferenceFrameEstimation[In, Out]):
+        SHOTLocalReferenceFrameEstimationOMP ()
+        # public:
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (unsigned int nr_threads)
+
+###
+
+# shot_omp.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT352, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimationOMP : public SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot_omp.h" namespace "pcl":
+    cdef cppclass SHOTEstimationOMP[In, NT, Out, RFT](SHOTEstimation[In, NT, Out, RFT]):
+        SHOTEstimationOMP ()
+        # SHOTEstimationOMP (unsigned int nr_threads = - 1)
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::fake_surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # 
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        #  * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        inline void setNumberOfThreads (unsigned int nr_threads)
+        
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT1344, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTColorEstimationOMP : public SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>
+#     public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::b_describe_shape_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::b_describe_color_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_color_bins_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTColorEstimationOMP (bool describe_shape = true,
+#                               bool describe_color = true,
+#                               unsigned int nr_threads = - 1)
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void setNumberOfThreads (unsigned int nr_threads)
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimationOMP, "SHOTEstimationOMP<..., pcl::SHOT, ...> IS DEPRECATED, USE SHOTEstimationOMP<..., pcl::SHOT352, ...> INSTEAD")
+# <PointInT, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>
+#     public:
+#       using Feature<PointInT, pcl::SHOT>::feature_name_;
+#       using Feature<PointInT, pcl::SHOT>::getClassName;
+#       using Feature<PointInT, pcl::SHOT>::input_;
+#       using Feature<PointInT, pcl::SHOT>::indices_;
+#       using Feature<PointInT, pcl::SHOT>::k_;
+#       using Feature<PointInT, pcl::SHOT>::search_parameter_;
+#       using Feature<PointInT, pcl::SHOT>::search_radius_;
+#       using Feature<PointInT, pcl::SHOT>::surface_;
+#       using Feature<PointInT, pcl::SHOT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudIn PointCloudIn;
+#       /** \brief Empty constructor. */
+#       SHOTEstimationOMP (unsigned int nr_threads = - 1, int nr_shape_bins = 10)
+#         : SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins), threads_ ()
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void setNumberOfThreads (unsigned int nr_threads)
+# 
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimationOMP, "SHOTEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT,...> IS DEPRECATED, USE SHOTEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT352,...> FOR SHAPE AND SHOTColorEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT1344,...> FOR SHAPE+COLOR INSTEAD")
+# <pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#       public:
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using FeatureFromNormals<pcl::PointXYZRGBA, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_shape_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_color_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_color_bins_;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTEstimationOMP (bool describeShape = true,
+#                          bool describeColor = false,
+#                          unsigned int nr_threads = - 1,
+#                          const int nr_shape_bins = 10,
+#                          const int nr_color_bins = 30)
+#         : SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (describeShape, describeColor, nr_shape_bins, nr_color_bins),
+#           threads_ ()
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void
+#       setNumberOfThreads (unsigned int nr_threads)
+###
+
+# spin_image.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class SpinImageEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/spin_image.h" namespace "pcl":
+    cdef cppclass SpinImageEstimation[In, NT, Out](Feature[In, Out]):
+        SpinImageEstimation ()
+        # SpinImageEstimation (unsigned int image_width = 8,
+        #                    double support_angle_cos = 0.0,   // when 0, this is bogus, so not applied
+        #                    unsigned int min_pts_neighb = 0);
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::fake_surface_;
+        # using PCLBase<PointInT>::input_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # typedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename boost::shared_ptr<SpinImageEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const SpinImageEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # /** \brief Sets spin-image resolution.
+        #  * \param[in] bin_count spin-image resolution, number of bins along one dimension
+        void setImageWidth (unsigned int bin_count)
+        # /** \brief Sets the maximum angle for the point normal to get to support region.
+        #   * \param[in] support_angle_cos minimal allowed cosine of the angle between 
+        #   *   the normals of input point and search surface point for the point 
+        #   *   to be retained in the support
+        void setSupportAngle (double support_angle_cos)
+        # /** \brief Sets minimal points count for spin image computation.
+        #   * \param[in] min_pts_neighb min number of points in the support to correctly estimate 
+        #   *   spin-image. If at some point the support contains less points, exception is thrown
+        void setMinPointCountInNeighbourhood (unsigned int min_pts_neighb)
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        #  * the input XYZ dataset given by \ref setInputCloud
+        #  * \attention The input normals given by \ref setInputNormals have to match
+        #  * the input point cloud given by \ref setInputCloud. This behavior is
+        #  * different than feature estimation methods that extend \ref
+        #  * FeatureFromNormals, which match the normals with the search surface.
+        #  * \param[in] normals the const boost shared pointer to a PointCloud of normals. 
+        #  * By convention, L2 norm of each normal should be 1. 
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # /** \brief Sets single vector a rotation axis for all input points.
+        #   * It could be useful e.g. when the vertical axis is known.
+        #   * \param[in] axis unit-length vector that serves as rotation axis for reference frame
+        # void setRotationAxis (const PointNT& axis)
+        # /** \brief Sets array of vectors as rotation axes for input points.
+        #  * Useful e.g. when one wants to use tangents instead of normals as rotation axes
+        #  * \param[in] axes unit-length vectors that serves as rotation axes for 
+        #  *   the corresponding input points' reference frames
+        # void setInputRotationAxes (const PointCloudNConstPtr& axes)
+        # /** \brief Sets input normals as rotation axes (default setting). */
+        void useNormalsAsRotationAxis () 
+        # /** \brief Sets/unsets flag for angular spin-image domain.
+        #   * Angular spin-image differs from the vanilla one in the way that not 
+        #   * the points are collected in the bins but the angles between their
+        #   * normals and the normal to the reference point. For further
+        #   * information please see 
+        #   * Endres, F., Plagemann, C., Stachniss, C., & Burgard, W. (2009). 
+        #   * Unsupervised Discovery of Object Classes from Range Data using Latent Dirichlet Allocation. 
+        #   * In Robotics: Science and Systems. Seattle, USA.
+        #   * \param[in] is_angular true for angular domain, false for point domain
+        void setAngularDomain (bool is_angular = true)
+        # /** \brief Sets/unsets flag for radial spin-image structure.
+        #   * 
+        #   * Instead of rectangular coordinate system for reference frame 
+        #   * polar coordinates are used. Binning is done depending on the distance and 
+        #   * inclination angle from the reference point
+        #   * \param[in] is_radial true for radial spin-image structure, false for rectangular
+        # */
+        void setRadialStructure (bool is_radial = true)
+
+
+####
+
+# template <typename PointInT, typename PointNT>
+# class SpinImageEstimation<PointInT, PointNT, Eigen::MatrixXf> : public SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >
+# cdef extern from "pcl/features/spin_image.h" namespace "pcl":
+#    cdef cppclass SpinImageEstimation[In, NT, Eigen::MatrixXf](SpinImageEstimation[In, NT, pcl::Histogram<153>]):
+#       SpinImageEstimation ()
+#       public:
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::indices_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::search_radius_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::k_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::surface_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::fake_surface_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::compute;
+# 
+#       /** \brief Constructs empty spin image estimator.
+#         * 
+#         * \param[in] image_width spin-image resolution, number of bins along one dimension
+#         * \param[in] support_angle_cos minimal allowed cosine of the angle between 
+#         *   the normals of input point and search surface point for the point 
+#         *   to be retained in the support
+#         * \param[in] min_pts_neighb min number of points in the support to correctly estimate 
+#         *   spin-image. If at some point the support contains less points, exception is thrown
+#         */
+#       SpinImageEstimation (unsigned int image_width = 8,
+#                            double support_angle_cos = 0.0,   // when 0, this is bogus, so not applied
+#                            unsigned int min_pts_neighb = 0) : 
+#       SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> > (image_width, support_angle_cos, min_pts_neighb) {}
+###
+
+# statistical_multiscale_interest_region_extraction.h
+# template <typename PointT>
+# class StatisticalMultiscaleInterestRegionExtraction : public PCLBase<PointT>
+cdef extern from "pcl/features/statistical_multiscale_interest_region_extraction.h" namespace "pcl":
+    cdef cppclass StatisticalMultiscaleInterestRegionExtraction[T](cpp.PCLBase[T]):
+        StatisticalMultiscaleInterestRegionExtraction ()
+        # public:
+        # typedef boost::shared_ptr <std::vector<int> > IndicesPtr;
+        # typedef typename boost::shared_ptr<StatisticalMultiscaleInterestRegionExtraction<PointT> > Ptr;
+        # typedef typename boost::shared_ptr<const StatisticalMultiscaleInterestRegionExtraction<PointT> > ConstPtr;
+        
+        # brief Method that generates the underlying nearest neighbor graph based on the input point cloud
+        void generateCloudGraph ()
+        
+        # brief The method to be called in order to run the algorithm and produce the resulting
+        # set of regions of interest
+        # void computeRegionsOfInterest (list[IndicesPtr_t]& rois)
+        
+        # brief Method for setting the scale parameters for the algorithm
+        # param scale_values vector of scales to determine the size of each scaling step
+        inline void setScalesVector (vector[float] &scale_values)
+        
+        # brief Method for getting the scale parameters vector */
+        inline vector[float] getScalesVector ()
+###
+
+# usc.h
+# template <typename PointInT, typename PointOutT, typename PointRFT = pcl::ReferenceFrame>
+# class UniqueShapeContext : public Feature<PointInT, PointOutT>,
+#                            public FeatureWithLocalReferenceFrames<PointInT, PointRFT>
+# cdef extern from "pcl/features/usc.h" namespace "pcl":
+#     cdef cppclass UniqueShapeContext[In, Out, RFT](Feature[In, Out], FeatureWithLocalReferenceFrames[In, RFT]):
+#        VFHEstimation ()
+#        public:
+#        using Feature<PointInT, PointOutT>::feature_name_;
+#        using Feature<PointInT, PointOutT>::getClassName;
+#        using Feature<PointInT, PointOutT>::indices_;
+#        using Feature<PointInT, PointOutT>::search_parameter_;
+#        using Feature<PointInT, PointOutT>::search_radius_;
+#        using Feature<PointInT, PointOutT>::surface_;
+#        using Feature<PointInT, PointOutT>::fake_surface_;
+#        using Feature<PointInT, PointOutT>::input_;
+#        using Feature<PointInT, PointOutT>::searchForNeighbors;
+#        using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#        typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#        typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#        typedef typename boost::shared_ptr<UniqueShapeContext<PointInT, PointOutT, PointRFT> > Ptr;
+#        typedef typename boost::shared_ptr<const UniqueShapeContext<PointInT, PointOutT, PointRFT> > ConstPtr;
+#        /** \brief Constructor. */
+#        UniqueShapeContext () :
+#       /** \brief Set the number of bins along the azimuth
+#         * \param[in] bins the number of bins along the azimuth
+#       inline void setAzimuthBins (size_t bins)
+#       /** \return The number of bins along the azimuth. */
+#       inline size_t getAzimuthBins () const
+#       /** \brief Set the number of bins along the elevation
+#         * \param[in] bins the number of bins along the elevation
+#         */
+#       inline void setElevationBins (size_t bins)
+#       /** \return The number of bins along the elevation */
+#       inline size_t getElevationBins () const
+#       /** \brief Set the number of bins along the radii
+#         * \param[in] bins the number of bins along the radii
+#       inline void setRadiusBins (size_t bins)
+#       /** \return The number of bins along the radii direction. */
+#       inline size_t getRadiusBins () const
+#       /** The minimal radius value for the search sphere (rmin) in the original paper
+#         * \param[in] radius the desired minimal radius
+#       inline void setMinimalRadius (double radius)
+#       /** \return The minimal sphere radius. */
+#       inline double
+#       getMinimalRadius () const
+#       /** This radius is used to compute local point density
+#         * density = number of points within this radius
+#         * \param[in] radius Value of the point density search radius
+#       inline void setPointDensityRadius (double radius)
+#       /** \return The point density search radius. */
+#       inline double getPointDensityRadius () const
+#       /** Set the local RF radius value
+#         * \param[in] radius the desired local RF radius
+#       inline void setLocalRadius (double radius)
+#       /** \return The local RF radius. */
+#       inline double getLocalRadius () const
+#
+###
+
+# usc.h
+# template <typename PointInT, typename PointRFT>
+# class UniqueShapeContext<PointInT, Eigen::MatrixXf, PointRFT> : public UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>
+# cdef extern from "pcl/features/usc.h" namespace "pcl":
+#     cdef cppclass UniqueShapeContext[In, Eigen::MatrixXf, RET](UniqueShapeContext[In, pcl::SHOT, RET]):
+#       UniqueShapeContext ()
+#       public:
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::indices_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::descriptor_length_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::compute;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::computePointDescriptor;
+###
+
+# vfh.h
+# template<typename PointInT, typename PointNT, typename PointOutT = pcl::VFHSignature308>
+# class VFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/vfh.h" namespace "pcl":
+    cdef cppclass VFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        VFHEstimation ()
+        # public:
+        # /** \brief Estimate the SPFH (Simple Point Feature Histograms) signatures of the angular
+        #   * (f1, f2, f3) and distance (f4) features for a given point from its neighborhood
+        #   * \param[in] centroid_p the centroid point
+        #   * \param[in] centroid_n the centroid normal
+        #   * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        #   * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        #   * \param[in] indices the k-neighborhood point indices in the dataset
+        # void computePointSPFHSignature (const Eigen::Vector4f &centroid_p, const Eigen::Vector4f &centroid_n,
+        #                            const pcl::PointCloud<PointInT> &cloud, const pcl::PointCloud<PointNT> &normals,
+        #                            const std::vector<int> &indices);
+        # 
+        # /** \brief Set the viewpoint.
+        #   * \param[in] vpx the X coordinate of the viewpoint
+        #   * \param[in] vpy the Y coordinate of the viewpoint
+        #   * \param[in] vpz the Z coordinate of the viewpoint
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # /** \brief Get the viewpoint. */
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        # 
+        # /** \brief Set use_given_normal_
+        #   * \param[in] use Set to true if you want to use the normal passed to setNormalUse(normal)
+        #   */
+        # inline void setUseGivenNormal (bool use)
+        # 
+        # /** \brief Set the normal to use
+        #   * \param[in] normal Sets the normal to be used in the VFH computation. It is is used
+        #   * to build the Darboux Coordinate system.
+        #   */
+        # inline void setNormalToUse (const Eigen::Vector3f &normal)
+        # 
+        # /** \brief Set use_given_centroid_
+        #   * \param[in] use Set to true if you want to use the centroid passed through setCentroidToUse(centroid)
+        #   */
+        # inline void setUseGivenCentroid (bool use)
+        # 
+        # /** \brief Set centroid_to_use_
+        #   * \param[in] centroid Centroid to be used in the VFH computation. It is used to compute the distances
+        #   * from all points to this centroid.
+        #   */
+        # inline void setCentroidToUse (const Eigen::Vector3f &centroid)
+        # 
+        # /** \brief set normalize_bins_
+        #   * \param[in] normalize If true, the VFH bins are normalized using the total number of points
+        #   */
+        # inline void setNormalizeBins (bool normalize)
+        # 
+        # /** \brief set normalize_distances_
+        #   * \param[in] normalize If true, the 4th component of VFH (shape distribution component) get normalized
+        #   * by the maximum size between the centroid and the point cloud
+        #   */
+        # inline void setNormalizeDistance (bool normalize)
+        # 
+        # /** \brief set size_component_
+        #   * \param[in] fill_size True if the 4th component of VFH (shape distribution component) needs to be filled.
+        #   * Otherwise, it is set to zero.
+        #   */
+        # inline void setFillSizeComponent (bool fill_size)
+        # 
+        # /** \brief Overloaded computed method from pcl::Feature.
+        #   * \param[out] output the resultant point cloud model dataset containing the estimated features
+        #   */
+        # void compute (cpp.PointCloud[Out] &output);
+
+
+ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+# Template
+# # enum CoordinateFrame
+# # CAMERA_FRAME = 0,
+# # LASER_FRAME = 1
+# Start
+# cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+#     ctypedef enum CoordinateFrame2 "pcl::RangeImage::CoordinateFrame":
+#         COORDINATEFRAME_CAMERA "pcl::RangeImage::CAMERA_FRAME"
+#         COORDINATEFRAME_LASER "pcl::RangeImage::LASER_FRAME"
+###
+
+# integral_image_normal.h
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#         cdef enum BorderPolicy:
+#             BORDER_POLICY_IGNORE
+#             BORDER_POLICY_MIRROR
+# NG : IntegralImageNormalEstimation use Template
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#     ctypedef enum BorderPolicy2 "pcl::IntegralImageNormalEstimation::BorderPolicy":
+#         BORDERPOLICY_IGNORE "pcl::IntegralImageNormalEstimation::BORDER_POLICY_IGNORE"
+#         BORDERPOLICY_MIRROR "pcl::IntegralImageNormalEstimation::BORDER_POLICY_MIRROR"
+###
+
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#         cdef enum NormalEstimationMethod:
+#             COVARIANCE_MATRIX
+#             AVERAGE_3D_GRADIENT
+#             AVERAGE_DEPTH_CHANGE
+#             SIMPLE_3D_GRADIENT
+# 
+# NG : IntegralImageNormalEstimation use Template
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+#     ctypedef enum NormalEstimationMethod2 "pcl::IntegralImageNormalEstimation::NormalEstimationMethod":
+#         ESTIMATIONMETHOD_COVARIANCE_MATRIX "pcl::IntegralImageNormalEstimation::COVARIANCE_MATRIX"
+#         ESTIMATIONMETHOD_AVERAGE_3D_GRADIENT "pcl::IntegralImageNormalEstimation::AVERAGE_3D_GRADIENT"
+#         ESTIMATIONMETHOD_AVERAGE_DEPTH_CHANGE "pcl::IntegralImageNormalEstimation::AVERAGE_DEPTH_CHANGE"
+#         ESTIMATIONMETHOD_SIMPLE_3D_GRADIENT "pcl::IntegralImageNormalEstimation::SIMPLE_3D_GRADIENT"
+# NG : (Test Cython 0.24.1)
+# define __PYX_VERIFY_RETURN_INT/__PYX_VERIFY_RETURN_INT_EXC etc... , Convert Error "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::NormalEstimationMethod"
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#     ctypedef enum NormalEstimationMethod2 "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::NormalEstimationMethod":
+#         ESTIMATIONMETHOD_COVARIANCE_MATRIX "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::COVARIANCE_MATRIX"
+#         ESTIMATIONMETHOD_AVERAGE_3D_GRADIENT "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::AVERAGE_3D_GRADIENT"
+#         ESTIMATIONMETHOD_AVERAGE_DEPTH_CHANGE "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::AVERAGE_DEPTH_CHANGE"
+#         ESTIMATIONMETHOD_SIMPLE_3D_GRADIENT "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::SIMPLE_3D_GRADIENT"
+###
+
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_features_180.pxd b/pcl/pcl_features_180.pxd
new file mode 100644
index 0000000..d568d98
--- /dev/null
+++ b/pcl/pcl_features_180.pxd
@@ -0,0 +1,3817 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_kdtree_180 as pclkdt
+cimport pcl_range_image_180 as pcl_r_img
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# feature.h
+# class Feature : public PCLBase<PointInT>
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass Feature[In, Out](cpp.PCLBase[In]):
+        Feature ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::input_;
+        # ctypedef PCLBase<PointInT> BaseClass;
+        # ctypedef boost::shared_ptr< Feature<PointInT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const Feature<PointInT, PointOutT> > ConstPtr;
+        # ctypedef typename pcl::search::Search<PointInT> KdTree;
+        # ctypedef typename pcl::search::Search<PointInT>::Ptr KdTreePtr;
+        # ctypedef pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # ctypedef boost::function<int (size_t, double, std::vector<int> &, std::vector<float> &)> SearchMethod;
+        # ctypedef boost::function<int (const PointCloudIn &cloud, size_t index, double, std::vector<int> &, std::vector<float> &)> SearchMethodSurface;
+        # public:
+        # inline void setSearchSurface (const cpp.PointCloudPtr_t &)
+        # inline cpp.PointCloudPtr_t getSearchSurface () const
+        void setSearchSurface (const In &)
+        In getSearchSurface () const
+        
+        # inline void setSearchMethod (const KdTreePtr &tree)
+        # void setSearchMethod (pclkdt.KdTreePtr_t tree)
+        # void setSearchMethod (pclkdt.KdTreeFLANNPtr_t tree)
+        # void setSearchMethod (pclkdt.KdTreeFLANNConstPtr_t &tree)
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # inline KdTreePtr getSearchMethod () const
+        # pclkdt.KdTreePtr_t getSearchMethod ()
+        # pclkdt.KdTreeFLANNPtr_t getSearchMethod ()
+        # pclkdt.KdTreeFLANNConstPtr_t getSearchMethod ()
+        
+        double getSearchParameter ()
+        void setKSearch (int search)
+        int getKSearch () const
+        void setRadiusSearch (double radius)
+        double getRadiusSearch ()
+        
+        # void compute (PointCloudOut &output);
+        # void compute (cpp.PointCloudPtr_t output)
+        # void compute (cpp.PointCloud_PointXYZI_Ptr_t output)
+        # void compute (cpp.PointCloud_PointXYZRGB_Ptr_t output)
+        # void compute (cpp.PointCloud_PointXYZRGBA_Ptr_t output)
+        void compute (cpp.PointCloud[Out] &output)
+        
+        # void computeEigen (cpp.PointCloud[Eigen::MatrixXf] &output);
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class FeatureFromNormals : public Feature<PointInT, PointOutT>
+# cdef cppclass FeatureFromNormals(Feature[In, Out]):
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureFromNormals[In, NT, Out](Feature[In, Out]):
+        FeatureFromNormals()
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # ctypedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # ctypedef typename PointCloudN::Ptr PointCloudNPtr;
+        # ctypedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # ctypedef boost::shared_ptr< FeatureFromNormals<PointInT, PointNT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const FeatureFromNormals<PointInT, PointNT, PointOutT> > ConstPtr;
+        # // Members derived from the base class
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of
+        #         * the XYZ dataset.
+        # * In case of search surface is set to be different from the input cloud,
+        # * normals should correspond to the search surface, not the input cloud!
+        # * \param[in] normals the const boost shared pointer to a PointCloud of normals.
+        # * By convention, L2 norm of each normal should be 1.
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        void setInputNormals (cpp.PointCloud_Normal_Ptr_t normals)
+        
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals ()
+
+
+###
+
+# 3dsc.h
+# class ShapeContext3DEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/3dsc.h" namespace "pcl":
+    cdef cppclass ShapeContext3DEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        ShapeContext3DEstimation(bool)
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::searchForNeighbors;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        ##
+        # brief Set the number of bins along the azimuth to \a bins.
+        # param[in] bins the number of bins along the azimuth
+        void setAzimuthBins (size_t bins)
+        # return the number of bins along the azimuth
+        size_t getAzimuthBins () 
+        # brief Set the number of bins along the elevation to \a bins.
+        # param[in] bins the number of bins along the elevation
+        void setElevationBins (size_t )
+        # return The number of bins along the elevation
+        size_t getElevationBins ()
+        # brief Set the number of bins along the radii to \a bins.
+        # param[in] bins the number of bins along the radii
+        void setRadiusBins (size_t )
+        # return The number of bins along the radii direction
+        size_t getRadiusBins ()
+        # brief The minimal radius value for the search sphere (rmin) in the original paper 
+        # param[in] radius the desired minimal radius
+        void setMinimalRadius (double radius)
+        # return The minimal sphere radius
+        double getMinimalRadius ()
+        # brief This radius is used to compute local point density 
+        # density = number of points within this radius
+        # param[in] radius value of the point density search radius
+        void setPointDensityRadius (double radius)
+        # return The point density search radius
+        double getPointDensityRadius ()
+        
+###
+
+# feature.h
+# cdef extern from "pcl/features/feature.h" namespace "pcl":
+#     cdef inline void solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix,
+#                                             const Eigen::Vector4f &point,
+#                                             Eigen::Vector4f &plane_parameters, float &curvature);
+#     cdef inline void solvePlaneParameters (const Eigen::Matrix3f &covariance_matrix,
+#                         float &nx, float &ny, float &nz, float &curvature);
+# template <typename PointInT, typename PointLT, typename PointOutT>
+# class FeatureFromLabels : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureFromLabels[In, LT, Out](Feature[In, Out]):
+        FeatureFromLabels()
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # ctypedef typename PointCloudL::Ptr PointCloudNPtr;
+        # ctypedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # ctypedef boost::shared_ptr< FeatureFromLabels<PointInT, PointLT, PointOutT> > Ptr;
+        # ctypedef boost::shared_ptr< const FeatureFromLabels<PointInT, PointLT, PointOutT> > ConstPtr;
+        # // Members derived from the base class
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::k_;
+        # /** \brief Provide a pointer to the input dataset that contains the point labels of
+        #   * the XYZ dataset.
+        #   * In case of search surface is set to be different from the input cloud,
+        #   * labels should correspond to the search surface, not the input cloud!
+        #   * \param[in] labels the const boost shared pointer to a PointCloud of labels.
+        #   */
+        # inline void setInputLabels (const PointCloudLConstPtr &labels)
+        # inline PointCloudLConstPtr getInputLabels () const
+###
+
+### Inheritance class ###
+
+# > 1.7.2
+# board.h
+# namespace pcl
+# /** \brief BOARDLocalReferenceFrameEstimation implements the BOrder Aware Repeatable Directions algorithm
+# * for local reference frame estimation as described here:
+# *  - A. Petrelli, L. Di Stefano,
+# *    "On the repeatability of the local reference frame for partial shape matching",
+# *    13th International Conference on Computer Vision (ICCV), 2011
+# *
+# * \author Alioscia Petrelli (original), Tommaso Cavallari (PCL port)
+# * \ingroup features
+# */
+# template<typename PointInT, typename PointNT, typename PointOutT = ReferenceFrame>
+# class BOARDLocalReferenceFrameEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/board.h" namespace "pcl":
+    cdef cppclass BOARDLocalReferenceFrameEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        BOARDLocalReferenceFrameEstimation()
+        # public:
+        # typedef boost::shared_ptr<BOARDLocalReferenceFrameEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const BOARDLocalReferenceFrameEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # /** \brief Constructor. */
+        # BOARDLocalReferenceFrameEstimation () :
+        #   tangent_radius_ (0.0f),
+        #   find_holes_ (false),
+        #   margin_thresh_ (0.85f),
+        #   check_margin_array_size_ (24),
+        #   hole_size_prob_thresh_ (0.2f),
+        #   steep_thresh_ (0.1f),
+        #   check_margin_array_ (),
+        #   margin_array_min_angle_ (),
+        #   margin_array_max_angle_ (),
+        #   margin_array_min_angle_normal_ (),
+        #   margin_array_max_angle_normal_ ()
+        # {
+        #   feature_name_ = "BOARDLocalReferenceFrameEstimation";
+        #   setCheckMarginArraySize (check_margin_array_size_);
+        # }
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~BOARDLocalReferenceFrameEstimation () {}
+        # 
+        # //Getters/Setters
+        # /** \brief Set the maximum distance of the points used to estimate the x_axis and y_axis of the BOARD Reference Frame for a given point.
+        #   *
+        #   * \param[in] radius The search radius for x and y axes. If not set or set to 0 the parameter given with setRadiusSearch is used.
+        #   */
+        # inline void setTangentRadius (float radius)
+        # 
+        # /** \brief Get the maximum distance of the points used to estimate the x_axis and y_axis of the BOARD Reference Frame for a given point.
+        #   *
+        #   * \return The search radius for x and y axes. If set to 0 the parameter given with setRadiusSearch is used.
+        #   */
+        # inline float getTangentRadius () const
+        # 
+        # /** \brief Sets whether holes in the margin of the support, for each point, are searched and accounted for in the estimation of the 
+        # *          Reference Frame or not.
+        # *
+        # * \param[in] find_holes Enable/Disable the search for holes in the support.
+        # */
+        # inline void setFindHoles (bool find_holes)
+        # 
+        # /** \brief Gets whether holes in the margin of the support, for each point, are searched and accounted for in the estimation of the 
+        # *          Reference Frame or not.
+        # *
+        # * \return The search for holes in the support is enabled/disabled.
+        # */
+        # inline bool getFindHoles () const
+        # 
+        # /** \brief Sets the percentage of the search radius (or tangent radius if set) after which a point is considered part of the support margin.
+        # *
+        # * \param[in] margin_thresh the percentage of the search radius after which a point is considered a margin point.
+        # */
+        # inline void setMarginThresh (float margin_thresh)
+        # 
+        # /** \brief Gets the percentage of the search radius (or tangent radius if set) after which a point is considered part of the support margin.
+        # *
+        # * \return The percentage of the search radius after which a point is considered a margin point.
+        # */
+        # inline float getMarginThresh () const
+        # 
+        # /** \brief Sets the number of slices in which is divided the margin for the search of missing regions.
+        # *
+        # * \param[in] size the number of margin slices.
+        # */
+        # void setCheckMarginArraySize (int size)
+        # 
+        # /** \brief Gets the number of slices in which is divided the margin for the search of missing regions.
+        # *
+        # * \return the number of margin slices.
+        # */
+        # inline int getCheckMarginArraySize () const
+        # 
+        # /** \brief Given the angle width of a hole in the support margin, sets the minimum percentage of a circumference this angle 
+        # *         must cover to be considered a missing region in the support and hence used for the estimation of the Reference Frame.
+        # * \param[in] prob_thresh the minimum percentage of a circumference after which a hole is considered in the calculation
+        # */
+        # inline void setHoleSizeProbThresh (float prob_thresh)
+        # 
+        # /** \brief Given the angle width of a hole in the support margin, gets the minimum percentage of a circumference this angle 
+        # *         must cover to be considered a missing region in the support and hence used for the estimation of the Reference Frame.
+        # * \return the minimum percentage of a circumference after which a hole is considered in the calculation
+        # */
+        # inline float getHoleSizeProbThresh () const
+        # 
+        # /** \brief Sets the minimum steepness that the normals of the points situated on the borders of the hole, with reference
+        # *         to the normal of the best point found by the algorithm, must have in order to be considered in the calculation of the Reference Frame.
+        # * \param[in] steep_thresh threshold that defines if a missing region contains a point with the most different normal.
+        # */
+        # inline void setSteepThresh (float steep_thresh)
+        # 
+        # /** \brief Gets the minimum steepness that the normals of the points situated on the borders of the hole, with reference
+        # *         to the normal of the best point found by the algorithm, must have in order to be considered in the calculation of the Reference Frame.
+        # * \return threshold that defines if a missing region contains a point with the most different normal.
+        # */
+        # inline float getSteepThresh () const
+
+
+###
+
+# cppf.h
+# namespace pcl
+#   /** \brief
+#     * \param[in] p1 
+#     * \param[in] n1
+#     * \param[in] p2 
+#     * \param[in] n2
+#     * \param[in] c1
+#     * \param[in] c2
+#     * \param[out] f1
+#     * \param[out] f2
+#     * \param[out] f3
+#     * \param[out] f4
+#     * \param[out] f5
+#     * \param[out] f6
+#     * \param[out] f7
+#     * \param[out] f8
+#     * \param[out] f9
+#     * \param[out] f10
+#     */
+#   computeCPPFPairFeature (const Eigen::Vector4f &p1, const Eigen::Vector4f &n1, const Eigen::Vector4i &c1,
+#                             const Eigen::Vector4f &p2, const Eigen::Vector4f &n2, const Eigen::Vector4i &c2,
+#                             float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7, float &f8, float &f9, float &f10);
+# 
+##
+# cppf.h
+# namespace pcl
+# /** \brief Class that calculates the "surflet" features for each pair in the given
+# * pointcloud. Please refer to the following publication for more details:
+# *    C. Choi, Henrik Christensen
+# *    3D Pose Estimation of Daily Objects Using an RGB-D Camera
+# *    Proceedings of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)
+# *    2012
+# *
+# * PointOutT is meant to be pcl::CPPFSignature - contains the 10 values of the Surflet
+# * feature and in addition, alpha_m for the respective pair - optimization proposed by
+# * the authors (see above)
+# *
+# * \author Martin Szarski, Alexandru-Eugen Ichim
+# */
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class CPPFEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/cppf.h" namespace "pcl":
+    cdef cppclass CPPFEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        CPPFEstimation()
+        # public:
+        # typedef boost::shared_ptr<CPPFEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const CPPFEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # 
+        # /** \brief Empty Constructor. */
+        # CPPFEstimation ();
+
+
+###
+
+# crh.h
+# namespace pcl
+# /** \brief CRHEstimation estimates the Camera Roll Histogram (CRH) descriptor for a given
+# * point cloud dataset containing XYZ data and normals, as presented in:
+# *   - CAD-Model Recognition and 6 DOF Pose Estimation
+# *     A. Aldoma, N. Blodow, D. Gossow, S. Gedikli, R.B. Rusu, M. Vincze and G. Bradski
+# *     ICCV 2011, 3D Representation and Recognition (3dRR11) workshop
+# *     Barcelona, Spain, (2011)
+# *
+# * The suggested PointOutT is pcl::Histogram<90>. //dc (real) + 44 complex numbers (real, imaginary) + nyquist (real)
+# *
+# * \author Aitor Aldoma
+# * \ingroup features
+# */
+# template<typename PointInT, typename PointNT, typename PointOutT = pcl::Histogram<90> >
+# class CRHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/crh.h" namespace "pcl":
+    cdef cppclass CRHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        CRHEstimation()
+        # public:
+        # typedef boost::shared_ptr<CRHEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const CRHEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # 
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # 
+        # /** \brief Constructor. */
+        # CRHEstimation () : vpx_ (0), vpy_ (0), vpz_ (0), nbins_ (90)
+        # 
+        # /** \brief Set the viewpoint.
+        # * \param[in] vpx the X coordinate of the viewpoint
+        # * \param[in] vpy the Y coordinate of the viewpoint
+        # * \param[in] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # /** \brief Get the viewpoint. 
+        # * \param[out] vpx the X coordinate of the viewpoint
+        # * \param[out] vpy the Y coordinate of the viewpoint
+        # * \param[out] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        # inline void setCentroid (Eigen::Vector4f & centroid)
+
+
+###
+
+# don.h
+# namespace pcl
+# /** \brief A Difference of Normals (DoN) scale filter implementation for point cloud data.
+# * For each point in the point cloud two normals estimated with a differing search radius (sigma_s, sigma_l)
+# * are subtracted, the difference of these normals provides a scale-based feature which
+# * can be further used to filter the point cloud, somewhat like the Difference of Guassians
+# * in image processing, but instead on surfaces. Best results are had when the two search
+# * radii are related as sigma_l=10*sigma_s, the octaves between the two search radii
+# * can be though of as a filter bandwidth. For appropriate values and thresholds it
+# * can be used for surface edge extraction.
+# * \attention The input normals given by setInputNormalsSmall and setInputNormalsLarge have
+# * to match the input point cloud given by setInputCloud. This behavior is different than
+# * feature estimation methods that extend FeatureFromNormals, which match the normals
+# * with the search surface.
+# * \note For more information please see
+# *    <b>Yani Ioannou. Automatic Urban Modelling using Mobile Urban LIDAR Data.
+# *    Thesis (Master, Computing), Queen's University, March, 2010.</b>
+# * \author Yani Ioannou.
+# * \ingroup features
+# */
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class DifferenceOfNormalsEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/don.h" namespace "pcl":
+    cdef cppclass DifferenceOfNormalsEstimation[In, NT, Out](Feature[In, Out]):
+        DifferenceOfNormalsEstimation()
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using PCLBase<PointInT>::input_;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # typedef boost::shared_ptr<DifferenceOfNormalsEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const DifferenceOfNormalsEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # /**
+        # * Creates a new Difference of Normals filter.
+        # */
+        # DifferenceOfNormalsEstimation ()
+        # virtual ~DifferenceOfNormalsEstimation ()
+        # 
+        # /**
+        # * Set the normals calculated using a smaller search radius (scale) for the DoN operator.
+        # * @param normals the smaller radius (scale) of the DoN filter.
+        # */
+        # inline void setNormalScaleSmall (const PointCloudNConstPtr &normals)
+        # 
+        # /**
+        # * Set the normals calculated using a larger search radius (scale) for the DoN operator.
+        # * @param normals the larger radius (scale) of the DoN filter.
+        # */
+        # inline void setNormalScaleLarge (const PointCloudNConstPtr &normals)
+        # 
+        # /**
+        # * Computes the DoN vector for each point in the input point cloud and outputs the vector cloud to the given output.
+        # * @param output the cloud to output the DoN vector cloud to.
+        # */
+        # virtual void computeFeature (PointCloudOut &output);
+        # 
+        # /**
+        # * Initialize for computation of features.
+        # * @return true if parameters (input normals, input) are sufficient to perform computation.
+        # */
+        # virtual bool initCompute ();
+
+
+###
+
+# gfpfh.h
+# namespace pcl
+# /** \brief @b GFPFHEstimation estimates the Global Fast Point Feature Histogram (GFPFH) descriptor for a given point
+#   * cloud dataset containing points and labels.
+#   * @note If you use this code in any academic work, please cite:
+#   * <ul>
+#   * <li> R.B. Rusu, A. Holzbach, M. Beetz.
+#   *      Detecting and Segmenting Objects for Mobile Manipulation.
+#   *      In the S3DV Workshop of the 12th International Conference on Computer Vision (ICCV),
+#   *      2009.
+#   * </li>
+#   * </ul>
+#   * \author Radu B. Rusu
+#   * \ingroup features
+#   */
+# template <typename PointInT, typename PointLT, typename PointOutT>
+# class GFPFHEstimation : public FeatureFromLabels<PointInT, PointLT, PointOutT>
+cdef extern from "pcl/features/gfpfh.h" namespace "pcl":
+    cdef cppclass GFPFHEstimation[In, LT, Out](FeatureFromLabels[In, LT, Out]):
+        DifferenceOfNormalsEstimation()
+        # public:
+        # typedef boost::shared_ptr<GFPFHEstimation<PointInT, PointLT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const GFPFHEstimation<PointInT, PointLT, PointOutT> > ConstPtr;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::feature_name_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::getClassName;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::indices_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::k_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::search_parameter_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::surface_;
+        # 
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::input_;
+        # using FeatureFromLabels<PointInT, PointLT, PointOutT>::labels_;
+        # 
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # 
+        # /** \brief Empty constructor. */
+        # GFPFHEstimation () : octree_leaf_size_ (0.01), number_of_classes_ (16), descriptor_size_ (PointOutT::descriptorSize ())
+        # 
+        # /** \brief Set the size of the octree leaves.
+        #   */
+        # inline void setOctreeLeafSize (double size)
+        # 
+        # /** \brief Get the sphere radius used for determining the neighbors. */
+        # inline double getOctreeLeafSize ()
+        # 
+        # /** \brief Return the empty label value. */
+        # inline uint32_t emptyLabel () const
+        # 
+        # /** \brief Return the number of different classes. */
+        # inline uint32_t getNumberOfClasses () const
+        # 
+        # /** \brief Set the number of different classes.
+        #  * \param n number of different classes.
+        #  */
+        # inline void setNumberOfClasses (uint32_t n)
+        # 
+        # /** \brief Return the size of the descriptor. */
+        # inline int descriptorSize () const
+        # 
+        # /** \brief Overloaded computed method from pcl::Feature.
+        #   * \param[out] output the resultant point cloud model dataset containing the estimated features
+        #   */
+        # void compute (PointCloudOut &output);
+
+
+###
+
+# linear_least_squares_normal.h
+# namespace pcl
+# /** \brief Surface normal estimation on dense data using a least-squares estimation based on a first-order Taylor approximation.
+# * \author Stefan Holzer, Cedric Cagniart
+# */
+# template <typename PointInT, typename PointOutT>
+# class LinearLeastSquaresNormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/linear_least_squares_normal.h" namespace "pcl":
+    cdef cppclass LinearLeastSquaresNormalEstimation[In, Out](Feature[In, Out]):
+        LinearLeastSquaresNormalEstimation()
+        # public:
+        # typedef boost::shared_ptr<LinearLeastSquaresNormalEstimation<PointInT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const LinearLeastSquaresNormalEstimation<PointInT, PointOutT> > ConstPtr;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # 
+        # /** \brief Constructor */
+        # LinearLeastSquaresNormalEstimation () :
+        #   use_depth_dependent_smoothing_(false),
+        #   max_depth_change_factor_(1.0f),
+        #   normal_smoothing_size_(9.0f)
+        # 
+        # /** \brief Destructor */
+        # virtual ~LinearLeastSquaresNormalEstimation ();
+        # 
+        # /** \brief Computes the normal at the specified position. 
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[out] normal the output estimated normal 
+        # */
+        # void computePointNormal (const int pos_x, const int pos_y, PointOutT &normal)
+        # 
+        # /** \brief Set the normal smoothing size
+        # * \param[in] normal_smoothing_size factor which influences the size of the area used to smooth normals 
+        # * (depth dependent if useDepthDependentSmoothing is true)
+        # */
+        # void setNormalSmoothingSize (float normal_smoothing_size)
+        # 
+        # /** \brief Set whether to use depth depending smoothing or not
+        #  * \param[in] use_depth_dependent_smoothing decides whether the smoothing is depth dependent
+        #  */
+        # void setDepthDependentSmoothing (bool use_depth_dependent_smoothing)
+        # 
+        # /** \brief The depth change threshold for computing object borders
+        #  * \param[in] max_depth_change_factor the depth change threshold for computing object borders based on 
+        #  * depth changes
+        #  */
+        # void setMaxDepthChangeFactor (float max_depth_change_factor)
+        # 
+        # /** \brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # virtual inline void setInputCloud (const typename PointCloudIn::ConstPtr &cloud) 
+
+
+###
+
+# moment_of_inertia_estimation.h
+# namespace pcl
+# /** 
+#   * Implements the method for extracting features based on moment of inertia.
+#   * It also calculates AABB, OBB and eccentricity of the projected cloud.
+#   */
+# template <typename PointT>
+# class PCL_EXPORTS MomentOfInertiaEstimation : public pcl::PCLBase <PointT>
+cdef extern from "pcl/features/moment_of_inertia_estimation.h" namespace "pcl":
+    cdef cppclass MomentOfInertiaEstimation[PointT](cpp.PCLBase[PointT]):
+        MomentOfInertiaEstimation()
+        # /** \brief Constructor that sets default values for member variables. */
+        # MomentOfInertiaEstimation ();
+        # public:
+        # typedef typename pcl::PCLBase <PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PCLBase <PointT>::PointIndicesConstPtr PointIndicesConstPtr;
+        # public:
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        void setInputCloud (const cpp.PCLBase[PointT]& cloud)
+        
+        # \brief Provide a pointer to the vector of indices that represents the input data.
+        # \param[in] indices a pointer to the vector of indices that represents the input data.
+        # virtual void setIndices (const IndicesPtr& indices);
+        # void setIndices (const IndicesPtr& indices)
+        
+        # /** \brief Provide a pointer to the vector of indices that represents the input data.
+        # * \param[in] indices a pointer to the vector of indices that represents the input data.
+        # */
+        # void setIndices (const IndicesConstPtr& indices)
+        
+        # /** \brief Provide a pointer to the vector of indices that represents the input data.
+        # * \param[in] indices a pointer to the vector of indices that represents the input data.
+        # */
+        # virtual void setIndices (const PointIndicesConstPtr& indices);
+        # void setIndices (const PointIndicesConstPtr& indices)
+        
+        # /** \brief Set the indices for the points laying within an interest region of 
+        #   * the point cloud.
+        #   * \note you shouldn't call this method on unorganized point clouds!
+        #   * \param[in] row_start the offset on rows
+        #   * \param[in] col_start the offset on columns
+        #   * \param[in] nb_rows the number of rows to be considered row_start included
+        #   * \param[in] nb_cols the number of columns to be considered col_start included
+        #   */
+        # virtual void setIndices (size_t row_start, size_t col_start, size_t nb_rows, size_t nb_cols);
+        void setIndices (size_t row_start, size_t col_start, size_t nb_rows, size_t nb_cols)
+        
+        # /** \brief This method allows to set the angle step. It is used for the rotation
+        # * of the axis which is used for moment of inertia/eccentricity calculation.
+        # * \param[in] step angle step
+        # */
+        # void setAngleStep (const float step);
+        void setAngleStep (const float step)
+        
+        # /** \brief Returns the angle step. */
+        # float getAngleStep () const;
+        float getAngleStep ()
+        
+        # /** \brief This method allows to set the normalize_ flag. If set to false, then
+        # * point_mass_ will be used to scale the moment of inertia values. Otherwise,
+        # * point_mass_ will be set to 1 / number_of_points. Default value is true.
+        # * \param[in] need_to_normalize desired value
+        # */
+        # void setNormalizePointMassFlag (bool need_to_normalize);
+        void setNormalizePointMassFlag (bool need_to_normalize)
+        
+        # /** \brief Returns the normalize_ flag. */
+        # bool getNormalizePointMassFlag () const;
+        bool getNormalizePointMassFlag ()
+        
+        # /** \brief This method allows to set point mass that will be used for
+        # * moment of inertia calculation. It is needed to scale moment of inertia values.
+        # * default value is 0.0001.
+        # * \param[in] point_mass point mass
+        # */
+        # void setPointMass (const float point_mass);
+        void setPointMass (const float point_mass)
+        
+        # /** \brief Returns the mass of point. */
+        # float getPointMass () const;
+        float getPointMass ()
+        
+        # /** \brief This method launches the computation of all features. After execution
+        # * it sets is_valid_ flag to true and each feature can be accessed with the
+        # * corresponding get method.
+        # */
+        # void compute ();
+        void compute ()
+        
+        # 
+        # /** \brief This method gives access to the computed axis aligned bounding box. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] min_point min point of the AABB
+        # * \param[out] max_point max point of the AABB
+        # */
+        # bool getAABB (PointT& min_point, PointT& max_point) const;
+        bool getAABB (PointT& min_point, PointT& max_point)
+        
+        # /** \brief This method gives access to the computed oriented bounding box. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * Note that in order to get the OBB, each vertex of the given AABB (specified with min_point and max_point)
+        # * must be rotated with the given rotational matrix (rotation transform) and then positioned.
+        # * Also pay attention to the fact that this is not the minimal possible bounding box. This is the bounding box
+        # * which is oriented in accordance with the eigen vectors.
+        # * \param[out] min_point min point of the OBB
+        # * \param[out] max_point max point of the OBB
+        # * \param[out] position position of the OBB
+        # * \param[out] rotational_matrix this matrix represents the rotation transform
+        # */
+        # bool getOBB (PointT& min_point, PointT& max_point, PointT& position, Eigen::Matrix3f& rotational_matrix) const;
+        bool getOBB (PointT& min_point, PointT& max_point, PointT& position, eigen3.Matrix3f& rotational_matrix)
+        
+        # /** \brief This method gives access to the computed eigen values. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] major major eigen value
+        # * \param[out] middle middle eigen value
+        # * \param[out] minor minor eigen value
+        # */
+        # bool getEigenValues (float& major, float& middle, float& minor) const;
+        bool getEigenValues (float& major, float& middle, float& minor)
+        
+        # /** \brief This method gives access to the computed eigen vectors. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] major axis which corresponds to the eigen vector with the major eigen value
+        # * \param[out] middle axis which corresponds to the eigen vector with the middle eigen value
+        # * \param[out] minor axis which corresponds to the eigen vector with the minor eigen value
+        # */
+        # bool getEigenVectors (Eigen::Vector3f& major, Eigen::Vector3f& middle, Eigen::Vector3f& minor) const;
+        bool getEigenVectors (eigen3.Vector3f& major, eigen3.Vector3f& middle, eigen3.Vector3f& minor)
+        
+        # /** \brief This method gives access to the computed moments of inertia. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] moment_of_inertia computed moments of inertia
+        # */
+        # bool getMomentOfInertia (std::vector <float>& moment_of_inertia) const;
+        bool getMomentOfInertia (vector [float]& moment_of_inertia)
+        
+        # /** \brief This method gives access to the computed ecentricities. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * \param[out] eccentricity computed eccentricities
+        # */
+        # bool getEccentricity (std::vector <float>& eccentricity) const;
+        bool getEccentricity (vector [float]& eccentricity)
+        
+        # /** \brief This method gives access to the computed mass center. It returns true
+        # * if the current values (eccentricity, moment of inertia etc) are valid and false otherwise.
+        # * Note that when mass center of a cloud is computed, mass point is always considered equal 1.
+        # * \param[out] mass_center computed mass center
+        # */
+        # bool getMassCenter (Eigen::Vector3f& mass_center) const;
+        bool getMassCenter (eigen3.Vector3f& mass_center)
+
+
+ctypedef MomentOfInertiaEstimation[cpp.PointXYZ] MomentOfInertiaEstimation_t
+ctypedef MomentOfInertiaEstimation[cpp.PointXYZI] MomentOfInertiaEstimation_PointXYZI_t
+ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGB] MomentOfInertiaEstimation_PointXYZRGB_t
+ctypedef MomentOfInertiaEstimation[cpp.PointXYZRGBA] MomentOfInertiaEstimation_PointXYZRGBA_t
+ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZ]] MomentOfInertiaEstimationPtr_t
+ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZI]] MomentOfInertiaEstimation_PointXYZI_Ptr_t
+ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGB]] MomentOfInertiaEstimation_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[MomentOfInertiaEstimation[cpp.PointXYZRGBA]] MomentOfInertiaEstimation_PointXYZRGBA_Ptr_t
+###
+
+# our_cvfh.h
+# namespace pcl
+# /** \brief OURCVFHEstimation estimates the Oriented, Unique and Repetable Clustered Viewpoint Feature Histogram (CVFH) descriptor for a given
+#  * point cloud dataset given XYZ data and normals, as presented in:
+#  *     - OUR-CVFH Oriented, Unique and Repeatable Clustered Viewpoint Feature Histogram for Object Recognition and 6DOF Pose Estimation
+#  *     A. Aldoma, F. Tombari, R.B. Rusu and M. Vincze
+#  *     DAGM-OAGM 2012
+#  *     Graz, Austria
+#  * The suggested PointOutT is pcl::VFHSignature308.
+#  * \author Aitor Aldoma
+#  * \ingroup features
+#  */
+# template<typename PointInT, typename PointNT, typename PointOutT = pcl::VFHSignature308>
+# class OURCVFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/our_cvfh.h" namespace "pcl":
+    cdef cppclass OURCVFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        OURCVFHEstimation()
+        # public:
+        # typedef boost::shared_ptr<OURCVFHEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef boost::shared_ptr<const OURCVFHEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # 
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::search::Search<PointNormal>::Ptr KdTreePtr;
+        # typedef typename pcl::PointCloud<PointInT>::Ptr PointInTPtr;
+        # /** \brief Empty constructor. */
+        # OURCVFHEstimation () :
+        # vpx_ (0), vpy_ (0), vpz_ (0), leaf_size_ (0.005f), normalize_bins_ (false), curv_threshold_ (0.03f), cluster_tolerance_ (leaf_size_ * 3),
+        #     eps_angle_threshold_ (0.125f), min_points_ (50), radius_normals_ (leaf_size_ * 3), centroids_dominant_orientations_ (),
+        #     dominant_normals_ ()
+        # 
+        # /** \brief Creates an affine transformation from the RF axes
+        # * \param[in] evx the x-axis
+        # * \param[in] evy the y-axis
+        # * \param[in] evz the z-axis
+        # * \param[out] transformPC the resulting transformation
+        # * \param[in] center_mat 4x4 matrix concatenated to the resulting transformation
+        # */
+        # inline Eigen::Matrix4f createTransFromAxes (Eigen::Vector3f & evx, Eigen::Vector3f & evy, Eigen::Vector3f & evz, Eigen::Affine3f & transformPC, Eigen::Matrix4f & center_mat)
+        # 
+        # /** \brief Computes SGURF and the shape distribution based on the selected SGURF
+        # * \param[in] processed the input cloud
+        # * \param[out] output the resulting signature
+        # * \param[in] cluster_indices the indices of the stable cluster
+        # */
+        # void computeRFAndShapeDistribution (PointInTPtr & processed, PointCloudOut &output, std::vector<pcl::PointIndices> & cluster_indices);
+        # 
+        # /** \brief Computes SGURF
+        # * \param[in] centroid the centroid of the cluster
+        # * \param[in] normal_centroid the average of the normals
+        # * \param[in] processed the input cloud
+        # * \param[out] transformations the transformations aligning the cloud to the SGURF axes
+        # * \param[out] grid the cloud transformed internally
+        # * \param[in] indices the indices of the stable cluster
+        # */
+        # bool sgurf (Eigen::Vector3f & centroid, Eigen::Vector3f & normal_centroid, PointInTPtr & processed, std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > & transformations, PointInTPtr & grid, pcl::PointIndices & indices);
+        # 
+        # /** \brief Removes normals with high curvature caused by real edges or noisy data
+        # * \param[in] cloud pointcloud to be filtered
+        # * \param[in] indices_to_use
+        # * \param[out] indices_out the indices of the points with higher curvature than threshold
+        # * \param[out] indices_in the indices of the remaining points after filtering
+        # * \param[in] threshold threshold value for curvature
+        # */
+        # void filterNormalsWithHighCurvature (const pcl::PointCloud<PointNT> & cloud, std::vector<int> & indices_to_use, std::vector<int> &indices_out, std::vector<int> &indices_in, float threshold);
+        # 
+        # /** \brief Set the viewpoint.
+        # * \param[in] vpx the X coordinate of the viewpoint
+        # * \param[in] vpy the Y coordinate of the viewpoint
+        # * \param[in] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # /** \brief Set the radius used to compute normals
+        # * \param[in] radius_normals the radius
+        # */
+        # inline void setRadiusNormals (float radius_normals)
+        # 
+        # /** \brief Get the viewpoint. 
+        # * \param[out] vpx the X coordinate of the viewpoint
+        # * \param[out] vpy the Y coordinate of the viewpoint
+        # * \param[out] vpz the Z coordinate of the viewpoint
+        # */
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        # 
+        # /** \brief Get the centroids used to compute different CVFH descriptors
+        # * \param[out] centroids vector to hold the centroids
+        # */
+        # inline void getCentroidClusters (std::vector<Eigen::Vector3f> & centroids)
+        # 
+        # /** \brief Get the normal centroids used to compute different CVFH descriptors
+        # * \param[out] centroids vector to hold the normal centroids
+        # */
+        # inline void getCentroidNormalClusters (std::vector<Eigen::Vector3f> & centroids)
+        # 
+        # /** \brief Sets max. Euclidean distance between points to be added to the cluster 
+        # * \param[in] d the maximum Euclidean distance
+        # */
+        # inline void setClusterTolerance (float d)
+        # 
+        # /** \brief Sets max. deviation of the normals between two points so they can be clustered together
+        # * \param[in] d the maximum deviation
+        # */
+        # inline void setEPSAngleThreshold (float d)
+        # 
+        # /** \brief Sets curvature threshold for removing normals
+        # * \param[in] d the curvature threshold
+        # */
+        # inline void setCurvatureThreshold (float d)
+        # 
+        # /** \brief Set minimum amount of points for a cluster to be considered
+        # * \param[in] min the minimum amount of points to be set
+        # */
+        # inline void setMinPoints (size_t min)
+        # 
+        # /** \brief Sets wether if the signatures should be normalized or not
+        # * \param[in] normalize true if normalization is required, false otherwise
+        # */
+        # inline void setNormalizeBins (bool normalize)
+        # 
+        # /** \brief Gets the indices of the original point cloud used to compute the signatures
+        # * \param[out] indices vector of point indices
+        # */
+        # inline void getClusterIndices (std::vector<pcl::PointIndices> & indices)
+        # 
+        # /** \brief Gets the number of non-disambiguable axes that correspond to each centroid
+        # * \param[out] cluster_axes vector mapping each centroid to the number of signatures
+        # */
+        # inline void getClusterAxes (std::vector<short> & cluster_axes)
+        # 
+        # /** \brief Sets the refinement factor for the clusters
+        # * \param[in] rc the factor used to decide if a point is used to estimate a stable cluster
+        # */
+        # void setRefineClusters (float rc)
+        # 
+        # /** \brief Returns the transformations aligning the point cloud to the corresponding SGURF
+        # * \param[out] trans vector of transformations
+        # */
+        # void getTransforms (std::vector<Eigen::Matrix4f, Eigen::aligned_allocator<Eigen::Matrix4f> > & trans)
+        # 
+        # /** \brief Returns a boolean vector indicating of the transformation obtained by getTransforms() represents
+        # * a valid SGURF
+        # * \param[out] valid vector of booleans
+        # */
+        # void getValidTransformsVec (std::vector<bool> & valid)
+        # 
+        # /** \brief Sets the min axis ratio between the SGURF axes to decide if disambiguition is feasible
+        # * \param[in] f the ratio between axes
+        # */
+        # void setAxisRatio (float f)
+        # 
+        # /** \brief Sets the min disambiguition axis value to generate several SGURFs for the cluster when disambiguition is difficult
+        # * \param[in] f the min axis value
+        # */
+        # void setMinAxisValue (float f)
+        # 
+        # /** \brief Overloaded computed method from pcl::Feature.
+        # * \param[out] output the resultant point cloud model dataset containing the estimated features
+        # */
+        # void compute (PointCloudOut &output);
+
+
+####
+
+# pfh_tools.h
+# namespace pcl
+#   /** \brief Compute the 4-tuple representation containing the three angles and one distance between two points
+#     * represented by Cartesian coordinates and normals.
+#     * \note For explanations about the features, please see the literature mentioned above (the order of the
+#     * features might be different).
+#     * \param[in] p1 the first XYZ point
+#     * \param[in] n1 the first surface normal
+#     * \param[in] p2 the second XYZ point
+#     * \param[in] n2 the second surface normal
+#     * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+#     * \param[out] f2 the second angular feature (angle between nq_idx and v)
+#     * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+#     * \param[out] f4 the distance feature (p_idx - q_idx)
+#     *
+#     * \note For efficiency reasons, we assume that the point data passed to the method is finite.
+#     * \ingroup features
+#     */
+#   PCL_EXPORTS bool 
+#   computePairFeatures (const Eigen::Vector4f &p1, const Eigen::Vector4f &n1, 
+#                        const Eigen::Vector4f &p2, const Eigen::Vector4f &n2, 
+#                        float &f1, float &f2, float &f3, float &f4);
+# 
+#   PCL_EXPORTS bool
+#   computeRGBPairFeatures (const Eigen::Vector4f &p1, const Eigen::Vector4f &n1, const Eigen::Vector4i &colors1,
+#                           const Eigen::Vector4f &p2, const Eigen::Vector4f &n2, const Eigen::Vector4i &colors2,
+#                           float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7);
+# 
+###
+
+# rops_estimation.h
+# namespace pcl
+# /** \brief
+# * This class implements the method for extracting RoPS features presented in the article
+# * "Rotational Projection Statistics for 3D Local Surface Description and Object Recognition" by
+# * Yulan Guo, Ferdous Sohel, Mohammed Bennamoun, Min Lu and Jianwei Wan.
+# */
+# template <typename PointInT, typename PointOutT>
+# class PCL_EXPORTS ROPSEstimation : public pcl::Feature <PointInT, PointOutT>
+cdef extern from "pcl/features/rops_estimation.h" namespace "pcl":
+    cdef cppclass ROPSEstimation[In, Out](Feature[In, Out]):
+        ROPSEstimation()
+        # public:
+        # using Feature <PointInT, PointOutT>::input_;
+        # using Feature <PointInT, PointOutT>::indices_;
+        # using Feature <PointInT, PointOutT>::surface_;
+        # using Feature <PointInT, PointOutT>::tree_;
+        # typedef typename pcl::Feature <PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::Feature <PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # public:
+        # /** \brief Simple constructor. */
+        # ROPSEstimation ();
+        # 
+        # /** \brief Virtual destructor. */
+        # virtual ~ROPSEstimation ();
+        # 
+        # /** \brief Allows to set the number of partition bins that is used for distribution matrix calculation.
+        # * \param[in] number_of_bins number of partition bins
+        # */
+        # void setNumberOfPartitionBins (unsigned int number_of_bins);
+        # 
+        # /** \brief Returns the nmber of partition bins. */
+        # unsigned int getNumberOfPartitionBins () const;
+        # 
+        # /** \brief This method sets the number of rotations.
+        # * \param[in] number_of_rotations number of rotations
+        # */
+        # void setNumberOfRotations (unsigned int number_of_rotations);
+        # 
+        # /** \brief returns the number of rotations. */
+        # unsigned int getNumberOfRotations () const;
+        # 
+        # /** \brief Allows to set the support radius that is used to crop the local surface of the point.
+        # * \param[in] support_radius support radius
+        # */
+        # void setSupportRadius (float support_radius);
+        # 
+        # /** \brief Returns the support radius. */
+        # float getSupportRadius () const;
+        # 
+        # /** \brief This method sets the triangles of the mesh.
+        # * \param[in] triangles list of triangles of the mesh
+        # */
+        # void setTriangles (const std::vector <pcl::Vertices>& triangles);
+        # 
+        # /** \brief Returns the triangles of the mesh.
+        # * \param[out] triangles triangles of tthe mesh
+        # */
+        # void getTriangles (std::vector <pcl::Vertices>& triangles) const;
+
+
+###
+
+# rsd.h
+# namespace pcl
+#   /** \brief Transform a list of 2D matrices into a point cloud containing the values in a vector (Histogram<N>).
+#     * Can be used to transform the 2D histograms obtained in \ref RSDEstimation into a point cloud.
+#     * @note The template paramter N should be (greater or) equal to the product of the number of rows and columns.
+#     * \param[in] histograms2D the list of neighborhood 2D histograms
+#     * \param[out] histogramsPC the dataset containing the linearized matrices
+#     * \ingroup features
+#     */
+#   template <int N> void getFeaturePointCloud (const std::vector<Eigen::MatrixXf, Eigen::aligned_allocator<Eigen::MatrixXf> > &histograms2D, PointCloud<Histogram<N> > &histogramsPC)
+# 
+#   /** \brief Estimate the Radius-based Surface Descriptor (RSD) for a given point based on its spatial neighborhood of 3D points with normals
+#     * \param[in] surface the dataset containing the XYZ points
+#     * \param[in] normals the dataset containing the surface normals at each point in the dataset
+#     * \param[in] indices the neighborhood point indices in the dataset (first point is used as the reference)
+#     * \param[in] max_dist the upper bound for the considered distance interval
+#     * \param[in] nr_subdiv the number of subdivisions for the considered distance interval
+#     * \param[in] plane_radius maximum radius, above which everything can be considered planar
+#     * \param[in] radii the output point of a type that should have r_min and r_max fields
+#     * \param[in] compute_histogram if not false, the full neighborhood histogram is provided, usable as a point signature
+#     * \ingroup features
+#     */
+#   template <typename PointInT, typename PointNT, typename PointOutT> Eigen::MatrixXf
+#   computeRSD (boost::shared_ptr<const pcl::PointCloud<PointInT> > &surface, boost::shared_ptr<const pcl::PointCloud<PointNT> > &normals,
+#              const std::vector<int> &indices, double max_dist,
+#              int nr_subdiv, double plane_radius, PointOutT &radii, bool compute_histogram = false);
+# 
+#   /** \brief Estimate the Radius-based Surface Descriptor (RSD) for a given point based on its spatial neighborhood of 3D points with normals
+#     * \param[in] normals the dataset containing the surface normals at each point in the dataset
+#     * \param[in] indices the neighborhood point indices in the dataset (first point is used as the reference)
+#     * \param[in] sqr_dists the squared distances from the first to all points in the neighborhood
+#     * \param[in] max_dist the upper bound for the considered distance interval
+#     * \param[in] nr_subdiv the number of subdivisions for the considered distance interval
+#     * \param[in] plane_radius maximum radius, above which everything can be considered planar
+#     * \param[in] radii the output point of a type that should have r_min and r_max fields
+#     * \param[in] compute_histogram if not false, the full neighborhood histogram is provided, usable as a point signature
+#     * \ingroup features
+#     */
+#   template <typename PointNT, typename PointOutT> Eigen::MatrixXf
+#   computeRSD (boost::shared_ptr<const pcl::PointCloud<PointNT> > &normals,
+#              const std::vector<int> &indices, const std::vector<float> &sqr_dists, double max_dist,
+#              int nr_subdiv, double plane_radius, PointOutT &radii, bool compute_histogram = false);
+# 
+##
+# rsd.h
+# namespace pcl
+# /** \brief @b RSDEstimation estimates the Radius-based Surface Descriptor (minimal and maximal radius of the local surface's curves)
+# * for a given point cloud dataset containing points and normals.
+# *
+# * @note If you use this code in any academic work, please cite:
+# *
+# * <ul>
+# * <li> Z.C. Marton , D. Pangercic , N. Blodow , J. Kleinehellefort, M. Beetz
+# *      General 3D Modelling of Novel Objects from a Single View
+# *      In Proceedings of the 2010 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)
+# *      Taipei, Taiwan, October 18-22, 2010
+# * </li>
+# * <li> Z.C. Marton, D. Pangercic, N. Blodow, Michael Beetz.
+# *      Combined 2D-3D Categorization and Classification for Multimodal Perception Systems.
+# *      In The International Journal of Robotics Research, Sage Publications
+# *      pages 1378--1402, Volume 30, Number 11, September 2011.
+# * </li>
+# * </ul>
+# *
+# * @note The code is stateful as we do not expect this class to be multicore parallelized.
+# * \author Zoltan-Csaba Marton
+# * \ingroup features
+# */
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class RSDEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+# Note : Travis CI error (not found rsd.h)
+# cdef extern from "pcl/features/rsd.h" namespace "pcl":
+#     cdef cppclass RSDEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+#         RSDEstimation()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # typedef typename boost::shared_ptr<RSDEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const RSDEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # RSDEstimation () : nr_subdiv_ (5), plane_radius_ (0.2), save_histograms_ (false)
+        # 
+        # /** \brief Set the number of subdivisions for the considered distance interval.
+        #  * \param[in] nr_subdiv the number of subdivisions
+        #  */
+        # inline void setNrSubdivisions (int nr_subdiv)
+        # 
+        # /** \brief Get the number of subdivisions for the considered distance interval. */
+        # inline int getNrSubdivisions () const
+        # 
+        # /** \brief Set the maximum radius, above which everything can be considered planar.
+        # * \note the order of magnitude should be around 10-20 times the search radius (0.2 works well for typical datasets).
+        # * \note on accurate 3D data (e.g. openni sernsors) a search radius as low as 0.01 still gives good results.
+        # * \param[in] plane_radius the new plane radius
+        # */
+        # inline void setPlaneRadius (double plane_radius)
+        # 
+        # /** \brief Get the maximum radius, above which everything can be considered planar. */
+        # inline double getPlaneRadius () const
+        # 
+        # /** \brief Disables the setting of the number of k nearest neighbors to use for the feature estimation. */
+        # inline void setKSearch (int) 
+        # 
+        # /** \brief Set whether the full distance-angle histograms should be saved.
+        # * @note Obtain the list of histograms by getHistograms ()
+        # * \param[in] save set to true if histograms should be saved
+        # */
+        # inline void setSaveHistograms (bool save)
+        # 
+        # /** \brief Returns whether the full distance-angle histograms are being saved. */
+        # inline bool getSaveHistograms () const
+        # 
+        # /** \brief Returns a pointer to the list of full distance-angle histograms for all points. */
+        # inline boost::shared_ptr<std::vector<Eigen::MatrixXf, Eigen::aligned_allocator<Eigen::MatrixXf> > > getHistograms () const { return (histograms_); }
+
+
+###
+
+# 3dsc.h
+# class ShapeContext3DEstimation<PointInT, PointNT, Eigen::MatrixXf> : public ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>
+# cdef extern from "pcl/features/3dsc.h" namespace "pcl":
+#     cdef cppclass ShapeContext3DEstimation[T, N, M]:
+#         ShapeContext3DEstimation(bool)
+#         # public:
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::feature_name_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::indices_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::descriptor_length_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::normals_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::input_;
+#         # using ShapeContext3DEstimation<PointInT, PointNT, pcl::SHOT>::compute;
+###
+
+# class BoundaryEstimation: public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/boundary.h" namespace "pcl":
+    cdef cppclass BoundaryEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        BoundaryEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        ##
+        # brief Check whether a point is a boundary point in a planar patch of projected points given by indices.
+        # note A coordinate system u-v-n must be computed a-priori using \a getCoordinateSystemOnPlane
+        # param[in] cloud a pointer to the input point cloud
+        # param[in] q_idx the index of the query point in \a cloud
+        # param[in] indices the estimated point neighbors of the query point
+        # param[in] u the u direction
+        # param[in] v the v direction
+        # param[in] angle_threshold the threshold angle (default \f$\pi / 2.0\f$)
+        # bool isBoundaryPoint (const cpp.PointCloud[In] &cloud, 
+        #                int q_idx, const vector[int] &indices, 
+        #                const Eigen::Vector4f &u, const Eigen::Vector4f &v, const float angle_threshold);
+        # brief Check whether a point is a boundary point in a planar patch of projected points given by indices.
+        # note A coordinate system u-v-n must be computed a-priori using \a getCoordinateSystemOnPlane
+        # param[in] cloud a pointer to the input point cloud
+        # param[in] q_point a pointer to the querry point
+        # param[in] indices the estimated point neighbors of the query point
+        # param[in] u the u direction
+        # param[in] v the v direction
+        # param[in] angle_threshold the threshold angle (default \f$\pi / 2.0\f$)
+        # bool isBoundaryPoint (const cpp.PointCloud[In] &cloud, 
+        #                const [In] &q_point, 
+        #                const vector[int] &indices, 
+        #                const Eigen::Vector4f &u, const Eigen::Vector4f &v, const float angle_threshold);
+        # brief Set the decision boundary (angle threshold) that marks points as boundary or regular. 
+        # (default \f$\pi / 2.0\f$) 
+        # param[in] angle the angle threshold
+        inline void setAngleThreshold (float angle)
+        inline float getAngleThreshold ()
+        # brief Get a u-v-n coordinate system that lies on a plane defined by its normal
+        # param[in] p_coeff the plane coefficients (containing the plane normal)
+        # param[out] u the resultant u direction
+        # param[out] v the resultant v direction
+        # inline void getCoordinateSystemOnPlane (const PointNT &p_coeff, 
+        #                           Eigen::Vector4f &u, Eigen::Vector4f &v)
+
+###
+
+# class CVFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+# cdef extern from "pcl/features/cvfh.h" namespace "pcl":
+#     cdef cppclass CVFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+#         CVFHEstimation()
+#         # public:
+#         # using Feature<PointInT, PointOutT>::feature_name_;
+#         # using Feature<PointInT, PointOutT>::getClassName;
+#         # using Feature<PointInT, PointOutT>::indices_;
+#         # using Feature<PointInT, PointOutT>::k_;
+#         # using Feature<PointInT, PointOutT>::search_radius_;
+#         # using Feature<PointInT, PointOutT>::surface_;
+#         # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#         # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#         # ctypedef typename pcl::search::Search<PointNormal>::Ptr KdTreePtr;
+#         # ctypedef typename pcl::NormalEstimation<PointNormal, PointNormal> NormalEstimator;
+#         # ctypedef typename pcl::VFHEstimation<PointInT, PointNT, pcl::VFHSignature308> VFHEstimator;
+#         ##
+#         # brief Removes normals with high curvature caused by real edges or noisy data
+#         # param[in] cloud pointcloud to be filtered
+#         # param[out] indices_out the indices of the points with higher curvature than threshold
+#         # param[out] indices_in the indices of the remaining points after filtering
+#         # param[in] threshold threshold value for curvature
+#         void filterNormalsWithHighCurvature (
+#                                               const cpp.PointCloud[NT] & cloud, 
+#                                               vector[int] &indices, vector[int] &indices2,
+#                                               vector[int] &, float);
+#         # brief Set the viewpoint.
+#         # param[in] vpx the X coordinate of the viewpoint
+#         # param[in] vpy the Y coordinate of the viewpoint
+#         # param[in] vpz the Z coordinate of the viewpoint
+#         inline void setViewPoint (float x, float y, float z)
+#         # brief Set the radius used to compute normals
+#         # param[in] radius_normals the radius
+#         inline void setRadiusNormals (float radius)
+#         # brief Get the viewpoint. 
+#         # param[out] vpx the X coordinate of the viewpoint
+#         # param[out] vpy the Y coordinate of the viewpoint
+#         # param[out] vpz the Z coordinate of the viewpoint
+#         inline void getViewPoint (float &x, float &y, float &z)
+#         # brief Get the centroids used to compute different CVFH descriptors
+#         # param[out] centroids vector to hold the centroids
+#         # inline void getCentroidClusters (vector[Eigen::Vector3f] &)
+#         # brief Get the normal centroids used to compute different CVFH descriptors
+#         # param[out] centroids vector to hold the normal centroids
+#         # inline void getCentroidNormalClusters (vector[Eigen::Vector3f] &)
+#         # brief Sets max. Euclidean distance between points to be added to the cluster 
+#         # param[in] d the maximum Euclidean distance 
+#         inline void setClusterTolerance (float tolerance)
+#         # brief Sets max. deviation of the normals between two points so they can be clustered together
+#         # param[in] d the maximum deviation 
+#         inline void setEPSAngleThreshold (float angle)
+#         # brief Sets curvature threshold for removing normals
+#         # param[in] d the curvature threshold 
+#         inline void setCurvatureThreshold (float curve)
+#         # brief Set minimum amount of points for a cluster to be considered
+#         # param[in] min the minimum amount of points to be set 
+#         inline void setMinPoints (size_t points)
+#         # brief Sets wether if the CVFH signatures should be normalized or not
+#         # param[in] normalize true if normalization is required, false otherwise 
+#         inline void setNormalizeBins (bool bins)
+#         # brief Overloaded computed method from pcl::Feature.
+#         # param[out] output the resultant point cloud model dataset containing the estimated features
+#         # void compute (PointCloudOut &);
+
+
+###
+
+# esf.h
+# class ESFEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/esf.h" namespace "pcl":
+    cdef cppclass ESFEstimation[In, Out](Feature[In, Out]):
+        ESFEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # ctypedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # void compute (cpp.PointCloud[Out] &output)
+###
+
+# template <typename PointInT, typename PointRFT>
+# class FeatureWithLocalReferenceFrames
+cdef extern from "pcl/features/feature.h" namespace "pcl":
+    cdef cppclass FeatureWithLocalReferenceFrames[T, REF]:
+        FeatureWithLocalReferenceFrames ()
+        # public:
+        # ctypedef cpp.PointCloud[RFT] PointCloudLRF;
+        # ctypedef typename PointCloudLRF::Ptr PointCloudLRFPtr;
+        # ctypedef typename PointCloudLRF::ConstPtr PointCloudLRFConstPtr;
+        # inline void setInputReferenceFrames (const PointCloudLRFConstPtr &frames)
+        # inline PointCloudLRFConstPtr getInputReferenceFrames () const
+        # protected:
+        # /** \brief A boost shared pointer to the local reference frames. */
+        # PointCloudLRFConstPtr frames_;
+        # /** \brief The user has never set the frames. */
+        # bool frames_never_defined_;
+        # /** \brief Check if frames_ has been correctly initialized and compute it if needed.
+        # * \param input the subclass' input cloud dataset.
+        # * \param lrf_estimation a pointer to a local reference frame estimation class to be used as default.
+        # * \return true if frames_ has been correctly initialized.
+        # */
+        # typedef typename Feature<PointInT, PointRFT>::Ptr LRFEstimationPtr;
+        # virtual bool
+        # initLocalReferenceFrames (const size_t& indices_size,
+        #                           const LRFEstimationPtr& lrf_estimation = LRFEstimationPtr());
+###
+
+# fpfh
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::FPFHSignature33>
+# class FPFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/fpfh.h" namespace "pcl":
+    cdef cppclass FPFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        FPFHEstimation()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * represented by Cartesian coordinates and normals.
+        # * \note For explanations about the features, please see the literature mentioned above (the order of the
+        # * features might be different).
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals (assuming normalized vectors) at each point in cloud
+        # * \param[in] p_idx the index of the first point (source)
+        # * \param[in] q_idx the index of the second point (target)
+        # * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+        # * \param[out] f2 the second angular feature (angle between nq_idx and v)
+        # * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+        # * \param[out] f4 the distance feature (p_idx - q_idx)
+        # bool 
+        # computePairFeatures (const pcl::PointCloud<PointInT> &cloud, const pcl::PointCloud<PointNT> &normals, 
+        #                    int p_idx, int q_idx, float &f1, float &f2, float &f3, float &f4);
+        # * \brief Estimate the SPFH (Simple Point Feature Histograms) individual signatures of the three angular
+        # * (f1, f2, f3) features for a given point based on its spatial neighborhood of 3D points with normals
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        # * \param[in] p_idx the index of the query point (source)
+        # * \param[in] row the index row in feature histogramms
+        # * \param[in] indices the k-neighborhood point indices in the dataset
+        # * \param[out] hist_f1 the resultant SPFH histogram for feature f1
+        # * \param[out] hist_f2 the resultant SPFH histogram for feature f2
+        # * \param[out] hist_f3 the resultant SPFH histogram for feature f3
+        # void 
+        # computePointSPFHSignature (const pcl::PointCloud<PointInT> &cloud, 
+        #                          const pcl::PointCloud<PointNT> &normals, int p_idx, int row, 
+        #                          const std::vector<int> &indices, 
+        #                          Eigen::MatrixXf &hist_f1, Eigen::MatrixXf &hist_f2, Eigen::MatrixXf &hist_f3);
+        # * \brief Weight the SPFH (Simple Point Feature Histograms) individual histograms to create the final FPFH
+        # * (Fast Point Feature Histogram) for a given point based on its 3D spatial neighborhood
+        # * \param[in] hist_f1 the histogram feature vector of \a f1 values over the given patch
+        # * \param[in] hist_f2 the histogram feature vector of \a f2 values over the given patch
+        # * \param[in] hist_f3 the histogram feature vector of \a f3 values over the given patch
+        # * \param[in] indices the point indices of p_idx's k-neighborhood in the point cloud
+        # * \param[in] dists the distances from p_idx to all its k-neighbors
+        # * \param[out] fpfh_histogram the resultant FPFH histogram representing the feature at the query point
+        # void 
+        # weightPointSPFHSignature (const Eigen::MatrixXf &hist_f1, 
+        #                         const Eigen::MatrixXf &hist_f2, 
+        #                         const Eigen::MatrixXf &hist_f3, 
+        #                         const std::vector<int> &indices, 
+        #                         const std::vector<float> &dists, 
+        #                         Eigen::VectorXf &fpfh_histogram);
+        # * \brief Set the number of subdivisions for each angular feature interval.
+        # * \param[in] nr_bins_f1 number of subdivisions for the first angular feature
+        # * \param[in] nr_bins_f2 number of subdivisions for the second angular feature
+        # * \param[in] nr_bins_f3 number of subdivisions for the third angular feature
+        inline void setNrSubdivisions (int , int , int )
+         # * \brief Get the number of subdivisions for each angular feature interval. 
+        # * \param[out] nr_bins_f1 number of subdivisions for the first angular feature
+        # * \param[out] nr_bins_f2 number of subdivisions for the second angular feature
+        # * \param[out] nr_bins_f3 number of subdivisions for the third angular feature
+        inline void getNrSubdivisions (int &, int &, int &)
+###
+
+# template <typename PointInT, typename PointNT>
+# class FPFHEstimation<PointInT, PointNT, Eigen::MatrixXf> : public FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>
+# cdef extern from "pcl/features/feature.h" namespace "pcl":
+#     cdef cppclass FPFHEstimation[T, NT]:
+#         FPFHEstimation()
+#         # public:
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::k_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::nr_bins_f1_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::nr_bins_f2_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::nr_bins_f3_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::hist_f1_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::hist_f2_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::hist_f3_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::indices_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::search_parameter_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::input_;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::compute;
+#         # using FPFHEstimation<PointInT, PointNT, pcl::FPFHSignature33>::fpfh_histogram_;
+
+###
+
+# fpfh_omp
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class FPFHEstimationOMP : public FPFHEstimation<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/fpfh_omp.h" namespace "pcl":
+    cdef cppclass FPFHEstimationOMP[In, NT, Out](FPFHEstimation[In, NT, Out]):
+        FPFHEstimationOMP ()
+        # FPFHEstimationOMP (unsigned int )
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f1_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f2_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::hist_f3_;
+        # using FPFHEstimation<PointInT, PointNT, PointOutT>::weightPointSPFHSignature;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * \brief Initialize the scheduler and set the number of threads to use.
+        # * \param[in] nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        inline void setNumberOfThreads (unsigned threads)
+        # public:
+        # * \brief The number of subdivisions for each angular feature interval. */
+        # int nr_bins_f1_, nr_bins_f2_, nr_bins_f3_;
+
+###
+
+# integral_image_normal.h
+# template <typename PointInT, typename PointOutT>
+# class IntegralImageNormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+    cdef cppclass IntegralImageNormalEstimation[In, Out](Feature[In, Out]):
+        IntegralImageNormalEstimation ()
+        # public:
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # 
+        # * \brief Set the regions size which is considered for normal estimation.
+        # * \param[in] width the width of the search rectangle
+        # * \param[in] height the height of the search rectangle
+        void setRectSize (const int width, const int height)
+        
+        # * \brief Sets the policy for handling borders.
+        # * \param[in] border_policy the border policy.
+        # minipcl
+        # void setBorderPolicy (BorderPolicy border_policy)
+        # * \brief Computes the normal at the specified position.
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[in] point_index the position index of the point
+        # * \param[out] normal the output estimated normal
+        void computePointNormal (const int pos_x, const int pos_y, const unsigned point_index, Out &normal)
+        
+        # * \brief Computes the normal at the specified position with mirroring for border handling.
+        # * \param[in] pos_x x position (pixel)
+        # * \param[in] pos_y y position (pixel)
+        # * \param[in] point_index the position index of the point
+        # * \param[out] normal the output estimated normal
+        void computePointNormalMirror (const int pos_x, const int pos_y, const unsigned point_index, Out &normal)
+        
+        # * \brief The depth change threshold for computing object borders
+        # * \param[in] max_depth_change_factor the depth change threshold for computing object borders based on
+        # * depth changes
+        void setMaxDepthChangeFactor (float max_depth_change_factor)
+        
+        # * \brief Set the normal smoothing size
+        # * \param[in] normal_smoothing_size factor which influences the size of the area used to smooth normals
+        # * (depth dependent if useDepthDependentSmoothing is true)
+        void setNormalSmoothingSize (float normal_smoothing_size)
+        
+        # TODO : use minipcl.cpp/h
+        # * \brief Set the normal estimation method. The current implemented algorithms are:
+        # * <ul>
+        # *   <li><b>COVARIANCE_MATRIX</b> - creates 9 integral images to compute the normal for a specific point
+        # *   from the covariance matrix of its local neighborhood.</li>
+        # *   <li><b>AVERAGE_3D_GRADIENT</b> - creates 6 integral images to compute smoothed versions of
+        # *   horizontal and vertical 3D gradients and computes the normals using the cross-product between these
+        # *   two gradients.
+        # *   <li><b>AVERAGE_DEPTH_CHANGE</b> -  creates only a single integral image and computes the normals
+        # *   from the average depth changes.
+        # * </ul>
+        # * \param[in] normal_estimation_method the method used for normal estimation
+        # void setNormalEstimationMethod (NormalEstimationMethod2 normal_estimation_method)
+       
+        # brief Set whether to use depth depending smoothing or not
+        # param[in] use_depth_dependent_smoothing decides whether the smoothing is depth dependent
+        void setDepthDependentSmoothing (bool use_depth_dependent_smoothing)
+        
+        # brief Provide a pointer to the input dataset (overwrites the PCLBase::setInputCloud method)
+        # \param[in] cloud the const boost shared pointer to a PointCloud message
+        # void setInputCloud (const typename PointCloudIn::ConstPtr &cloud)
+        void setInputCloud (In cloud)
+        
+        # brief Returns a pointer to the distance map which was computed internally
+        inline float* getDistanceMap ()
+        
+        # * \brief Set the viewpoint.
+        # * \param vpx the X coordinate of the viewpoint
+        # * \param vpy the Y coordinate of the viewpoint
+        # * \param vpz the Z coordinate of the viewpoint
+        inline void setViewPoint (float vpx, float vpy, float vpz)
+        
+        # * \brief Get the viewpoint.
+        # * \param [out] vpx x-coordinate of the view point
+        # * \param [out] vpy y-coordinate of the view point
+        # * \param [out] vpz z-coordinate of the view point
+        # * \note this method returns the currently used viewpoint for normal flipping.
+        # * If the viewpoint is set manually using the setViewPoint method, this method will return the set view point coordinates.
+        # * If an input cloud is set, it will return the sensor origin otherwise it will return the origin (0, 0, 0)
+        inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        
+        # * \brief sets whether the sensor origin or a user given viewpoint should be used. After this method, the 
+        # * normal estimation method uses the sensor origin of the input cloud.
+        # * to use a user defined view point, use the method setViewPoint
+        inline void useSensorOriginAsViewPoint ()
+
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal] IntegralImageNormalEstimation_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal] IntegralImageNormalEstimation_PointXYZI_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGB_t
+ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal] IntegralImageNormalEstimation_PointXYZRGBA_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]] IntegralImageNormalEstimationPtr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal]] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal]] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal]) IntegralImageNormalEstimation_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal]) IntegralImageNormalEstimation_PointXYZI_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal](Feature[cpp.PointXYZRGB, cpp.Normal]) IntegralImageNormalEstimation_PointXYZRGB_t
+# ctypedef IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal](Feature[cpp.PointXYZRGBA, cpp.Normal]) IntegralImageNormalEstimation_PointXYZRGBA_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal](Feature[cpp.PointXYZ, cpp.Normal])] IntegralImageNormalEstimationPtr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZI, cpp.Normal](Feature[cpp.PoinPointXYZItXYZ, cpp.Normal])] IntegralImageNormalEstimation_PointXYZI_Ptr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGB, cpp.Normal](Feature[cpp.PointXYZRGB, cpp.Normal])] IntegralImageNormalEstimation_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[IntegralImageNormalEstimation[cpp.PointXYZRGBA, cpp.Normal](Feature[cpp.PointXYZRGBA, cpp.Normal])] IntegralImageNormalEstimation_PointXYZRGBA_Ptr_t
+###
+
+# integral_image2D.h
+# template <class DataType, unsigned Dimension>
+# class IntegralImage2D
+cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+    cdef cppclass IntegralImage2D[Type, Dim]:
+        # IntegralImage2D ()
+        IntegralImage2D (bool flag)
+        # public:
+        # static const unsigned second_order_size = (Dimension * (Dimension + 1)) >> 1;
+        # ctypedef Eigen::Matrix<typename IntegralImageTypeTraits<DataType>::IntegralType, Dimension, 1> ElementType;
+        # ctypedef Eigen::Matrix<typename IntegralImageTypeTraits<DataType>::IntegralType, second_order_size, 1> SecondOrderType;
+        # void setSecondOrderComputation (bool compute_second_order_integral_images);
+        # * \brief Set the input data to compute the integral image for
+        #   * \param[in] data the input data
+        #   * \param[in] width the width of the data
+        #   * \param[in] height the height of the data
+        #   * \param[in] element_stride the element stride of the data
+        #   * \param[in] row_stride the row stride of the data
+        # void setInput (const DataType * data, unsigned width, unsigned height, unsigned element_stride, unsigned row_stride)
+        # * \brief Compute the first order sum within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        # inline ElementType getFirstOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the first order sum within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        # inline ElementType getFirstOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+        # /** \brief Compute the second order sum within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        # inline SecondOrderType getSecondOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the second order sum within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        # inline SecondOrderType getSecondOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+        # /** \brief Compute the number of finite elements within a given rectangle
+        #   * \param[in] start_x x position of rectangle
+        #   * \param[in] start_y y position of rectangle
+        #   * \param[in] width width of rectangle
+        #   * \param[in] height height of rectangle
+        inline unsigned getFiniteElementsCount (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const
+        # /** \brief Compute the number of finite elements within a given rectangle
+        #   * \param[in] start_x x position of the start of the rectangle
+        #   * \param[in] start_y x position of the start of the rectangle
+        #   * \param[in] end_x x position of the end of the rectangle
+        #   * \param[in] end_y x position of the end of the rectangle
+        inline unsigned getFiniteElementsCountSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const
+###
+
+# template <class DataType>
+# class IntegralImage2D <DataType, 1>
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+#     cdef cppclass IntegralImage2D[Type]:
+#         # IntegralImage2D ()
+#         IntegralImage2D (bool flag)
+#         # public:
+#         # static const unsigned second_order_size = 1;
+#         # ctypedef typename IntegralImageTypeTraits<DataType>::IntegralType ElementType;
+#         # ctypedef typename IntegralImageTypeTraits<DataType>::IntegralType SecondOrderType;
+#         # /** \brief Set the input data to compute the integral image for
+#         #   * \param[in] data the input data
+#         #   * \param[in] width the width of the data
+#         #   * \param[in] height the height of the data
+#         #   * \param[in] element_stride the element stride of the data
+#         #   * \param[in] row_stride the row stride of the data
+#         #   */
+#         # void setInput (const DataType * data, unsigned width, unsigned height, unsigned element_stride, unsigned row_stride);
+#         # /** \brief Compute the first order sum within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         # inline ElementType getFirstOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the first order sum within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         #   */
+#         # inline ElementType getFirstOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+#         # /** \brief Compute the second order sum within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         # inline SecondOrderType getSecondOrderSum (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the second order sum within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         # inline SecondOrderType getSecondOrderSumSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+#         # /** \brief Compute the number of finite elements within a given rectangle
+#         #   * \param[in] start_x x position of rectangle
+#         #   * \param[in] start_y y position of rectangle
+#         #   * \param[in] width width of rectangle
+#         #   * \param[in] height height of rectangle
+#         #   */
+#         inline unsigned getFiniteElementsCount (unsigned start_x, unsigned start_y, unsigned width, unsigned height) const;
+#         # /** \brief Compute the number of finite elements within a given rectangle
+#         #   * \param[in] start_x x position of the start of the rectangle
+#         #   * \param[in] start_y x position of the start of the rectangle
+#         #   * \param[in] end_x x position of the end of the rectangle
+#         #   * \param[in] end_y x position of the end of the rectangle
+#         #   */
+#         inline unsigned getFiniteElementsCountSE (unsigned start_x, unsigned start_y, unsigned end_x, unsigned end_y) const;
+
+###
+
+# intensity_gradient.h
+# template <typename PointInT, typename PointNT, typename PointOutT, typename IntensitySelectorT = pcl::common::IntensityFieldAccessor<PointInT> >
+# class IntensityGradientEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/intensity_gradient.h" namespace "pcl":
+    cdef cppclass IntensityGradientEstimation[In, NT, Out, Intensity](FeatureFromNormals[In, NT, Out]):
+        IntensityGradientEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (int nr_threads)
+###
+
+# template <typename PointInT, typename PointNT>
+# class IntensityGradientEstimation<PointInT, PointNT, Eigen::MatrixXf>: public IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>
+# cdef extern from "pcl/features/intensity_gradient.h" namespace "pcl":
+#     cdef cppclass IntensityGradientEstimation[In, NT]:
+#         IntensityGradientEstimation ()
+#         # public:
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::indices_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::normals_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::input_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::surface_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::k_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::search_parameter_;
+#         #   using IntensityGradientEstimation<PointInT, PointNT, pcl::IntensityGradient>::compute;
+
+###
+
+# intensity_spin.h
+# template <typename PointInT, typename PointOutT>
+# class IntensitySpinEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/intensity_spin.h" namespace "pcl":
+    cdef cppclass IntensitySpinEstimation[In, Out](Feature[In, Out]):
+        IntensitySpinEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # ctypedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        ##
+        # /** \brief Estimate the intensity-domain spin image descriptor for a given point based on its spatial
+        #   * neighborhood of 3D points and their intensities. 
+        #   * \param[in] cloud the dataset containing the Cartesian coordinates and intensity values of the points
+        #   * \param[in] radius the radius of the feature
+        #   * \param[in] sigma the standard deviation of the Gaussian smoothing kernel to use during the soft histogram update
+        #   * \param[in] k the number of neighbors to use from \a indices and \a squared_distances
+        #   * \param[in] indices the indices of the points that comprise the query point's neighborhood
+        #   * \param[in] squared_distances the squared distances from the query point to each point in the neighborhood
+        #   * \param[out] intensity_spin_image the resultant intensity-domain spin image descriptor
+        #   */
+        # void computeIntensitySpinImage (const PointCloudIn &cloud, 
+        #                            float radius, float sigma, int k, 
+        #                            const std::vector<int> &indices, 
+        #                            const std::vector<float> &squared_distances, 
+        #                            Eigen::MatrixXf &intensity_spin_image);
+
+        # /** \brief Set the number of bins to use in the distance dimension of the spin image
+        #   * \param[in] nr_distance_bins the number of bins to use in the distance dimension of the spin image
+        #   */
+        # inline void setNrDistanceBins (size_t nr_distance_bins) { nr_distance_bins_ = static_cast<int> (nr_distance_bins); };
+        # /** \brief Returns the number of bins in the distance dimension of the spin image. */
+        # inline int getNrDistanceBins ()
+        # /** \brief Set the number of bins to use in the intensity dimension of the spin image.
+        #   * \param[in] nr_intensity_bins the number of bins to use in the intensity dimension of the spin image
+        #   */
+        # inline void setNrIntensityBins (size_t nr_intensity_bins)
+        # /** \brief Returns the number of bins in the intensity dimension of the spin image. */
+        # inline int getNrIntensityBins ()
+        # /** \brief Set the standard deviation of the Gaussian smoothing kernel to use when constructing the spin images.  
+        #   * \param[in] sigma the standard deviation of the Gaussian smoothing kernel to use when constructing the spin images
+        # inline void setSmoothingBandwith (float sigma)
+        # /** \brief Returns the standard deviation of the Gaussian smoothing kernel used to construct the spin images.  */
+        # inline float getSmoothingBandwith ()
+        # /** \brief Estimate the intensity-domain descriptors at a set of points given by <setInputCloud (), setIndices ()>
+        #   *  using the surface in setSearchSurface (), and the spatial locator in setSearchMethod ().
+        #   * \param[out] output the resultant point cloud model dataset that contains the intensity-domain spin image features
+        # void computeFeature (PointCloudOut &output);
+        # /** \brief The number of distance bins in the descriptor. */
+        # int nr_distance_bins_;
+        # /** \brief The number of intensity bins in the descriptor. */
+        # int nr_intensity_bins_;
+        # /** \brief The standard deviation of the Gaussian smoothing kernel used to construct the spin images. */
+        # float sigma_;
+
+###
+
+# template <typename PointInT>
+# class IntensitySpinEstimation<PointInT, Eigen::MatrixXf>: public IntensitySpinEstimation<PointInT, pcl::Histogram<20> >
+# cdef extern from "pcl/features/intensity_spin.h" namespace "pcl":
+#     cdef cppclass IntensitySpinEstimation[In](IntensitySpinEstimation[In]):
+#         IntensitySpinEstimation ()
+#         # public:
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::getClassName;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::input_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::indices_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::surface_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::search_radius_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::nr_intensity_bins_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::nr_distance_bins_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::tree_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::sigma_;
+#         #   using IntensitySpinEstimation<PointInT, pcl::Histogram<20> >::compute;
+###
+
+# moment_invariants.h
+# template <typename PointInT, typename PointOutT>
+# class MomentInvariantsEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/moment_invariants.h" namespace "pcl":
+    cdef cppclass MomentInvariantsEstimation[In, Out](Feature[In, Out]):
+        MomentInvariantsEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # /** \brief Compute the 3 moment invariants (j1, j2, j3) for a given set of points, using their indices.
+        # * \param[in] cloud the input point cloud
+        # * \param[in] indices the point cloud indices that need to be used
+        # * \param[out] j1 the resultant first moment invariant
+        # * \param[out] j2 the resultant second moment invariant
+        # * \param[out] j3 the resultant third moment invariant
+        # */
+        # void computePointMomentInvariants (const pcl::PointCloud<PointInT> &cloud, 
+        #                             const std::vector<int> &indices, 
+        #                             float &j1, float &j2, float &j3);
+        # * \brief Compute the 3 moment invariants (j1, j2, j3) for a given set of points, using their indices.
+        # * \param[in] cloud the input point cloud
+        # * \param[out] j1 the resultant first moment invariant
+        # * \param[out] j2 the resultant second moment invariant
+        # * \param[out] j3 the resultant third moment invariant
+        # void computePointMomentInvariants (const pcl::PointCloud<PointInT> &cloud, 
+        #                             float &j1, float &j2, float &j3);
+###
+
+# template <typename PointInT>
+# class MomentInvariantsEstimation<PointInT, Eigen::MatrixXf>: public MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>
+# cdef extern from "pcl/features/moment_invariants.h" namespace "pcl":
+#     cdef cppclass MomentInvariantsEstimation[In, Out](MomentInvariantsEstimation[In]):
+#         MomentInvariantsEstimation ()
+#         public:
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::k_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::indices_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::search_parameter_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::surface_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::input_;
+#         using MomentInvariantsEstimation<PointInT, pcl::MomentInvariants>::compute;
+###
+
+# multiscale_feature_persistence.h
+# template <typename PointSource, typename PointFeature>
+# class MultiscaleFeaturePersistence : public PCLBase<PointSource>
+cdef extern from "pcl/features/multiscale_feature_persistence.h" namespace "pcl":
+    cdef cppclass MultiscaleFeaturePersistence[Source, Feature](cpp.PCLBase[Source]):
+        MultiscaleFeaturePersistence ()
+        # public:
+        # typedef pcl::PointCloud<PointFeature> FeatureCloud;
+        # typedef typename pcl::PointCloud<PointFeature>::Ptr FeatureCloudPtr;
+        # typedef typename pcl::Feature<PointSource, PointFeature>::Ptr FeatureEstimatorPtr;
+        # typedef boost::shared_ptr<const pcl::PointRepresentation <PointFeature> > FeatureRepresentationConstPtr;
+        # using pcl::PCLBase<PointSource>::input_;
+        # 
+        # /** \brief Method that calls computeFeatureAtScale () for each scale parameter */
+        # void computeFeaturesAtAllScales ();
+        
+        # /** \brief Central function that computes the persistent features
+        #  * \param output_features a cloud containing the persistent features
+        #  * \param output_indices vector containing the indices of the points in the input cloud
+        #  * that have persistent features, under a one-to-one correspondence with the output_features cloud
+        #  */
+        # void determinePersistentFeatures (FeatureCloud &output_features, boost::shared_ptr<std::vector<int> > &output_indices);
+        
+        # /** \brief Method for setting the scale parameters for the algorithm
+        #  * \param scale_values vector of scales to determine the characteristic of each scaling step
+        #  */
+        inline void setScalesVector (vector[float] &scale_values)
+        
+        # /** \brief Method for getting the scale parameters vector */
+        inline vector[float] getScalesVector ()
+        
+        # /** \brief Setter method for the feature estimator
+        #  * \param feature_estimator pointer to the feature estimator instance that will be used
+        #  * \note the feature estimator instance should already have the input data given beforehand
+        #  * and everything set, ready to be given the compute () command
+        #  */
+        # inline void setFeatureEstimator (FeatureEstimatorPtr feature_estimator)
+        
+        # /** \brief Getter method for the feature estimator */
+        # inline FeatureEstimatorPtr getFeatureEstimator ()
+        
+        # \brief Provide a pointer to the feature representation to use to convert features to k-D vectors.
+        # \param feature_representation the const boost shared pointer to a PointRepresentation
+        # inline void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation)
+        
+        # \brief Get a pointer to the feature representation used when converting features into k-D vectors. */
+        # inline FeatureRepresentationConstPtr const getPointRepresentation ()
+        
+        # \brief Sets the alpha parameter
+        # \param alpha value to replace the current alpha with
+        inline void setAlpha (float alpha)
+        
+        # /** \brief Get the value of the alpha parameter */
+        inline float getAlpha ()
+        
+        # /** \brief Method for setting the distance metric that will be used for computing the difference between feature vectors
+        # * \param distance_metric the new distance metric chosen from the NormType enum
+        # inline void setDistanceMetric (NormType distance_metric)
+        
+        # /** \brief Returns the distance metric that is currently used to calculate the difference between feature vectors */
+        # inline NormType getDistanceMetric ()
+###
+
+# narf.h
+# namespace pcl 
+# {
+#   // Forward declarations
+#   class RangeImage;
+#   struct InterestPoint;
+# 
+# #define NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE 10
+# narf.h
+# namespace pcl 
+# /**
+# * \brief NARF (Normal Aligned Radial Features) is a point feature descriptor type for 3D data.
+# * Please refer to pcl/features/narf_descriptor.h if you want the class derived from pcl Feature.
+# * See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard
+# *     Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries
+# *     In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011. 
+# * \author Bastian Steder
+# * \ingroup features
+# */
+# class PCL_EXPORTS Narf
+        # public:
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # //! Constructor
+        # Narf();
+        # //! Copy Constructor
+        # Narf(const Narf& other);
+        # //! Destructor
+        # ~Narf();
+        # 
+        # // =====Operators=====
+        # //! Assignment operator
+        # const Narf& operator=(const Narf& other);
+        # 
+        # // =====STATIC=====
+        # /** The maximum number of openmp threads that can be used in this class */
+        # static int max_no_of_threads;
+        # 
+        # /** Add features extracted at the given interest point and add them to the list */
+        # static void extractFromRangeImageAndAddToList (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Same as above */
+        # static void extractFromRangeImageAndAddToList (const RangeImage& range_image, float image_x, float image_y, int descriptor_size,float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Get a list of features from the given interest points. */
+        # static void extractForInterestPoints (const RangeImage& range_image, const PointCloud<InterestPoint>& interest_points, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # /** Extract an NARF for every point in the range image. */
+        # static void extractForEveryRangeImagePointAndAddToList (const RangeImage& range_image, int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
+        # 
+        # // =====PUBLIC METHODS=====
+        # /** Method to extract a NARF feature from a certain 3D point using a range image.
+        # *  pose determines the coordinate system of the feature, whereas it transforms a point from the world into the feature system.
+        # *  This means the interest point at which the feature is extracted will be the inverse application of pose onto (0,0,0).
+        # *  descriptor_size_ determines the size of the descriptor,
+        # *  support_size determines the support size of the feature, meaning the size in the world it covers */
+        # bool extractFromRangeImage (const RangeImage& range_image, const Eigen::Affine3f& pose, int descriptor_size, float support_size,int surface_patch_world_size=NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE);
+        # 
+        # //! Same as above, but determines the transformation from the surface in the range image
+        # bool extractFromRangeImage (const RangeImage& range_image, float x, float y, int descriptor_size, float support_size);
+        # 
+        # //! Same as above
+        # bool extractFromRangeImage (const RangeImage& range_image, const InterestPoint& interest_point, int descriptor_size, float support_size);
+        # 
+        # //! Same as above
+        # bool extractFromRangeImage (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size);
+        # 
+        # /** Same as above, but using the rotational invariant version by choosing the best extracted rotation around the normal.
+        # *  Use extractFromRangeImageAndAddToList if you want to enable the system to return multiple features with different rotations. */
+        # bool extractFromRangeImageWithBestRotation (const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size);
+        # 
+        # /* Get the dominant rotations of the current descriptor
+        # * \param rotations the returned rotations
+        # * \param strength values describing how pronounced the corresponding rotations are
+        # */
+        # void getRotations (std::vector<float>& rotations, std::vector<float>& strengths) const;
+        # 
+        # /* Get the feature with a different rotation around the normal
+        # * You are responsible for deleting the new features!
+        # * \param range_image the source from which the feature is extracted
+        # * \param rotations list of angles (in radians)
+        # * \param rvps returned features
+        # */
+        # void getRotatedVersions (const RangeImage& range_image, const std::vector<float>& rotations, std::vector<Narf*>& features) const;
+        # 
+        # //! Calculate descriptor distance, value in [0,1] with 0 meaning identical and 1 every cell above maximum distance
+        # inline float getDescriptorDistance (const Narf& other) const;
+        # 
+        # //! How many points on each beam of the gradient star are used to calculate the descriptor?
+        # inline int getNoOfBeamPoints () const { return (static_cast<int> (pcl_lrint (ceil (0.5f * float (surface_patch_pixel_size_))))); }
+        # 
+        # //! Copy the descriptor and pose to the point struct Narf36
+        # inline void copyToNarf36 (Narf36& narf36) const;
+        # 
+        # /** Write to file */
+        # void saveBinary (const std::string& filename) const;
+        # 
+        # /** Write to output stream */
+        # void saveBinary (std::ostream& file) const;
+        # 
+        # /** Read from file */
+        # void loadBinary (const std::string& filename);
+        # /** Read from input stream */
+        # void loadBinary (std::istream& file);
+        # 
+        # //! Create the descriptor from the already set other members
+        # bool extractDescriptor (int descriptor_size);
+        # 
+        # // =====GETTERS=====
+        # //! Getter (const) for the descriptor
+        # inline const float* getDescriptor () const { return descriptor_;}
+        # //! Getter for the descriptor
+        # inline float* getDescriptor () { return descriptor_;}
+        # //! Getter (const) for the descriptor length
+        # inline const int& getDescriptorSize () const { return descriptor_size_;}
+        # //! Getter for the descriptor length
+        # inline int& getDescriptorSize () { return descriptor_size_;}
+        # //! Getter (const) for the position
+        # inline const Eigen::Vector3f& getPosition () const { return position_;}
+        # //! Getter for the position
+        # inline Eigen::Vector3f& getPosition () { return position_;}
+        # //! Getter (const) for the 6DoF pose
+        # inline const Eigen::Affine3f& getTransformation () const { return transformation_;}
+        # //! Getter for the 6DoF pose
+        # inline Eigen::Affine3f& getTransformation () { return transformation_;}
+        # //! Getter (const) for the pixel size of the surface patch (only one dimension)
+        # inline const int& getSurfacePatchPixelSize () const { return surface_patch_pixel_size_;}
+        # //! Getter for the pixel size of the surface patch (only one dimension)
+        # inline int& getSurfacePatchPixelSize () { return surface_patch_pixel_size_;}
+        # //! Getter (const) for the world size of the surface patch
+        # inline const float& getSurfacePatchWorldSize () const { return surface_patch_world_size_;}
+        # //! Getter for the world size of the surface patch
+        # inline float& getSurfacePatchWorldSize () { return surface_patch_world_size_;}
+        # //! Getter (const) for the rotation of the surface patch
+        # inline const float& getSurfacePatchRotation () const { return surface_patch_rotation_;}
+        # //! Getter for the rotation of the surface patch
+        # inline float& getSurfacePatchRotation () { return surface_patch_rotation_;}
+        # //! Getter (const) for the surface patch
+        # inline const float* getSurfacePatch () const { return surface_patch_;}
+        # //! Getter for the surface patch
+        # inline float* getSurfacePatch () { return surface_patch_;}
+        # //! Method to erase the surface patch and free the memory
+        # inline void freeSurfacePatch () { delete[] surface_patch_; surface_patch_=NULL; surface_patch_pixel_size_=0; }
+        # 
+        # // =====SETTERS=====
+        # //! Setter for the descriptor
+        # inline void setDescriptor (float* descriptor) { descriptor_ = descriptor;}
+        # //! Setter for the surface patch
+        # inline void setSurfacePatch (float* surface_patch) { surface_patch_ = surface_patch;}
+        # 
+        # // =====PUBLIC MEMBER VARIABLES=====
+        # 
+        # // =====PUBLIC STRUCTS=====
+        # struct FeaturePointRepresentation : public PointRepresentation<Narf*>
+        # {
+        #     typedef Narf* PointT;
+        #     FeaturePointRepresentation(int nr_dimensions) { this->nr_dimensions_ = nr_dimensions; }
+        #     /** \brief Empty destructor */
+        #     virtual ~FeaturePointRepresentation () {}
+        #     virtual void copyToFloatArray (const PointT& p, float* out) const { memcpy(out, p->getDescriptor(), sizeof(*p->getDescriptor())*this->nr_dimensions_); }
+        # };
+
+
+###
+
+# narf_descriptor.h
+# namespace pcl
+#     // Forward declarations
+#     class RangeImage;
+##
+# narf_descriptor.h
+# namespace pcl
+# /** @b Computes NARF feature descriptors for points in a range image
+# * See B. Steder, R. B. Rusu, K. Konolige, and W. Burgard
+# *     Point Feature Extraction on 3D Range Scans Taking into Account Object Boundaries
+# *     In Proc. of the IEEE Int. Conf. on Robotics &Automation (ICRA). 2011. 
+# * \author Bastian Steder
+# * \ingroup features
+# */
+# class PCL_EXPORTS NarfDescriptor : public Feature<PointWithRange,Narf36>
+        # public:
+        # typedef boost::shared_ptr<NarfDescriptor> Ptr;
+        # typedef boost::shared_ptr<const NarfDescriptor> ConstPtr;
+        # // =====TYPEDEFS=====
+        # typedef Feature<PointWithRange,Narf36> BaseClass;
+        # 
+        # // =====STRUCTS/CLASSES=====
+        # struct Parameters
+        # {
+        #   Parameters() : support_size(-1.0f), rotation_invariant(true) {}
+        #   float support_size;
+        #   bool rotation_invariant;
+        # };
+        # 
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # NarfDescriptor (const RangeImage* range_image=NULL, const std::vector<int>* indices=NULL);
+        # /** Destructor */
+        # virtual ~NarfDescriptor();
+        # 
+        # // =====METHODS=====
+        # //! Set input data
+        # void setRangeImage (const RangeImage* range_image, const std::vector<int>* indices=NULL);
+        # 
+        # //! Overwrite the compute function of the base class
+        # void compute (cpp.PointCloud[Out]& output);
+        # 
+        # // =====GETTER=====
+        # //! Get a reference to the parameters struct
+        # Parameters& getParameters () { return parameters_;}
+
+
+###
+
+# normal_3d.h
+# cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+#     cdef cppclass NormalEstimation[I, N, O]:
+#         NormalEstimation()
+# 
+#   template <typename PointT> inline void
+#   computePointNormal (const pcl::PointCloud<PointT> &cloud,
+#                       Eigen::Vector4f &plane_parameters, float &curvature)
+#   /** \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+#     * and return the estimated plane parameters together with the surface curvature.
+#     * \param cloud the input point cloud
+#     * \param indices the point cloud indices that need to be used
+#     * \param plane_parameters the plane parameters as: a, b, c, d (ax + by + cz + d = 0)
+#     * \param curvature the estimated surface curvature as a measure of
+#     * \f[
+#     * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+#     * \f]
+#     * \ingroup features
+#     */
+#   template <typename PointT> inline void
+#   computePointNormal (const pcl::PointCloud<PointT> &cloud, const std::vector<int> &indices,
+#                       Eigen::Vector4f &plane_parameters, float &curvature)
+#
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param normal the plane normal to be flipped
+#     * \ingroup features
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               Eigen::Matrix<Scalar, 4, 1>& normal)
+# 
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param normal the plane normal to be flipped
+#     * \ingroup features
+#     */
+#   template <typename PointT, typename Scalar> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               Eigen::Matrix<Scalar, 3, 1>& normal)
+#   
+#   /** \brief Flip (in place) the estimated normal of a point towards a given viewpoint
+#     * \param point a given point
+#     * \param vp_x the X coordinate of the viewpoint
+#     * \param vp_y the X coordinate of the viewpoint
+#     * \param vp_z the X coordinate of the viewpoint
+#     * \param nx the resultant X component of the plane normal
+#     * \param ny the resultant Y component of the plane normal
+#     * \param nz the resultant Z component of the plane normal
+#     * \ingroup features
+#     */
+#   template <typename PointT> inline void
+#   flipNormalTowardsViewpoint (const PointT &point, float vp_x, float vp_y, float vp_z,
+#                               float &nx, float &ny, float &nz)
+#
+
+# template <typename PointInT, typename PointOutT>
+# class NormalEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+    cdef cppclass NormalEstimation[In, Out](Feature[In, Out]):
+        NormalEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudConstPtr PointCloudConstPtr;
+        
+        # * \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+        # * and return the estimated plane parameters together with the surface curvature.
+        # * \param cloud the input point cloud
+        # * \param indices the point cloud indices that need to be used
+        # * \param plane_parameters the plane parameters as: a, b, c, d (ax + by + cz + d = 0)
+        # * \param curvature the estimated surface curvature as a measure of
+        # * \f[
+        # * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+        # * \f]
+        # inline void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, Eigen::Vector4f &plane_parameters, float &curvature)
+        # void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, eigen3.Vector4f &plane_parameters, float &curvature)
+        
+        # * \brief Compute the Least-Squares plane fit for a given set of points, using their indices,
+        # * and return the estimated plane parameters together with the surface curvature.
+        # * \param cloud the input point cloud
+        # * \param indices the point cloud indices that need to be used
+        # * \param nx the resultant X component of the plane normal
+        # * \param ny the resultant Y component of the plane normal
+        # * \param nz the resultant Z component of the plane normal
+        # * \param curvature the estimated surface curvature as a measure of
+        # * \f[
+        # * \lambda_0 / (\lambda_0 + \lambda_1 + \lambda_2)
+        # * \f]
+        # inline void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, float &nx, float &ny, float &nz, float &curvature)
+        void computePointNormal (const cpp.PointCloud[In] &cloud, const vector[int] &indices, float &nx, float &ny, float &nz, float &curvature)
+        
+        # * \brief Provide a pointer to the input dataset
+        # * \param cloud the const boost shared pointer to a PointCloud message
+        # virtual inline void setInputCloud (const PointCloudConstPtr &cloud)
+        # * \brief Set the viewpoint.
+        # * \param vpx the X coordinate of the viewpoint
+        # * \param vpy the Y coordinate of the viewpoint
+        # * \param vpz the Z coordinate of the viewpoint
+        inline void setViewPoint (float vpx, float vpy, float vpz)
+        
+        # * \brief Get the viewpoint.
+        # * \param [out] vpx x-coordinate of the view point
+        # * \param [out] vpy y-coordinate of the view point
+        # * \param [out] vpz z-coordinate of the view point
+        # * \note this method returns the currently used viewpoint for normal flipping.
+        # * If the viewpoint is set manually using the setViewPoint method, this method will return the set view point coordinates.
+        # * If an input cloud is set, it will return the sensor origin otherwise it will return the origin (0, 0, 0)
+        inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        
+        # * \brief sets whether the sensor origin or a user given viewpoint should be used. After this method, the 
+        # * normal estimation method uses the sensor origin of the input cloud.
+        # * to use a user defined view point, use the method setViewPoint
+        inline void useSensorOriginAsViewPoint ()
+        
+ctypedef NormalEstimation[cpp.PointXYZ, cpp.Normal] NormalEstimation_t
+ctypedef NormalEstimation[cpp.PointXYZI, cpp.Normal] NormalEstimation_PointXYZI_t
+ctypedef NormalEstimation[cpp.PointXYZRGB, cpp.Normal] NormalEstimation_PointXYZRGB_t
+ctypedef NormalEstimation[cpp.PointXYZRGBA, cpp.Normal] NormalEstimation_PointXYZRGBA_t
+
+###
+
+# template <typename PointInT>
+# class NormalEstimation<PointInT, Eigen::MatrixXf>: public NormalEstimation<PointInT, pcl::Normal>
+# cdef extern from "pcl/features/normal_3d.h" namespace "pcl":
+#     cdef cppclass NormalEstimation[In, Eigen::MatrixXf](NormalEstimation[In, pcl::Normal]):
+#         NormalEstimation ()
+#     public:
+#       using NormalEstimation<PointInT, pcl::Normal>::indices_;
+#       using NormalEstimation<PointInT, pcl::Normal>::input_;
+#       using NormalEstimation<PointInT, pcl::Normal>::surface_;
+#       using NormalEstimation<PointInT, pcl::Normal>::k_;
+#       using NormalEstimation<PointInT, pcl::Normal>::search_parameter_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpx_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpy_;
+#       using NormalEstimation<PointInT, pcl::Normal>::vpz_;
+#       using NormalEstimation<PointInT, pcl::Normal>::computePointNormal;
+#       using NormalEstimation<PointInT, pcl::Normal>::compute;
+###
+
+# normal_3d_omp.h
+# template <typename PointInT, typename PointOutT>
+# class NormalEstimationOMP: public NormalEstimation<PointInT, PointOutT>
+cdef extern from "pcl/features/normal_3d_omp.h" namespace "pcl":
+    cdef cppclass NormalEstimationOMP[In, Out](NormalEstimation[In, Out]):
+        NormalEstimationOMP ()
+        NormalEstimationOMP (unsigned int nr_threads)
+        # public:
+        # using NormalEstimation<PointInT, PointOutT>::feature_name_;
+        # using NormalEstimation<PointInT, PointOutT>::getClassName;
+        # using NormalEstimation<PointInT, PointOutT>::indices_;
+        # using NormalEstimation<PointInT, PointOutT>::input_;
+        # using NormalEstimation<PointInT, PointOutT>::k_;
+        # using NormalEstimation<PointInT, PointOutT>::search_parameter_;
+        # using NormalEstimation<PointInT, PointOutT>::surface_;
+        # using NormalEstimation<PointInT, PointOutT>::getViewPoint;
+        # typedef typename NormalEstimation<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # public:
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        #     * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # */
+        inline void setNumberOfThreads (unsigned int nr_threads)
+###
+
+# template <typename PointInT>
+# class NormalEstimationOMP<PointInT, Eigen::MatrixXf>: public NormalEstimationOMP<PointInT, pcl::Normal>
+#     public:
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::indices_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::search_parameter_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::k_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::input_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::surface_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::getViewPoint;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::threads_;
+#       using NormalEstimationOMP<PointInT, pcl::Normal>::compute;
+# 
+#       /** \brief Default constructor.
+#         */
+#       NormalEstimationOMP () : NormalEstimationOMP<PointInT, pcl::Normal> () {}
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       NormalEstimationOMP (unsigned int nr_threads) : NormalEstimationOMP<PointInT, pcl::Normal> (nr_threads) {}
+# 
+
+
+###
+
+# normal_based_signature.h
+# template <typename PointT, typename PointNT, typename PointFeature>
+# class NormalBasedSignatureEstimation : public FeatureFromNormals<PointT, PointNT, PointFeature>
+cdef extern from "pcl/features/normal_based_signature.h" namespace "pcl":
+    cdef cppclass NormalBasedSignatureEstimation[In, NT, Feature](FeatureFromNormals[In,  NT, Feature]):
+        NormalBasedSignatureEstimation ()
+        # public:
+        # using Feature<PointT, PointFeature>::input_;
+        # using Feature<PointT, PointFeature>::tree_;
+        # using Feature<PointT, PointFeature>::search_radius_;
+        # using PCLBase<PointT>::indices_;
+        # using FeatureFromNormals<PointT, PointNT, PointFeature>::normals_;
+        # typedef pcl::PointCloud<PointFeature> FeatureCloud;
+        # typedef typename boost::shared_ptr<NormalBasedSignatureEstimation<PointT, PointNT, PointFeature> > Ptr;
+        # typedef typename boost::shared_ptr<const NormalBasedSignatureEstimation<PointT, PointNT, PointFeature> > ConstPtr;
+        # /** \brief Setter method for the N parameter - the length of the columns used for the Discrete Fourier Transform. 
+        # * \param[in] n the length of the columns used for the Discrete Fourier Transform. 
+        inline void setN (size_t n)
+        # /** \brief Returns the N parameter - the length of the columns used for the Discrete Fourier Transform. */
+        # inline size_t getN ()
+        # /** \brief Setter method for the M parameter - the length of the rows used for the Discrete Cosine Transform.
+        # * \param[in] m the length of the rows used for the Discrete Cosine Transform.
+        inline void setM (size_t m)
+        # /** \brief Returns the M parameter - the length of the rows used for the Discrete Cosine Transform */
+        inline size_t getM ()
+        # /** \brief Setter method for the N' parameter - the number of columns to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        # * \param[in] n_prime the number of columns from the matrix of DFT and DCT that will be contained in the output
+        inline void setNPrime (size_t n_prime)
+        # /** \brief Returns the N' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        inline size_t getNPrime ()
+        # * \brief Setter method for the M' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        # * \param[in] m_prime the number of rows from the matrix of DFT and DCT that will be contained in the output
+        inline void setMPrime (size_t m_prime)
+        # * \brief Returns the M' parameter - the number of rows to be taken from the matrix of DFT and DCT
+        # * values that will be contained in the output feature vector
+        # * \note This value directly influences the dimensions of the type of output points (PointFeature)
+        inline size_t getMPrime ()
+        # * \brief Setter method for the scale parameter - used to determine the radius of the sampling disc around the
+        # * point of interest - linked to the smoothing scale of the input cloud
+        inline void setScale (float scale)
+        # * \brief Returns the scale parameter - used to determine the radius of the sampling disc around the
+        # * point of interest - linked to the smoothing scale of the input cloud
+        inline float getScale ()
+###
+
+# pfh.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PFHSignature125>
+# class PFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/pfh.h" namespace "pcl":
+    cdef cppclass PFHEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PFHEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn  PointCloudIn;
+        # * \brief Set the maximum internal cache size. Defaults to 2GB worth of entries.
+        # * \param[in] cache_size maximum cache size 
+        inline void setMaximumCacheSize (unsigned int cache_size)
+        # /** \brief Get the maximum internal cache size. */
+        inline unsigned int getMaximumCacheSize ()
+        # * \brief Set whether to use an internal cache mechanism for removing redundant calculations or not. 
+        # * \note Depending on how the point cloud is ordered and how the nearest
+        # * neighbors are estimated, using a cache could have a positive or a
+        # * negative influence. Please test with and without a cache on your
+        # * data, and choose whatever works best!
+        # * See \ref setMaximumCacheSize for setting the maximum cache size
+        # * \param[in] use_cache set to true to use the internal cache, false otherwise
+        inline void setUseInternalCache (bool use_cache)
+        # /** \brief Get whether the internal cache is used or not for computing the PFH features. */
+        inline bool getUseInternalCache ()
+        # * \brief Compute the 4-tuple representation containing the three angles and one distance between two points
+        # * represented by Cartesian coordinates and normals.
+        # * \note For explanations about the features, please see the literature mentioned above (the order of the
+        # * features might be different).
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals (assuming normalized vectors) at each point in cloud
+        # * \param[in] p_idx the index of the first point (source)
+        # * \param[in] q_idx the index of the second point (target)
+        # * \param[out] f1 the first angular feature (angle between the projection of nq_idx and u)
+        # * \param[out] f2 the second angular feature (angle between nq_idx and v)
+        # * \param[out] f3 the third angular feature (angle between np_idx and |p_idx - q_idx|)
+        # * \param[out] f4 the distance feature (p_idx - q_idx)
+        # * \note For efficiency reasons, we assume that the point data passed to the method is finite.
+        bool computePairFeatures (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals, 
+                                    int p_idx, int q_idx, float &f1, float &f2, float &f3, float &f4);
+        # * \brief Estimate the PFH (Point Feature Histograms) individual signatures of the three angular (f1, f2, f3)
+        # * features for a given point based on its spatial neighborhood of 3D points with normals
+        # * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        # * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        # * \param[in] indices the k-neighborhood point indices in the dataset
+        # * \param[in] nr_split the number of subdivisions for each angular feature interval
+        # * \param[out] pfh_histogram the resultant (combinatorial) PFH histogram representing the feature at the query point
+        # void computePointPFHSignature (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals, 
+        #                         const vector[int] &indices, int nr_split, Eigen::VectorXf &pfh_histogram);
+
+
+###
+
+# template <typename PointInT, typename PointNT>
+# class PFHEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>
+#     public:
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::pfh_histogram_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::nr_subdiv_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::k_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::indices_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::search_parameter_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::surface_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::input_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::normals_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::computePointPFHSignature;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::compute;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::feature_map_;
+#       using PFHEstimation<PointInT, PointNT, pcl::PFHSignature125>::key_list_;
+
+###
+
+# pfhrgb.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PFHRGBSignature250>
+# class PFHRGBEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/pfhrgb.h" namespace "pcl":
+    cdef cppclass PFHRGBEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PFHRGBEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        bool computeRGBPairFeatures (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals,
+                              int p_idx, int q_idx,
+                              float &f1, float &f2, float &f3, float &f4, float &f5, float &f6, float &f7)
+        # void computePointPFHRGBSignature (const cpp.PointCloud[In] &cloud, const cpp.PointCloud[NT] &normals,
+        #                            const vector[int] &indices, int nr_split, Eigen::VectorXf &pfhrgb_histogram)
+
+
+###
+
+# ppf.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/ppf.h" namespace "pcl":
+    cdef cppclass PPFEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PPFEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+
+# template <typename PointInT, typename PointNT>
+# class PPFEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PPFEstimation<PointInT, PointNT, pcl::PPFSignature>
+#     public:
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::getClassName;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::input_;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::normals_;
+#       using PPFEstimation<PointInT, PointNT, pcl::PPFSignature>::indices_;
+# 
+###
+
+# ppfrgb.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFRGBEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/ppfrgb.h" namespace "pcl":
+    cdef cppclass PPFRGBEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PPFRGBEstimation ()
+        # public:
+        # using PCLBase<PointInT>::indices_;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class PPFRGBRegionEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+#       PPFRGBRegionEstimation ();
+#     public:
+#       using PCLBase<PointInT>::indices_;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::tree_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       typedef pcl::PointCloud<PointOutT> PointCloudOut;
+###
+
+# principal_curvatures.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::PrincipalCurvatures>
+# class PrincipalCurvaturesEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/principal_curvatures.h" namespace "pcl":
+    cdef cppclass PrincipalCurvaturesEstimation[In, NT, Out](FeatureFromNormals[In,  NT, Out]):
+        PrincipalCurvaturesEstimation ()
+#       public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       /** \brief Perform Principal Components Analysis (PCA) on the point normals of a surface patch in the tangent
+#        *  plane of the given point normal, and return the principal curvature (eigenvector of the max eigenvalue),
+#        *  along with both the max (pc1) and min (pc2) eigenvalues
+#        * \param[in] normals the point cloud normals
+#        * \param[in] p_idx the query point at which the least-squares plane was estimated
+#        * \param[in] indices the point cloud indices that need to be used
+#        * \param[out] pcx the principal curvature X direction
+#        * \param[out] pcy the principal curvature Y direction
+#        * \param[out] pcz the principal curvature Z direction
+#        * \param[out] pc1 the max eigenvalue of curvature
+#        * \param[out] pc2 the min eigenvalue of curvature
+#        */
+#       void computePointPrincipalCurvatures (const pcl::PointCloud<PointNT> &normals,
+#                                        int p_idx, const std::vector<int> &indices,
+#                                        float &pcx, float &pcy, float &pcz, float &pc1, float &pc2);
+
+# template <typename PointInT, typename PointNT>
+# class PrincipalCurvaturesEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>
+#     public:
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::indices_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::k_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::search_parameter_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::surface_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::compute;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::input_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::normals_;
+###
+
+# range_image_border_extractor.h
+# namespace pcl
+# class RangeImage;
+# template <typename PointType>
+# class PointCloud;
+
+# class PCL_EXPORTS RangeImageBorderExtractor : public Feature<PointWithRange, BorderDescription>
+cdef extern from "pcl/features/range_image_border_extractor.h" namespace "pcl":
+    cdef cppclass RangeImageBorderExtractor(Feature[cpp.PointWithRange, cpp.BorderDescription]):
+        RangeImageBorderExtractor ()
+        RangeImageBorderExtractor (const pcl_r_img.RangeImage range_image)
+        # =====CONSTRUCTOR & DESTRUCTOR=====
+        # Constructor
+        # RangeImageBorderExtractor (const RangeImage* range_image = NULL)
+        # /** Destructor */
+        # ~RangeImageBorderExtractor ();
+        # 
+        
+        # public:
+        # // =====PUBLIC STRUCTS=====
+        # Stores some information extracted from the neighborhood of a point
+        # struct LocalSurface
+        # {
+        #   LocalSurface () : 
+        #     normal (), neighborhood_mean (), eigen_values (), normal_no_jumps (), 
+        #     neighborhood_mean_no_jumps (), eigen_values_no_jumps (), max_neighbor_distance_squared () {}
+        # 
+        #   Eigen::Vector3f normal;
+        #   Eigen::Vector3f neighborhood_mean;
+        #   Eigen::Vector3f eigen_values;
+        #   Eigen::Vector3f normal_no_jumps;
+        #   Eigen::Vector3f neighborhood_mean_no_jumps;
+        #   Eigen::Vector3f eigen_values_no_jumps;
+        #   float max_neighbor_distance_squared;
+        # };
+        
+        # Stores the indices of the shadow border corresponding to obstacle borders
+        # struct ShadowBorderIndices 
+        # {
+        #   ShadowBorderIndices () : left (-1), right (-1), top (-1), bottom (-1) {}
+        #   int left, right, top, bottom;
+        # };
+        
+        # Parameters used in this class
+        # struct Parameters
+        # {
+        #   Parameters () : max_no_of_threads(1), pixel_radius_borders (3), pixel_radius_plane_extraction (2), pixel_radius_border_direction (2), 
+        #                  minimum_border_probability (0.8f), pixel_radius_principal_curvature (2) {}
+        #   int max_no_of_threads;
+        #   int pixel_radius_borders;
+        #   int pixel_radius_plane_extraction;
+        #   int pixel_radius_border_direction;
+        #   float minimum_border_probability;
+        #   int pixel_radius_principal_curvature;
+        # };
+        
+        # =====STATIC METHODS=====
+        # brief Take the information from BorderTraits to calculate the local direction of the border
+        # param border_traits contains the information needed to calculate the border angle
+        # 
+        # static inline float getObstacleBorderAngle (const BorderTraits& border_traits);
+        
+        # // =====METHODS=====
+        # /** \brief Provide a pointer to the range image
+        #   * \param range_image a pointer to the range_image
+        # void setRangeImage (const RangeImage* range_image);
+        void setRangeImage (const pcl_r_img.RangeImage range_image)
+        
+        # brief Erase all data calculated for the current range image
+        void clearData ()
+        
+        # brief Get the 2D directions in the range image from the border directions - probably mainly useful for 
+        # visualization 
+        # float* getAnglesImageForBorderDirections ();
+        # float[] getAnglesImageForBorderDirections ()
+        
+        # brief Get the 2D directions in the range image from the surface change directions - probably mainly useful for visualization 
+        # float* getAnglesImageForSurfaceChangeDirections ();
+        # float[] getAnglesImageForSurfaceChangeDirections ()
+        
+        # /** Overwrite the compute function of the base class */
+        # void compute (PointCloudOut& output);
+        # void compute (cpp.PointCloud[Out]& output)
+        
+        # =====GETTER=====
+        # Parameters& getParameters () { return (parameters_); }
+        # Parameters& getParameters ()
+        # 
+        # bool hasRangeImage () const { return range_image_ != NULL; }
+        bool hasRangeImage ()
+        
+        # const RangeImage& getRangeImage () const { return *range_image_; }
+        const pcl_r_img.RangeImage getRangeImage ()
+        
+        # float* getBorderScoresLeft ()   { extractBorderScoreImages (); return border_scores_left_; }
+        # float* getBorderScoresRight ()  { extractBorderScoreImages (); return border_scores_right_; }
+        # float* getBorderScoresTop ()    { extractBorderScoreImages (); return border_scores_top_; }
+        # float* getBorderScoresBottom () { extractBorderScoreImages (); return border_scores_bottom_; }
+        # 
+        # LocalSurface** getSurfaceStructure () { extractLocalSurfaceStructure (); return surface_structure_; }
+        # PointCloudOut& getBorderDescriptions () { classifyBorders (); return *border_descriptions_; }
+        # ShadowBorderIndices** getShadowBorderInformations () { findAndEvaluateShadowBorders (); return shadow_border_informations_; }
+        # Eigen::Vector3f** getBorderDirections () { calculateBorderDirections (); return border_directions_; }
+        # float* getSurfaceChangeScores () { calculateSurfaceChanges (); return surface_change_scores_; }
+        # Eigen::Vector3f* getSurfaceChangeDirections () { calculateSurfaceChanges (); return surface_change_directions_; }
+
+
+###
+
+# rift.h
+# template <typename PointInT, typename GradientT, typename PointOutT>
+# class RIFTEstimation: public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/rift.h" namespace "pcl":
+    cdef cppclass RIFTEstimation[In, GradientT, Out](Feature[In, Out]):
+        RIFTEstimation ()
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<GradientT> PointCloudGradient;
+        # typedef typename PointCloudGradient::Ptr PointCloudGradientPtr;
+        # typedef typename PointCloudGradient::ConstPtr PointCloudGradientConstPtr;
+        # typedef typename boost::shared_ptr<RIFTEstimation<PointInT, GradientT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const RIFTEstimation<PointInT, GradientT, PointOutT> > ConstPtr;
+        
+        # brief Provide a pointer to the input gradient data
+        # param[in] gradient a pointer to the input gradient data
+        # inline void setInputGradient (const PointCloudGradientConstPtr &gradient)
+        
+        # /** \brief Returns a shared pointer to the input gradient data */
+        # inline PointCloudGradientConstPtr getInputGradient () const 
+        
+        # brief Set the number of bins to use in the distance dimension of the RIFT descriptor
+        # param[in] nr_distance_bins the number of bins to use in the distance dimension of the RIFT descriptor
+        # inline void setNrDistanceBins (int nr_distance_bins)
+        
+        # /** \brief Returns the number of bins in the distance dimension of the RIFT descriptor. */
+        # inline int getNrDistanceBins () const
+        
+        # /** \brief Set the number of bins to use in the gradient orientation dimension of the RIFT descriptor
+        # * \param[in] nr_gradient_bins the number of bins to use in the gradient orientation dimension of the RIFT descriptor
+        # inline void setNrGradientBins (int nr_gradient_bins)
+        
+        # /** \brief Returns the number of bins in the gradient orientation dimension of the RIFT descriptor. */
+        # inline int getNrGradientBins () const
+        
+        # /** \brief Estimate the Rotation Invariant Feature Transform (RIFT) descriptor for a given point based on its 
+        # * spatial neighborhood of 3D points and the corresponding intensity gradient vector field
+        # * \param[in] cloud the dataset containing the Cartesian coordinates of the points
+        # * \param[in] gradient the dataset containing the intensity gradient at each point in \a cloud
+        # * \param[in] p_idx the index of the query point in \a cloud (i.e. the center of the neighborhood)
+        # * \param[in] radius the radius of the RIFT feature
+        # * \param[in] indices the indices of the points that comprise \a p_idx's neighborhood in \a cloud
+        # * \param[in] squared_distances the squared distances from the query point to each point in the neighborhood
+        # * \param[out] rift_descriptor the resultant RIFT descriptor
+        # void computeRIFT (const PointCloudIn &cloud, const PointCloudGradient &gradient, int p_idx, float radius,
+        #            const std::vector<int> &indices, const std::vector<float> &squared_distances, 
+        #            Eigen::MatrixXf &rift_descriptor);
+
+
+# ctypedef
+# 
+###
+
+# template <typename PointInT, typename GradientT>
+# class RIFTEstimation<PointInT, GradientT, Eigen::MatrixXf>: public RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >
+#     public:
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::getClassName;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::surface_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::indices_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::tree_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::search_radius_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::gradient_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::nr_gradient_bins_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::nr_distance_bins_;
+#       using RIFTEstimation<PointInT, GradientT, pcl::Histogram<32> >::compute;
+###
+
+# shot.h
+# template <typename PointInT, typename PointNT, typename PointOutT, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimationBase : public FeatureFromNormals<PointInT, PointNT, PointOutT>,
+#                            public FeatureWithLocalReferenceFrames<PointInT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTEstimationBase[In, NT, Out, RET](Feature[In, Out]):
+        SHOTEstimationBase ()
+#     public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#     protected:
+#       /** \brief Empty constructor.
+#         * \param[in] nr_shape_bins the number of bins in the shape histogram
+#         */
+#       SHOTEstimationBase (int nr_shape_bins = 10) :
+#         nr_shape_bins_ (nr_shape_bins),
+#         shot_ (),
+#         sqradius_ (0), radius3_4_ (0), radius1_4_ (0), radius1_2_ (0),
+#         nr_grid_sector_ (32),
+#         maxAngularSectors_ (28),
+#         descLength_ (0)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+#     public:
+#        /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#          * \param[in] index the index of the point in indices_
+#          * \param[in] indices the k-neighborhood point indices in surface_
+#          * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#          * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#          */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot) = 0;
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT352, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimation : public SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTEstimation[In, NT, Out, RFT](SHOTEstimationBase[In, NT, Out, RFT]):
+        SHOTEstimation ()
+#     public:
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::indices_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::k_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::surface_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::input_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::normals_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<..., pcl::SHOT, ...> IS DEPRECATED, USE SHOTEstimation<..., pcl::SHOT352, ...> INSTEAD")
+# <PointInT, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>
+# cdef extern from "pcl/features/shot.h" namespace "pcl":
+#    cdef cppclass PCL_DEPRECATED_CLASS[In, NT, RFT](SHOTEstimation[In, NT, pcl::SHOT, RFT]):
+#        SHOTEstimation ()
+#     public:
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::normals_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudIn PointCloudIn;
+#
+#       /** \brief Empty constructor.
+#         * \param[in] nr_shape_bins the number of bins in the shape histogram
+#         */
+#       SHOTEstimation (int nr_shape_bins = 10) : SHOTEstimationBase<PointInT, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+# 
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class SHOTEstimation<PointInT, PointNT, Eigen::MatrixXf, PointRFT> : public SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>
+#     public:
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::feature_name_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::getClassName;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::indices_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::k_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::search_parameter_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::search_radius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::surface_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::input_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::normals_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::descLength_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::sqradius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius3_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius1_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::radius1_2_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::shot_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTEstimation (int nr_shape_bins = 10) : SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT> ()
+#       {
+#         feature_name_ = "SHOTEstimation";
+#         nr_shape_bins_ = nr_shape_bins;
+#       };
+# 
+#       /** \brief Base method for feature estimation for all points given in
+#         * <setInputCloud (), setIndices ()> using the surface in setSearchSurface ()
+#         * and the spatial locator in setSearchMethod ()
+#         * \param[out] output the resultant point cloud model dataset containing the estimated features
+#         */
+#       void
+#       computeEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+#       {
+#         pcl::SHOTEstimation<PointInT, PointNT, pcl::SHOT352, PointRFT>::computeEigen (output);
+#       }
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       //virtual void
+#       //computePointSHOT (const int index,
+#                         //const std::vector<int> &indices,
+#                         //const std::vector<float> &sqr_dists,
+#                         //Eigen::VectorXf &shot);
+# 
+#       void computeFeatureEigen (pcl::PointCloud<Eigen::MatrixXf> &output);
+# 
+#     
+#       /** \brief Make the compute (&PointCloudOut); inaccessible from outside the class
+#         * \param[out] output the output point cloud
+#         */
+#       void compute (pcl::PointCloud<pcl::SHOT352> &) { assert(0); }
+#   };
+
+
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT1344, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTColorEstimation : public SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot.h" namespace "pcl":
+    cdef cppclass SHOTColorEstimation[In, NT, Out, RFT](SHOTEstimationBase[In, NT, Out, RFT]):
+        SHOTColorEstimation ()
+        #       SHOTColorEstimation (bool describe_shape = true,
+        #                            bool describe_color = true)
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::feature_name_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::getClassName;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::indices_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::k_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_parameter_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::search_radius_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::surface_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::input_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::normals_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::maxAngularSectors_;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::interpolateSingleChannel;
+        #       using SHOTEstimationBase<PointInT, PointNT, PointOutT, PointRFT>::shot_;
+        #       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+        #       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # 
+        #       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+        #         * \param[in] index the index of the point in indices_
+        #         * \param[in] indices the k-neighborhood point indices in surface_
+        #         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+        #         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+        #         */
+        #       virtual void
+        #       computePointSHOT (const int index,
+        #                         const std::vector<int> &indices,
+        #                         const std::vector<float> &sqr_dists,
+        #                         Eigen::VectorXf &shot);
+        #     public:
+        #       /** \brief Converts RGB triplets to CIELab space.
+        #         * \param[in] R the red channel
+        #         * \param[in] G the green channel
+        #         * \param[in] B the blue channel
+        #         * \param[out] L the lightness
+        #         * \param[out] A the first color-opponent dimension
+        #         * \param[out] B2 the second color-opponent dimension
+        #         */
+        #       static void
+        #       RGB2CIELAB (unsigned char R, unsigned char G, unsigned char B, float &L, float &A, float &B2);
+        # 
+        #       static float sRGB_LUT[256];
+        #       static float sXYZ_LUT[4000];
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class SHOTColorEstimation<PointInT, PointNT, Eigen::MatrixXf, PointRFT> : public SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>
+# cdef extern from "pcl/features/shot.h" namespace "pcl":
+#     cdef cppclass SHOTColorEstimation[In, NT, Out, RFT](SHOTColorEstimation[In, NT, Out, RFT]):
+#         SHOTColorEstimation ()
+#     public:
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::feature_name_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::getClassName;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::indices_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::k_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::search_parameter_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::search_radius_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::surface_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::input_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::normals_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::descLength_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_grid_sector_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_shape_bins_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::sqradius_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius3_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius1_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::radius1_2_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::maxAngularSectors_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::interpolateSingleChannel;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::shot_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::b_describe_shape_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::b_describe_color_;
+#       using SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::nr_color_bins_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         */
+#       SHOTColorEstimation (bool describe_shape = true,
+#                            bool describe_color = true,
+#                            int nr_shape_bins = 10,
+#                            int nr_color_bins = 30)
+#         : SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT> (describe_shape, describe_color)
+#       {
+#         feature_name_ = "SHOTColorEstimation";
+#         nr_shape_bins_ = nr_shape_bins;
+#         nr_color_bins_ = nr_color_bins;
+#       };
+# 
+#       /** \brief Base method for feature estimation for all points given in
+#         * <setInputCloud (), setIndices ()> using the surface in setSearchSurface ()
+#         * and the spatial locator in setSearchMethod ()
+#         * \param[out] output the resultant point cloud model dataset containing the estimated features
+#         */
+#       void
+#       computeEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+#       {
+#         pcl::SHOTColorEstimation<PointInT, PointNT, pcl::SHOT1344, PointRFT>::computeEigen (output);
+#       }
+# 
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<pcl::PointXYZRGBA,...,pcl::SHOT,...> IS DEPRECATED, USE SHOTEstimation<pcl::PointXYZRGBA,...,pcl::SHOT352,...> FOR SHAPE AND SHOTColorEstimation<pcl::PointXYZRGBA,...,pcl::SHOT1344,...> FOR SHAPE+COLOR INSTEAD")
+#   <pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#   : public SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> 
+#     public:
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using FeatureFromNormals<pcl::PointXYZRGBA, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::shot_;
+# 
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         * \param[in] nr_shape_bins
+#         * \param[in] nr_color_bins
+#         */
+#       SHOTEstimation (bool describe_shape = true,
+#                       bool describe_color = false,
+#                       const int nr_shape_bins = 10,
+#                       const int nr_color_bins = 30)
+#         : SHOTEstimationBase<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins),
+#           b_describe_shape_ (describe_shape),
+#           b_describe_color_ (describe_color),
+#           nr_color_bins_ (nr_color_bins)
+#       {
+#         feature_name_ = "SHOTEstimation";
+#       };
+# 
+#       /** \brief Estimate the SHOT descriptor for a given point based on its spatial neighborhood of 3D points with normals
+#         * \param[in] index the index of the point in indices_
+#         * \param[in] indices the k-neighborhood point indices in surface_
+#         * \param[in] sqr_dists the k-neighborhood point distances in surface_
+#         * \param[out] shot the resultant SHOT descriptor representing the feature at the query point
+#         */
+#       virtual void
+#       computePointSHOT (const int index,
+#                         const std::vector<int> &indices,
+#                         const std::vector<float> &sqr_dists,
+#                         Eigen::VectorXf &shot);
+#       /** \brief Quadrilinear interpolation; used when color and shape descriptions are both activated
+#         * \param[in] indices the neighborhood point indices
+#         * \param[in] sqr_dists the neighborhood point distances
+#         * \param[in] index the index of the point in indices_
+#         * \param[out] binDistanceShape the resultant distance shape histogram
+#         * \param[out] binDistanceColor the resultant color shape histogram
+#         * \param[in] nr_bins_shape the number of bins in the shape histogram
+#         * \param[in] nr_bins_color the number of bins in the color histogram
+#         * \param[out] shot the resultant SHOT histogram
+#         */
+#       void
+#       interpolateDoubleChannel (const std::vector<int> &indices,
+#                                 const std::vector<float> &sqr_dists,
+#                                 const int index,
+#                                 std::vector<double> &binDistanceShape,
+#                                 std::vector<double> &binDistanceColor,
+#                                 const int nr_bins_shape,
+#                                 const int nr_bins_color,
+#                                 Eigen::VectorXf &shot);
+# 
+#       /** \brief Converts RGB triplets to CIELab space.
+#         * \param[in] R the red channel
+#         * \param[in] G the green channel
+#         * \param[in] B the blue channel
+#         * \param[out] L the lightness
+#         * \param[out] A the first color-opponent dimension
+#         * \param[out] B2 the second color-opponent dimension
+#         */
+#       static void
+#       RGB2CIELAB (unsigned char R, unsigned char G, unsigned char B, float &L, float &A, float &B2);
+# 
+#       /** \brief Compute shape descriptor. */
+#       bool b_describe_shape_;
+# 
+#       /** \brief Compute color descriptor. */
+#       bool b_describe_color_;
+# 
+#       /** \brief The number of bins in each color histogram. */
+#       int nr_color_bins_;
+# 
+#     public:
+#       static float sRGB_LUT[256];
+#       static float sXYZ_LUT[4000];
+#   };
+
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimation, "SHOTEstimation<pcl::PointXYZRGBA,...,Eigen::MatrixXf,...> IS DEPRECATED, USE SHOTColorEstimation<pcl::PointXYZRGBA,...,Eigen::MatrixXf,...> FOR SHAPE AND SHAPE+COLOR INSTEAD")
+# <pcl::PointXYZRGBA, PointNT, Eigen::MatrixXf, PointRFT>
+# : public SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#     public:
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::maxAngularSectors_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::interpolateSingleChannel;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::shot_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_shape_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_color_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_color_bins_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+# 
+#       /** \brief Empty constructor.
+#         * \param[in] describe_shape
+#         * \param[in] describe_color
+#         * \param[in] nr_shape_bins
+#         * \param[in] nr_color_bins
+#         */
+#       SHOTEstimation (bool describe_shape = true,
+#                       bool describe_color = false,
+#                       const int nr_shape_bins = 10,
+#                       const int nr_color_bins = 30)
+#         : SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (describe_shape, describe_color, nr_shape_bins, nr_color_bins) {};
+# 
+###
+
+# shot_lrf.h
+#  template<typename PointInT, typename PointOutT = ReferenceFrame>
+#  class SHOTLocalReferenceFrameEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/shot_lrf.h" namespace "pcl":
+    cdef cppclass SHOTLocalReferenceFrameEstimation[In, Out](Feature[In, Out]):
+        PrincipalCurvaturesEstimation ()
+        # protected:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # //using Feature<PointInT, PointOutT>::searchForNeighbors;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::tree_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # * \brief Computes disambiguated local RF for a point index
+        # * \param[in] cloud input point cloud
+        # * \param[in] search_radius the neighborhood radius
+        # * \param[in] central_point the point from the input_ cloud at which the local RF is computed
+        # * \param[in] indices the neighbours indices
+        # * \param[in] dists the squared distances to the neighbours
+        # * \param[out] rf reference frame to compute
+        # float getLocalRF (const int &index, Eigen::Matrix3f &rf)
+        # * \brief Feature estimation method.
+        # \param[out] output the resultant features
+        # virtual void computeFeature (PointCloudOut &output)
+        # * \brief Feature estimation method.
+        # * \param[out] output the resultant features
+        # virtual void computeFeatureEigen (pcl::PointCloud<Eigen::MatrixXf> &output)
+###
+
+# template <typename PointInT, typename PointNT>
+# class PrincipalCurvaturesEstimation<PointInT, PointNT, Eigen::MatrixXf> : public PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>
+#     public:
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::indices_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::k_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::search_parameter_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::surface_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::compute;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::input_;
+#       using PrincipalCurvaturesEstimation<PointInT, PointNT, pcl::PrincipalCurvatures>::normals_;
+###
+
+# shot_lrf_omp.h
+# template<typename PointInT, typename PointOutT = ReferenceFrame>
+# class SHOTLocalReferenceFrameEstimationOMP : public SHOTLocalReferenceFrameEstimation<PointInT, PointOutT>
+cdef extern from "pcl/features/shot_lrf_omp.h" namespace "pcl":
+    cdef cppclass SHOTLocalReferenceFrameEstimationOMP[In, Out](SHOTLocalReferenceFrameEstimation[In, Out]):
+        SHOTLocalReferenceFrameEstimationOMP ()
+        # public:
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (unsigned int nr_threads)
+
+###
+
+# shot_omp.h
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT352, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTEstimationOMP : public SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>
+cdef extern from "pcl/features/shot_omp.h" namespace "pcl":
+    cdef cppclass SHOTEstimationOMP[In, NT, Out, RFT](SHOTEstimation[In, NT, Out, RFT]):
+        SHOTEstimationOMP ()
+        # SHOTEstimationOMP (unsigned int nr_threads = - 1)
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::input_;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::search_parameter_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::fake_surface_;
+        # using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+        # using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+        # using SHOTEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # 
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        #  * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        inline void setNumberOfThreads (unsigned int nr_threads)
+        
+###
+
+# template <typename PointInT, typename PointNT, typename PointOutT = pcl::SHOT1344, typename PointRFT = pcl::ReferenceFrame>
+# class SHOTColorEstimationOMP : public SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>
+#     public:
+#       using Feature<PointInT, PointOutT>::feature_name_;
+#       using Feature<PointInT, PointOutT>::getClassName;
+#       using Feature<PointInT, PointOutT>::input_;
+#       using Feature<PointInT, PointOutT>::indices_;
+#       using Feature<PointInT, PointOutT>::k_;
+#       using Feature<PointInT, PointOutT>::search_parameter_;
+#       using Feature<PointInT, PointOutT>::search_radius_;
+#       using Feature<PointInT, PointOutT>::surface_;
+#       using Feature<PointInT, PointOutT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, PointOutT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::descLength_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_grid_sector_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_shape_bins_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::sqradius_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius3_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_4_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::radius1_2_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::b_describe_shape_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::b_describe_color_;
+#       using SHOTColorEstimation<PointInT, PointNT, PointOutT, PointRFT>::nr_color_bins_;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTColorEstimationOMP (bool describe_shape = true,
+#                               bool describe_color = true,
+#                               unsigned int nr_threads = - 1)
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void setNumberOfThreads (unsigned int nr_threads)
+###
+
+# template <typename PointInT, typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimationOMP, "SHOTEstimationOMP<..., pcl::SHOT, ...> IS DEPRECATED, USE SHOTEstimationOMP<..., pcl::SHOT352, ...> INSTEAD")
+# <PointInT, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>
+#     public:
+#       using Feature<PointInT, pcl::SHOT>::feature_name_;
+#       using Feature<PointInT, pcl::SHOT>::getClassName;
+#       using Feature<PointInT, pcl::SHOT>::input_;
+#       using Feature<PointInT, pcl::SHOT>::indices_;
+#       using Feature<PointInT, pcl::SHOT>::k_;
+#       using Feature<PointInT, pcl::SHOT>::search_parameter_;
+#       using Feature<PointInT, pcl::SHOT>::search_radius_;
+#       using Feature<PointInT, pcl::SHOT>::surface_;
+#       using Feature<PointInT, pcl::SHOT>::fake_surface_;
+#       using FeatureFromNormals<PointInT, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<PointInT, pcl::SHOT>::PointCloudIn PointCloudIn;
+#       /** \brief Empty constructor. */
+#       SHOTEstimationOMP (unsigned int nr_threads = - 1, int nr_shape_bins = 10)
+#         : SHOTEstimation<PointInT, PointNT, pcl::SHOT, PointRFT> (nr_shape_bins), threads_ ()
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void setNumberOfThreads (unsigned int nr_threads)
+# 
+###
+
+# template <typename PointNT, typename PointRFT>
+# class PCL_DEPRECATED_CLASS (SHOTEstimationOMP, "SHOTEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT,...> IS DEPRECATED, USE SHOTEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT352,...> FOR SHAPE AND SHOTColorEstimationOMP<pcl::PointXYZRGBA,...,pcl::SHOT1344,...> FOR SHAPE+COLOR INSTEAD")
+# <pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+# : public SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>
+#       public:
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::feature_name_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::getClassName;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::input_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::indices_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::k_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_parameter_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::search_radius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::surface_;
+#       using FeatureFromNormals<pcl::PointXYZRGBA, PointNT, pcl::SHOT>::normals_;
+#       using FeatureWithLocalReferenceFrames<pcl::PointXYZRGBA, PointRFT>::frames_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::descLength_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_grid_sector_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_shape_bins_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::sqradius_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius3_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_4_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::radius1_2_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_shape_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::b_describe_color_;
+#       using SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT>::nr_color_bins_;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudOut PointCloudOut;
+#       typedef typename Feature<pcl::PointXYZRGBA, pcl::SHOT>::PointCloudIn PointCloudIn;
+# 
+#       /** \brief Empty constructor. */
+#       SHOTEstimationOMP (bool describeShape = true,
+#                          bool describeColor = false,
+#                          unsigned int nr_threads = - 1,
+#                          const int nr_shape_bins = 10,
+#                          const int nr_color_bins = 30)
+#         : SHOTEstimation<pcl::PointXYZRGBA, PointNT, pcl::SHOT, PointRFT> (describeShape, describeColor, nr_shape_bins, nr_color_bins),
+#           threads_ ()
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void
+#       setNumberOfThreads (unsigned int nr_threads)
+###
+
+# spin_image.h
+# template <typename PointInT, typename PointNT, typename PointOutT>
+# class SpinImageEstimation : public Feature<PointInT, PointOutT>
+cdef extern from "pcl/features/spin_image.h" namespace "pcl":
+    cdef cppclass SpinImageEstimation[In, NT, Out](Feature[In, Out]):
+        SpinImageEstimation ()
+        # SpinImageEstimation (unsigned int image_width = 8,
+        #                    double support_angle_cos = 0.0,   // when 0, this is bogus, so not applied
+        #                    unsigned int min_pts_neighb = 0);
+        # public:
+        # using Feature<PointInT, PointOutT>::feature_name_;
+        # using Feature<PointInT, PointOutT>::getClassName;
+        # using Feature<PointInT, PointOutT>::indices_;
+        # using Feature<PointInT, PointOutT>::search_radius_;
+        # using Feature<PointInT, PointOutT>::k_;
+        # using Feature<PointInT, PointOutT>::surface_;
+        # using Feature<PointInT, PointOutT>::fake_surface_;
+        # using PCLBase<PointInT>::input_;
+        # typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointInT> PointCloudIn;
+        # typedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename boost::shared_ptr<SpinImageEstimation<PointInT, PointNT, PointOutT> > Ptr;
+        # typedef typename boost::shared_ptr<const SpinImageEstimation<PointInT, PointNT, PointOutT> > ConstPtr;
+        # /** \brief Sets spin-image resolution.
+        #  * \param[in] bin_count spin-image resolution, number of bins along one dimension
+        void setImageWidth (unsigned int bin_count)
+        # /** \brief Sets the maximum angle for the point normal to get to support region.
+        #   * \param[in] support_angle_cos minimal allowed cosine of the angle between 
+        #   *   the normals of input point and search surface point for the point 
+        #   *   to be retained in the support
+        void setSupportAngle (double support_angle_cos)
+        # /** \brief Sets minimal points count for spin image computation.
+        #   * \param[in] min_pts_neighb min number of points in the support to correctly estimate 
+        #   *   spin-image. If at some point the support contains less points, exception is thrown
+        void setMinPointCountInNeighbourhood (unsigned int min_pts_neighb)
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        #  * the input XYZ dataset given by \ref setInputCloud
+        #  * \attention The input normals given by \ref setInputNormals have to match
+        #  * the input point cloud given by \ref setInputCloud. This behavior is
+        #  * different than feature estimation methods that extend \ref
+        #  * FeatureFromNormals, which match the normals with the search surface.
+        #  * \param[in] normals the const boost shared pointer to a PointCloud of normals. 
+        #  * By convention, L2 norm of each normal should be 1. 
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # /** \brief Sets single vector a rotation axis for all input points.
+        #   * It could be useful e.g. when the vertical axis is known.
+        #   * \param[in] axis unit-length vector that serves as rotation axis for reference frame
+        # void setRotationAxis (const PointNT& axis)
+        # /** \brief Sets array of vectors as rotation axes for input points.
+        #  * Useful e.g. when one wants to use tangents instead of normals as rotation axes
+        #  * \param[in] axes unit-length vectors that serves as rotation axes for 
+        #  *   the corresponding input points' reference frames
+        # void setInputRotationAxes (const PointCloudNConstPtr& axes)
+        # /** \brief Sets input normals as rotation axes (default setting). */
+        void useNormalsAsRotationAxis () 
+        # /** \brief Sets/unsets flag for angular spin-image domain.
+        #   * Angular spin-image differs from the vanilla one in the way that not 
+        #   * the points are collected in the bins but the angles between their
+        #   * normals and the normal to the reference point. For further
+        #   * information please see 
+        #   * Endres, F., Plagemann, C., Stachniss, C., & Burgard, W. (2009). 
+        #   * Unsupervised Discovery of Object Classes from Range Data using Latent Dirichlet Allocation. 
+        #   * In Robotics: Science and Systems. Seattle, USA.
+        #   * \param[in] is_angular true for angular domain, false for point domain
+        void setAngularDomain (bool is_angular = true)
+        # /** \brief Sets/unsets flag for radial spin-image structure.
+        #   * 
+        #   * Instead of rectangular coordinate system for reference frame 
+        #   * polar coordinates are used. Binning is done depending on the distance and 
+        #   * inclination angle from the reference point
+        #   * \param[in] is_radial true for radial spin-image structure, false for rectangular
+        # */
+        void setRadialStructure (bool is_radial = true)
+
+
+####
+
+# template <typename PointInT, typename PointNT>
+# class SpinImageEstimation<PointInT, PointNT, Eigen::MatrixXf> : public SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >
+# cdef extern from "pcl/features/spin_image.h" namespace "pcl":
+#    cdef cppclass SpinImageEstimation[In, NT, Eigen::MatrixXf](SpinImageEstimation[In, NT, pcl::Histogram<153>]):
+#       SpinImageEstimation ()
+#       public:
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::indices_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::search_radius_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::k_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::surface_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::fake_surface_;
+#       using SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> >::compute;
+# 
+#       /** \brief Constructs empty spin image estimator.
+#         * 
+#         * \param[in] image_width spin-image resolution, number of bins along one dimension
+#         * \param[in] support_angle_cos minimal allowed cosine of the angle between 
+#         *   the normals of input point and search surface point for the point 
+#         *   to be retained in the support
+#         * \param[in] min_pts_neighb min number of points in the support to correctly estimate 
+#         *   spin-image. If at some point the support contains less points, exception is thrown
+#         */
+#       SpinImageEstimation (unsigned int image_width = 8,
+#                            double support_angle_cos = 0.0,   // when 0, this is bogus, so not applied
+#                            unsigned int min_pts_neighb = 0) : 
+#       SpinImageEstimation<PointInT, PointNT, pcl::Histogram<153> > (image_width, support_angle_cos, min_pts_neighb) {}
+###
+
+# statistical_multiscale_interest_region_extraction.h
+# template <typename PointT>
+# class StatisticalMultiscaleInterestRegionExtraction : public PCLBase<PointT>
+cdef extern from "pcl/features/statistical_multiscale_interest_region_extraction.h" namespace "pcl":
+    cdef cppclass StatisticalMultiscaleInterestRegionExtraction[T](cpp.PCLBase[T]):
+        StatisticalMultiscaleInterestRegionExtraction ()
+        # public:
+        # typedef boost::shared_ptr <std::vector<int> > IndicesPtr;
+        # typedef typename boost::shared_ptr<StatisticalMultiscaleInterestRegionExtraction<PointT> > Ptr;
+        # typedef typename boost::shared_ptr<const StatisticalMultiscaleInterestRegionExtraction<PointT> > ConstPtr;
+        
+        # brief Method that generates the underlying nearest neighbor graph based on the input point cloud
+        void generateCloudGraph ()
+        
+        # brief The method to be called in order to run the algorithm and produce the resulting
+        # set of regions of interest
+        # void computeRegionsOfInterest (list[IndicesPtr_t]& rois)
+        
+        # brief Method for setting the scale parameters for the algorithm
+        # param scale_values vector of scales to determine the size of each scaling step
+        inline void setScalesVector (vector[float] &scale_values)
+        
+        # brief Method for getting the scale parameters vector */
+        inline vector[float] getScalesVector ()
+###
+
+# usc.h
+# template <typename PointInT, typename PointOutT, typename PointRFT = pcl::ReferenceFrame>
+# class UniqueShapeContext : public Feature<PointInT, PointOutT>,
+#                            public FeatureWithLocalReferenceFrames<PointInT, PointRFT>
+# cdef extern from "pcl/features/usc.h" namespace "pcl":
+#     cdef cppclass UniqueShapeContext[In, Out, RFT](Feature[In, Out], FeatureWithLocalReferenceFrames[In, RFT]):
+#        VFHEstimation ()
+#        public:
+#        using Feature<PointInT, PointOutT>::feature_name_;
+#        using Feature<PointInT, PointOutT>::getClassName;
+#        using Feature<PointInT, PointOutT>::indices_;
+#        using Feature<PointInT, PointOutT>::search_parameter_;
+#        using Feature<PointInT, PointOutT>::search_radius_;
+#        using Feature<PointInT, PointOutT>::surface_;
+#        using Feature<PointInT, PointOutT>::fake_surface_;
+#        using Feature<PointInT, PointOutT>::input_;
+#        using Feature<PointInT, PointOutT>::searchForNeighbors;
+#        using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#        typedef typename Feature<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#        typedef typename Feature<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#        typedef typename boost::shared_ptr<UniqueShapeContext<PointInT, PointOutT, PointRFT> > Ptr;
+#        typedef typename boost::shared_ptr<const UniqueShapeContext<PointInT, PointOutT, PointRFT> > ConstPtr;
+#        /** \brief Constructor. */
+#        UniqueShapeContext () :
+#       /** \brief Set the number of bins along the azimuth
+#         * \param[in] bins the number of bins along the azimuth
+#       inline void setAzimuthBins (size_t bins)
+#       /** \return The number of bins along the azimuth. */
+#       inline size_t getAzimuthBins () const
+#       /** \brief Set the number of bins along the elevation
+#         * \param[in] bins the number of bins along the elevation
+#         */
+#       inline void setElevationBins (size_t bins)
+#       /** \return The number of bins along the elevation */
+#       inline size_t getElevationBins () const
+#       /** \brief Set the number of bins along the radii
+#         * \param[in] bins the number of bins along the radii
+#       inline void setRadiusBins (size_t bins)
+#       /** \return The number of bins along the radii direction. */
+#       inline size_t getRadiusBins () const
+#       /** The minimal radius value for the search sphere (rmin) in the original paper
+#         * \param[in] radius the desired minimal radius
+#       inline void setMinimalRadius (double radius)
+#       /** \return The minimal sphere radius. */
+#       inline double
+#       getMinimalRadius () const
+#       /** This radius is used to compute local point density
+#         * density = number of points within this radius
+#         * \param[in] radius Value of the point density search radius
+#       inline void setPointDensityRadius (double radius)
+#       /** \return The point density search radius. */
+#       inline double getPointDensityRadius () const
+#       /** Set the local RF radius value
+#         * \param[in] radius the desired local RF radius
+#       inline void setLocalRadius (double radius)
+#       /** \return The local RF radius. */
+#       inline double getLocalRadius () const
+#
+###
+
+# usc.h
+# template <typename PointInT, typename PointRFT>
+# class UniqueShapeContext<PointInT, Eigen::MatrixXf, PointRFT> : public UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>
+# cdef extern from "pcl/features/usc.h" namespace "pcl":
+#     cdef cppclass UniqueShapeContext[In, Eigen::MatrixXf, RET](UniqueShapeContext[In, pcl::SHOT, RET]):
+#       UniqueShapeContext ()
+#       public:
+#       using FeatureWithLocalReferenceFrames<PointInT, PointRFT>::frames_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::indices_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::descriptor_length_;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::compute;
+#       using UniqueShapeContext<PointInT, pcl::SHOT, PointRFT>::computePointDescriptor;
+###
+
+# vfh.h
+# template<typename PointInT, typename PointNT, typename PointOutT = pcl::VFHSignature308>
+# class VFHEstimation : public FeatureFromNormals<PointInT, PointNT, PointOutT>
+cdef extern from "pcl/features/vfh.h" namespace "pcl":
+    cdef cppclass VFHEstimation[In, NT, Out](FeatureFromNormals[In, NT, Out]):
+        VFHEstimation ()
+        # public:
+        # /** \brief Estimate the SPFH (Simple Point Feature Histograms) signatures of the angular
+        #   * (f1, f2, f3) and distance (f4) features for a given point from its neighborhood
+        #   * \param[in] centroid_p the centroid point
+        #   * \param[in] centroid_n the centroid normal
+        #   * \param[in] cloud the dataset containing the XYZ Cartesian coordinates of the two points
+        #   * \param[in] normals the dataset containing the surface normals at each point in \a cloud
+        #   * \param[in] indices the k-neighborhood point indices in the dataset
+        # void computePointSPFHSignature (const Eigen::Vector4f &centroid_p, const Eigen::Vector4f &centroid_n,
+        #                            const pcl::PointCloud<PointInT> &cloud, const pcl::PointCloud<PointNT> &normals,
+        #                            const std::vector<int> &indices);
+        # 
+        # /** \brief Set the viewpoint.
+        #   * \param[in] vpx the X coordinate of the viewpoint
+        #   * \param[in] vpy the Y coordinate of the viewpoint
+        #   * \param[in] vpz the Z coordinate of the viewpoint
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # /** \brief Get the viewpoint. */
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz)
+        # 
+        # /** \brief Set use_given_normal_
+        #   * \param[in] use Set to true if you want to use the normal passed to setNormalUse(normal)
+        #   */
+        # inline void setUseGivenNormal (bool use)
+        # 
+        # /** \brief Set the normal to use
+        #   * \param[in] normal Sets the normal to be used in the VFH computation. It is is used
+        #   * to build the Darboux Coordinate system.
+        #   */
+        # inline void setNormalToUse (const Eigen::Vector3f &normal)
+        # 
+        # /** \brief Set use_given_centroid_
+        #   * \param[in] use Set to true if you want to use the centroid passed through setCentroidToUse(centroid)
+        #   */
+        # inline void setUseGivenCentroid (bool use)
+        # 
+        # /** \brief Set centroid_to_use_
+        #   * \param[in] centroid Centroid to be used in the VFH computation. It is used to compute the distances
+        #   * from all points to this centroid.
+        #   */
+        # inline void setCentroidToUse (const Eigen::Vector3f &centroid)
+        # 
+        # /** \brief set normalize_bins_
+        #   * \param[in] normalize If true, the VFH bins are normalized using the total number of points
+        #   */
+        # inline void setNormalizeBins (bool normalize)
+        # 
+        # /** \brief set normalize_distances_
+        #   * \param[in] normalize If true, the 4th component of VFH (shape distribution component) get normalized
+        #   * by the maximum size between the centroid and the point cloud
+        #   */
+        # inline void setNormalizeDistance (bool normalize)
+        # 
+        # /** \brief set size_component_
+        #   * \param[in] fill_size True if the 4th component of VFH (shape distribution component) needs to be filled.
+        #   * Otherwise, it is set to zero.
+        #   */
+        # inline void setFillSizeComponent (bool fill_size)
+        # 
+        # /** \brief Overloaded computed method from pcl::Feature.
+        #   * \param[out] output the resultant point cloud model dataset containing the estimated features
+        #   */
+        # void compute (cpp.PointCloud[Out] &output);
+
+
+ctypedef VFHEstimation[cpp.PointXYZ, cpp.Normal, cpp.VFHSignature308] VFHEstimation_t
+ctypedef VFHEstimation[cpp.PointXYZI, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZI_t
+ctypedef VFHEstimation[cpp.PointXYZRGB, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGB_t
+ctypedef VFHEstimation[cpp.PointXYZRGBA, cpp.Normal, cpp.VFHSignature308] VFHEstimation_PointXYZRGBA_t
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+# Template
+# # enum CoordinateFrame
+# # CAMERA_FRAME = 0,
+# # LASER_FRAME = 1
+# Start
+# cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+#     ctypedef enum CoordinateFrame2 "pcl::RangeImage::CoordinateFrame":
+#         COORDINATEFRAME_CAMERA "pcl::RangeImage::CAMERA_FRAME"
+#         COORDINATEFRAME_LASER "pcl::RangeImage::LASER_FRAME"
+###
+
+# integral_image_normal.h
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#         cdef enum BorderPolicy:
+#             BORDER_POLICY_IGNORE
+#             BORDER_POLICY_MIRROR
+# NG : IntegralImageNormalEstimation use Template
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#     ctypedef enum BorderPolicy2 "pcl::IntegralImageNormalEstimation::BorderPolicy":
+#         BORDERPOLICY_IGNORE "pcl::IntegralImageNormalEstimation::BORDER_POLICY_IGNORE"
+#         BORDERPOLICY_MIRROR "pcl::IntegralImageNormalEstimation::BORDER_POLICY_MIRROR"
+###
+
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#         cdef enum NormalEstimationMethod:
+#             COVARIANCE_MATRIX
+#             AVERAGE_3D_GRADIENT
+#             AVERAGE_DEPTH_CHANGE
+#             SIMPLE_3D_GRADIENT
+# 
+# NG : IntegralImageNormalEstimation use Template
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl":
+#     ctypedef enum NormalEstimationMethod2 "pcl::IntegralImageNormalEstimation::NormalEstimationMethod":
+#         ESTIMATIONMETHOD_COVARIANCE_MATRIX "pcl::IntegralImageNormalEstimation::COVARIANCE_MATRIX"
+#         ESTIMATIONMETHOD_AVERAGE_3D_GRADIENT "pcl::IntegralImageNormalEstimation::AVERAGE_3D_GRADIENT"
+#         ESTIMATIONMETHOD_AVERAGE_DEPTH_CHANGE "pcl::IntegralImageNormalEstimation::AVERAGE_DEPTH_CHANGE"
+#         ESTIMATIONMETHOD_SIMPLE_3D_GRADIENT "pcl::IntegralImageNormalEstimation::SIMPLE_3D_GRADIENT"
+# NG : (Test Cython 0.24.1)
+# define __PYX_VERIFY_RETURN_INT/__PYX_VERIFY_RETURN_INT_EXC etc... , Convert Error "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::NormalEstimationMethod"
+# cdef extern from "pcl/features/integral_image_normal.h" namespace "pcl::IntegralImageNormalEstimation":
+#     ctypedef enum NormalEstimationMethod2 "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::NormalEstimationMethod":
+#         ESTIMATIONMETHOD_COVARIANCE_MATRIX "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::COVARIANCE_MATRIX"
+#         ESTIMATIONMETHOD_AVERAGE_3D_GRADIENT "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::AVERAGE_3D_GRADIENT"
+#         ESTIMATIONMETHOD_AVERAGE_DEPTH_CHANGE "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::AVERAGE_DEPTH_CHANGE"
+#         ESTIMATIONMETHOD_SIMPLE_3D_GRADIENT "pcl::IntegralImageNormalEstimation<pcl::PointXYZ, pcl::Normal>::SIMPLE_3D_GRADIENT"
+###
+
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_filters.pxd b/pcl/pcl_filters.pxd
new file mode 100644
index 0000000..6638b9b
--- /dev/null
+++ b/pcl/pcl_filters.pxd
@@ -0,0 +1,1497 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# import
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# conditional_removal.h
+# template<typename PointT>
+# class ComparisonBase
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ComparisonBase[T]:
+        ComparisonBase()
+        # public:
+        # ctypedef boost::shared_ptr<ComparisonBase<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ComparisonBase<PointT> > ConstPtr;
+        #
+        # brief Return if the comparison is capable.
+        bool isCapable ()
+        
+        # /** \brief Evaluate function. */
+        # virtual bool evaluate (const PointT &point) const = 0;
+
+
+ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t
+ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t
+###
+
+# conditional_removal.h
+# template<typename PointT>
+# class ConditionBase
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionBase[T]:
+        ConditionBase ()
+        # public:
+        # ctypedef typename pcl::ComparisonBase<PointT> ComparisonBase;
+        # ctypedef typename ComparisonBase::Ptr ComparisonBasePtr;
+        # ctypedef typename ComparisonBase::ConstPtr ComparisonBaseConstPtr;
+        # ctypedef boost::shared_ptr<ConditionBase<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionBase<PointT> > ConstPtr;
+        
+        # NG(Cython 24.0.1) : evaluate is virtual Function
+        # void addComparison (ComparisonBase[T] comparison)
+        # void addComparison (const ComparisonBase[T] comparison)
+        # use Cython 0.25.2
+        void addComparison (shared_ptr[ComparisonBase[T]] comparison)
+        void addCondition (shared_ptr[ConditionBase[T]] condition)
+        bool isCapable ()
+
+
+ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t
+ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t
+###
+
+# filter.h
+# template<typename PointT>
+# class Filter : public PCLBase<PointT>
+cdef extern from "pcl/filters/filter.h" namespace "pcl":
+    cdef cppclass Filter[T](cpp.PCLBase[T]):
+        Filter()
+        # public:
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::input_;
+        # ctypedef boost::shared_ptr< Filter<PointT> > Ptr;
+        # ctypedef boost::shared_ptr< const Filter<PointT> > ConstPtr;
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        
+        # /** \brief Get the point indices being removed */
+        cpp.IndicesPtr_t getRemovedIndices ()
+        # [vector[int]]* getRemovedIndices ()
+        
+        # \brief Calls the filtering method and returns the filtered dataset in output.
+        # \param[out] output the resultant filtered point cloud dataset
+        void filter (cpp.PointCloud[T] &output)
+
+
+ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t
+###
+
+# template<>
+# class PCL_EXPORTS Filter<sensor_msgs::PointCloud2> : public PCLBase<sensor_msgs::PointCloud2>
+#     public:
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       typedef PointCloud2::Ptr PointCloud2Ptr;
+#       typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       /** \brief Empty constructor. 
+#         * \param[in] extract_removed_indices set to true if the filtered data indices should be saved in a 
+#         * separate list. Default: false.
+#       Filter (bool extract_removed_indices = false)
+#       /** \brief Get the point indices being removed */
+#       IndicesConstPtr const getRemovedIndices ()
+#       /** \brief Calls the filtering method and returns the filtered dataset in output.
+#         * \param[out] output the resultant filtered point cloud dataset
+#       void filter (PointCloud2 &output);
+###
+
+# filter_indices.h
+# template<typename PointT>
+# class FilterIndices : public Filter<PointT>
+cdef extern from "pcl/filters/filter_indices.h" namespace "pcl":
+    cdef cppclass FilterIndices[T](Filter[T]):
+        FilterIndices()
+        # public:
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        
+        ## filter function
+        # same question
+        # http://stackoverflow.com/questions/37186861/sync-bool-compare-and-swap-with-different-parameter-types-in-cython
+        # taisaku : 
+        # Interfacing with External C Code
+        # http://cython-docs2.readthedocs.io/en/latest/src/userguide/external_C_code.html
+        # void filter (cpp.PointCloud[T] &output)
+        void c_filter "filter" (cpp.PointCloud[T] &output)
+        
+        # brief Calls the filtering method and returns the filtered point cloud indices.
+        # param[out] indices the resultant filtered point cloud indices
+        void filter (vector[int]& indices)
+        ## filter function
+        
+        # \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+        # \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+        void setNegative (bool negative)
+        
+        # \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+        # \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        bool getNegative ()
+        
+        # \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+        # or removed from the PointCloud, thus potentially breaking its organized structure.
+        # \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+        void setKeepOrganized (bool keep_organized)
+        
+        # brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+        # or removed from the PointCloud, thus potentially breaking its organized structure.
+        # return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+        bool getKeepOrganized ()
+        
+        # brief Provide a value that the filtered points should be set to instead of removing them.
+        # Used in conjunction with \a setKeepOrganized ().
+        # param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+        void setUserFilterValue (float value)
+        
+        # brief Get the point indices being removed
+        # return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        cpp.IndicesPtr_t getRemovedIndices ()
+
+
+###
+
+# template<>
+# class PCL_EXPORTS FilterIndices<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#       public:
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       /** \brief Constructor.
+#         * \param[in] extract_removed_indices Set to true if you want to extract the indices of points being removed (default = false).
+#       FilterIndices (bool extract_removed_indices = false) :
+# 
+#       /** \brief Empty virtual destructor. */
+#       virtual ~FilterIndices ()
+#       virtual void filter (PointCloud2 &output)
+# 
+#       /** \brief Calls the filtering method and returns the filtered point cloud indices.
+#         * \param[out] indices the resultant filtered point cloud indices
+#       void filter (vector[int] &indices)
+# 
+#       /** \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+#         * \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+#       void setNegative (bool negative)
+# 
+#       /** \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+#         * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+#       bool getNegative ()
+# 
+#       /** \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+#         * or removed from the PointCloud, thus potentially breaking its organized structure.
+#         * \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+#       void setKeepOrganized (bool keep_organized)
+# 
+#       /** \brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+#         * or removed from the PointCloud, thus potentially breaking its organized structure.
+#         * \return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+#       bool getKeepOrganized ()
+# 
+#       /** \brief Provide a value that the filtered points should be set to instead of removing them.
+#         * Used in conjunction with \a setKeepOrganized ().
+#         * \param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+#       void setUserFilterValue (float value)
+# 
+#       /** \brief Get the point indices being removed
+#         * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+#       IndicesConstPtr const getRemovedIndices ()
+
+
+###
+
+### Inheritance class ###
+
+# approximate_voxel_grid.h
+# NG ###
+# template <typename PointT>
+# struct xNdCopyEigenPointFunctor
+
+# cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+#     cdef struct xNdCopyEigenPointFunctor[T]:
+#         xNdCopyEigenPointFunctor()
+#         # ctypedef typename traits::POD<PointT>::type Pod;
+#         # xNdCopyEigenPointFunctor (const Eigen::VectorXf &p1, PointT &p2)
+#         # template<typename Key> void operator() ()
+# 
+# # template <typename PointT>
+# # struct xNdCopyPointEigenFunctor
+# cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+#     cdef struct xNdCopyPointEigenFunctor[T]:
+#         xNdCopyPointEigenFunctor()
+#         # ctypedef typename traits::POD<PointT>::type Pod;
+#         # xNdCopyPointEigenFunctor (const PointT &p1, Eigen::VectorXf &p2)
+#         # template<typename Key> void operator() ()
+# NG ###
+
+# template <typename PointT>
+# class ApproximateVoxelGrid : public Filter<PointT>
+cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+    cdef cppclass ApproximateVoxelGrid[T](Filter[T]):
+        ApproximateVoxelGrid()
+        # ApproximateVoxelGrid (const ApproximateVoxelGrid &src) : 
+        # ApproximateVoxelGrid& operator = (const ApproximateVoxelGrid &src)
+        # ApproximateVoxelGrid& element "operator()"(ApproximateVoxelGrid src)
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # * \brief Set the voxel grid leaf size.
+        # * \param[in] leaf_size the voxel grid leaf size
+        void setLeafSize (eigen3.Vector3f &leaf_size)
+        
+        # * \brief Set the voxel grid leaf size.
+        # * \param[in] lx the leaf size for X
+        # * \param[in] ly the leaf size for Y
+        # * \param[in] lz the leaf size for Z
+        void setLeafSize (float lx, float ly, float lz)
+        
+        # /** \brief Get the voxel grid leaf size. */
+        eigen3.Vector3f getLeafSize ()
+        
+        # * \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+        # * \param downsample the new value (true/false)
+        void setDownsampleAllData (bool downsample)
+        
+        # * \brief Get the state of the internal downsampling parameter (true if
+        # * all fields need to be downsampled, false if just XYZ). 
+        bool getDownsampleAllData () const
+
+
+ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t
+###
+
+# bilateral.h
+# template<typename PointT>
+# class BilateralFilter : public Filter<PointT>
+cdef extern from "pcl/filters/bilateral.h" namespace "pcl":
+    cdef cppclass BilateralFilter[T](Filter[T]):
+        BilateralFilter()
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # public:
+        # * \brief Filter the input data and store the results into output
+        # * \param[out] output the resultant point cloud message
+        void applyFilter (cpp.PointCloud[T] &output)
+        
+        # * \brief Compute the intensity average for a single point
+        # * \param[in] pid the point index to compute the weight for
+        # * \param[in] indices the set of nearest neighor indices 
+        # * \param[in] distances the set of nearest neighbor distances
+        # * \return the intensity average at a given point index
+        double  computePointWeight (const int pid, const vector[int] &indices, const vector[float] &distances)
+        
+        # * \brief Set the half size of the Gaussian bilateral filter window.
+        # * \param[in] sigma_s the half size of the Gaussian bilateral filter window to use
+        void setHalfSize (const double sigma_s)
+        
+        # * \brief Get the half size of the Gaussian bilateral filter window as set by the user. */
+        double getHalfSize ()
+        
+        # \brief Set the standard deviation parameter
+        # * \param[in] sigma_r the new standard deviation parameter
+        void setStdDev (const double sigma_r)
+        
+        # * \brief Get the value of the current standard deviation parameter of the bilateral filter. */
+        double getStdDev ()
+        
+        # * \brief Provide a pointer to the search object.
+        # * \param[in] tree a pointer to the spatial search object.
+        # void setSearchMethod (const KdTreePtr &tree)
+
+
+###
+
+# clipper3D.h
+# Override class
+# template<typename PointT>
+# class Clipper3D
+cdef extern from "pcl/filters/bilateral.h" namespace "pcl":
+    cdef cppclass Clipper3D[T]:
+        Clipper3D()
+        # public:
+        # \brief interface to clip a single point
+        # \param[in] point the point to check against
+        # * \return true, it point still exists, false if its clipped
+        # virtual bool clipPoint3D (const PointT& point) const = 0;
+        # 
+        # \brief interface to clip a line segment given by two end points. The order of the end points is unimportant and will sty the same after clipping.
+        # This means basically, that the direction of the line will not flip after clipping.
+        # \param[in,out] pt1 start point of the line
+        # \param[in,out] pt2 end point of the line
+        # \return true if the clipped line is not empty, thus the parameters are still valid, false if line completely outside clipping space
+        # virtual bool clipLineSegment3D (PointT& pt1, PointT& pt2) const = 0;
+        # 
+        # \brief interface to clip a planar polygon given by an ordered list of points
+        # \param[in,out] polygon the polygon in any direction (ccw or cw) but ordered, thus two neighboring points define an edge of the polygon
+        # virtual void clipPlanarPolygon3D (std::vector<PointT>& polygon) const = 0;
+        # 
+        # \brief interface to clip a planar polygon given by an ordered list of points
+        # \param[in] polygon the polygon in any direction (ccw or cw) but ordered, thus two neighboring points define an edge of the polygon
+        # \param[out] clipped_polygon the clipped polygon
+        # virtual void clipPlanarPolygon3D (vector[PointT]& polygon, vector[PointT]& clipped_polygon) const = 0;
+        # 
+        # \brief interface to clip a point cloud
+        # \param[in] cloud_in input point cloud
+        # \param[out] clipped indices of points that remain after clipping the input cloud
+        # \param[in] indices the indices of points in the point cloud to be clipped.
+        # \return list of indices of remaining points after clipping.
+        # virtual void clipPointCloud3D (const pcl::PointCloud<PointT> &cloud_in, std::vector<int>& clipped, const std::vector<int>& indices = std::vector<int> ()) const = 0;
+        # 
+        # \brief polymorphic method to clone the underlying clipper with its parameters.
+        # \return the new clipper object from the specific subclass with all its parameters.
+        # virtual Clipper3D<PointT>* clone () const = 0;
+
+
+###
+
+# NG ###
+# no define constructor
+# template<typename PointT>
+# class PointDataAtOffset
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+#     cdef cppclass PointDataAtOffset[T]:
+#         # PointDataAtOffset (uint8_t datatype, uint32_t offset)
+#         # int compare (const T& p, const double& val);
+
+
+###
+
+# template<typename PointT>
+# class FieldComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass FieldComparison[T](ComparisonBase[T]):
+        FieldComparison (string field_name, CompareOp2 op, double compare_val)
+        # FieldComparison (const FieldComparison &src) :
+        # FieldComparison& operator = (const FieldComparison &src)
+        # using ComparisonBase<PointT>::field_name_;
+        # using ComparisonBase<PointT>::op_;
+        # using ComparisonBase<PointT>::capable_;
+        # public:
+        # ctypedef boost::shared_ptr<FieldComparison<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const FieldComparison<PointT> > ConstPtr;
+
+
+ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t
+ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class PackedRGBComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass PackedRGBComparison[T](ComparisonBase[T]):
+        PackedRGBComparison()
+        # PackedRGBComparison (string component_name, CompareOp op, double compare_val)
+        # using ComparisonBase<PointT>::capable_;
+        # using ComparisonBase<PointT>::op_;
+        # virtual boolevaluate (const PointT &point) const;
+###
+
+# template<typename PointT>
+# class PackedHSIComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass PackedHSIComparison[T](ComparisonBase[T]):
+        PackedHSIComparison()
+        # PackedHSIComparison (string component_name, CompareOp op, double compare_val)
+        # using ComparisonBase<PointT>::capable_;
+        # using ComparisonBase<PointT>::op_;
+        # public:
+        # * \brief Construct a PackedHSIComparison 
+        # * \param component_name either "h", "s" or "i"
+        # * \param op the operator to use when making the comparison
+        # * \param compare_val the constant value to compare the component value too
+        # typedef enum
+        # {
+        #   H, // -128 to 127 corresponds to -pi to pi
+        #   S, // 0 to 255
+        #   I  // 0 to 255
+        # } ComponentId;
+###
+
+# template<typename PointT>
+# class TfQuadraticXYZComparison : public pcl::ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass TfQuadraticXYZComparison[T](ComparisonBase[T]):
+        TfQuadraticXYZComparison ()
+        # * \param op the operator "[OP]" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_matrix the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_vector the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_scalar the scalar "c" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_transform the transformation of the comparison.
+        # TfQuadraticXYZComparison (const pcl::ComparisonOps::CompareOp op, const Eigen::Matrix3f &comparison_matrix,
+        #                         const Eigen::Vector3f &comparison_vector, const float &comparison_scalar,
+        #                         const Eigen::Affine3f &comparison_transform = Eigen::Affine3f::Identity ());
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW     //needed whenever there is a fixed size Eigen:: vector or matrix in a class
+        
+        # ctypedef boost::shared_ptr<TfQuadraticXYZComparison<PointT> > Ptr;
+        # typedef boost::shared_ptr<const TfQuadraticXYZComparison<PointT> > ConstPtr;
+        # void setComparisonOperator (const pcl::ComparisonOps::CompareOp op)
+        # * \brief set the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonMatrix (const Eigen::Matrix3f &matrix)
+        
+        # * \brief set the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonMatrix (const Eigen::Matrix4f &homogeneousMatrix)
+        
+        # * \brief set the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonVector (const Eigen::Vector3f &vector)
+        
+        # * \brief set the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonVector (const Eigen::Vector4f &homogeneousVector)
+        
+        # * \brief set the scalar "c" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonScalar (const float &scalar)
+        
+        # * \brief transform the coordinate system of the comparison. If you think of
+        # * the transformation to be a translation and rotation of the comparison in the
+        # * same coordinate system, you have to provide the inverse transformation.
+        # * This function does not change the original definition of the comparison. Thus,
+        # * each call of this function will assume the original definition of the comparison
+        # * as starting point for the transformation.
+        # * @param transform the transformation (rotation and translation) as an affine matrix.
+        # void transformComparison (const Eigen::Matrix4f &transform)
+        
+        # * \brief transform the coordinate system of the comparison. If you think of
+        # * the transformation to be a translation and rotation of the comparison in the
+        # * same coordinate system, you have to provide the inverse transformation.
+        # * This function does not change the original definition of the comparison. Thus,
+        # * each call of this function will assume the original definition of the comparison
+        # * as starting point for the transformation.
+        # * @param transform the transformation (rotation and translation) as an affine matrix.
+        # void transformComparison (const Eigen::Affine3f &transform)
+        
+        # \brief Determine the result of this comparison.
+        # \param point the point to evaluate
+        # \return the result of this comparison.
+        # virtual bool evaluate (const PointT &point) const;
+
+
+###
+# NG end ###
+
+
+# template<typename PointT>
+# class ConditionAnd : public ConditionBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionAnd[T](ConditionBase[T]):
+        ConditionAnd()
+        # using ConditionBase<PointT>::conditions_;
+        # using ConditionBase<PointT>::comparisons_;
+        # public:
+        # ctypedef boost::shared_ptr<ConditionAnd<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionAnd<PointT> > ConstPtr;
+
+
+ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t
+ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class ConditionOr : public ConditionBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionOr[T](ConditionBase[T]):
+        ConditionOr()
+        # using ConditionBase<PointT>::conditions_;
+        # using ConditionBase<PointT>::comparisons_;
+        # public:
+        # ctypedef boost::shared_ptr<ConditionOr<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionOr<PointT> > ConstPtr;
+
+
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class ConditionalRemoval : public Filter<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionalRemoval[T](Filter[T]):
+        ConditionalRemoval()
+        ConditionalRemoval(int)
+        # ConditionalRemoval (ConditionBasePtr condition, bool extract_removed_indices = false)
+        # python invalid default param ?
+        ConditionalRemoval (ConditionBasePtr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZI_Ptr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZRGB_Ptr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZRGBA_Ptr_t condition, bool extract_removed_indices = false)
+        # [with PointT = pcl::PointXYZ, pcl::ConditionalRemoval<PointT>::ConditionBasePtr = boost::shared_ptr<pcl::ConditionBase<pcl::PointXYZ> >]
+        # is deprecated (declared at /usr/include/pcl-1.7/pcl/filters/conditional_removal.h:632): ConditionalRemoval(ConditionBasePtr condition, bool extract_removed_indices = false) is deprecated, 
+        # please use the setCondition (ConditionBasePtr condition) function instead. [-Wdeprecated-declarations]
+        # ConditionalRemoval (shared_ptr[]
+        
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # using Filter<PointT>::removed_indices_;
+        # using Filter<PointT>::extract_removed_indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # ctypedef typename pcl::ConditionBase<PointT> ConditionBase;
+        # ctypedef typename ConditionBase::Ptr ConditionBasePtr;
+        # ctypedef typename ConditionBase::ConstPtr ConditionBaseConstPtr;
+        void setKeepOrganized (bool val)
+        bool getKeepOrganized ()
+        void setUserFilterValue (float val)
+        # void setCondition (ConditionBasePtr condition);
+        void setCondition (ConditionBasePtr_t condition);
+        void setCondition (ConditionBase_PointXYZI_Ptr_t condition);
+        void setCondition (ConditionBase_PointXYZRGB_Ptr_t condition);
+        void setCondition (ConditionBase_PointXYZRGBA_Ptr_t condition);
+
+
+ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t
+ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t
+###
+
+# crop_box.h
+# template<typename PointT>
+# class CropBox : public FilterIndices<PointT>
+cdef extern from "pcl/filters/crop_box.h" namespace "pcl":
+    cdef cppclass CropBox[T](FilterIndices[T]):
+        CropBox()
+        
+        # public:
+        # \brief Set the minimum point of the box
+        # \param[in] min_pt the minimum point of the box
+        void setMin (const eigen3.Vector4f &min_pt)
+        
+        # brief Get the value of the minimum point of the box, as set by the user
+        # return the value of the internal \a min_pt parameter.
+        eigen3.Vector4f getMin ()
+        
+        # brief Set the maximum point of the box
+        # param[in] max_pt the maximum point of the box
+        void setMax (const eigen3.Vector4f &max_pt)
+        
+        # brief Get the value of the maxiomum point of the box, as set by the user
+        # return the value of the internal \a max_pt parameter.
+        eigen3.Vector4f getMax ()
+        
+        # brief Set a translation value for the box
+        # param[in] translation the (tx, ty, tz) values that the box should be translated by
+        void setTranslation (const eigen3.Vector3f &translation)
+        
+        # brief Get the value of the box translation parameter as set by the user.
+        eigen3.Vector3f getTranslation ()
+        
+        # brief Set a rotation value for the box
+        # param[in] rotation the (rx, ry, rz) values that the box should be rotated by
+        void setRotation (const eigen3.Vector3f &rotation)
+        
+        # brief Get the value of the box rotatation parameter, as set by the user.
+        eigen3.Vector3f getRotation ()
+        
+        # brief Set a transformation that should be applied to the cloud before filtering
+        # param[in] transform an affine transformation that needs to be applied to the cloud before filtering
+        void setTransform (const eigen3.Affine3f &transform)
+        
+        # brief Get the value of the transformation parameter, as set by the user.
+        eigen3.Affine3f getTransform ()
+
+
+ctypedef CropBox[cpp.PointXYZ] CropBox_t
+ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t
+###
+
+# Sensor
+# template<>
+# class PCL_EXPORTS CropBox<sensor_msgs::PointCloud2> : public FilterIndices<sensor_msgs::PointCloud2>
+#    using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#    using Filter<sensor_msgs::PointCloud2>::getClassName;
+#    typedef sensor_msgs::PointCloud2 PointCloud2;
+#    typedef PointCloud2::Ptr PointCloud2Ptr;
+#    typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#    public:
+#    /** \brief Empty constructor. */
+#      CropBox () :
+#      /** \brief Set the minimum point of the box
+#        * \param[in] min_pt the minimum point of the box
+#      void setMin (const Eigen::Vector4f& min_pt)
+#      /** \brief Get the value of the minimum point of the box, as set by the user
+#        * \return the value of the internal \a min_pt parameter.
+#      Eigen::Vector4f getMin () const
+#      /** \brief Set the maximum point of the box
+#        * \param[in] max_pt the maximum point of the box
+#      void setMax (const Eigen::Vector4f &max_pt)
+#      /** \brief Get the value of the maxiomum point of the box, as set by the user
+#        * \return the value of the internal \a max_pt parameter.
+#      Eigen::Vector4f getMax () const
+#      /** \brief Set a translation value for the box
+#        * \param[in] translation the (tx,ty,tz) values that the box should be translated by
+#      void setTranslation (const Eigen::Vector3f &translation)
+#      /** \brief Get the value of the box translation parameter as set by the user. */
+#      Eigen::Vector3f getTranslation () const
+#      /** \brief Set a rotation value for the box
+#        * \param[in] rotation the (rx,ry,rz) values that the box should be rotated by
+#      void setRotation (const Eigen::Vector3f &rotation)
+#      /** \brief Get the value of the box rotatation parameter, as set by the user. */
+#      Eigen::Vector3f getRotation () const
+#      /** \brief Set a transformation that should be applied to the cloud before filtering
+#        * \param[in] transform an affine transformation that needs to be applied to the cloud before filtering
+#      void setTransform (const Eigen::Affine3f &transform)
+#      /** \brief Get the value of the transformation parameter, as set by the user. */
+#      Eigen::Affine3f getTransform () const
+
+
+###
+
+# crop_hull.h
+#  template<typename PointT>
+#  class CropHull: public FilterIndices<PointT>
+cdef extern from "pcl/filters/crop_hull.h" namespace "pcl":
+    cdef cppclass CropHull[T](FilterIndices[T]):
+        CropHull()
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::indices_;
+        # using Filter<PointT>::input_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # brief Set the vertices of the hull used to filter points.
+        # param[in] polygons Vector of polygons (Vertices structures) forming
+        # the hull used for filtering points.
+        void setHullIndices (const vector[cpp.Vertices]& polygons)
+        
+        # brief Get the vertices of the hull used to filter points.
+        vector[cpp.Vertices] getHullIndices () const
+        
+        # \brief Set the point cloud that the hull indices refer to
+        # \param[in] points the point cloud that the hull indices refer to
+        # void setHullCloud (cpp.PointCloudPtr_t points)
+        void setHullCloud (shared_ptr[cpp.PointCloud[T]] points)
+        
+        #/\brief Get the point cloud that the hull indices refer to. */
+        # cpp.PointCloudPtr_t getHullCloud () const
+        shared_ptr[cpp.PointCloud[T]] getHullCloud ()
+        
+        # brief Set the dimensionality of the hull to be used.
+        # This should be set to correspond to the dimensionality of the
+        # convex/concave hull produced by the pcl::ConvexHull and
+        # pcl::ConcaveHull classes.
+        # param[in] dim Dimensionailty of the hull used to filter points.
+        void setDim (int dim)
+        
+        # \brief Remove points outside the hull (default), or those inside the hull.
+        # \param[in] crop_outside If true, the filter will remove points
+        # outside the hull. If false, those inside will be removed.
+        void setCropOutside(bool crop_outside)
+
+
+ctypedef CropHull[cpp.PointXYZ] CropHull_t
+ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t
+###
+
+# extract_indices.h
+# template<typename PointT>
+# class ExtractIndices : public FilterIndices<PointT>
+cdef extern from "pcl/filters/extract_indices.h" namespace "pcl":
+    cdef cppclass ExtractIndices[T](FilterIndices[T]):
+        ExtractIndices()
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename pcl::traits::fieldList<PointT>::type FieldList;
+        
+        # * \brief Apply the filter and store the results directly in the input cloud.
+        # * \details This method will save the time and memory copy of an output cloud but can not alter the original size of the input cloud:
+        # * It operates as though setKeepOrganized() is true and will overwrite the filtered points instead of remove them.
+        # * All fields of filtered points are replaced with the value set by setUserFilterValue() (default = NaN).
+        # * This method also automatically alters the input cloud set via setInputCloud().
+        # * It does not alter the value of the internal keep organized boolean as set by setKeepOrganized().
+        # * \param[in/out] cloud The point cloud used for input and output.
+        void filterDirectly (cpp.PointCloudPtr_t &cloud);
+
+###
+
+# template<>
+# class PCL_EXPORTS ExtractIndices<sensor_msgs::PointCloud2> : public FilterIndices<sensor_msgs::PointCloud2>
+# public:
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       typedef PointCloud2::Ptr PointCloud2Ptr;
+#       typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       /** \brief Empty constructor. */
+#       ExtractIndices ()
+#     protected:
+#       using PCLBase<PointCloud2>::input_;
+#       using PCLBase<PointCloud2>::indices_;
+#       using PCLBase<PointCloud2>::use_indices_;
+#       using Filter<PointCloud2>::filter_name_;
+#       using Filter<PointCloud2>::getClassName;
+#       using FilterIndices<PointCloud2>::negative_;
+#       using FilterIndices<PointCloud2>::keep_organized_;
+#       using FilterIndices<PointCloud2>::user_filter_value_;
+#       /** \brief Extract point indices into a separate PointCloud
+#         * \param[out] output the resultant point cloud
+#       void applyFilter (PointCloud2 &output);
+#       /** \brief Extract point indices
+#         * \param indices the resultant indices
+#       void applyFilter (std::vector<int> &indices);
+
+###
+
+# normal_space.h
+# template<typename PointT, typename NormalT>
+# class NormalSpaceSampling : public FilterIndices<PointT>
+cdef extern from "pcl/filters/normal_space.h" namespace "pcl":
+    cdef cppclass NormalSpaceSampling[T, Normal](FilterIndices[T]):
+        NormalSpaceSampling()
+        # using FilterIndices<PointT>::filter_name_;
+        # using FilterIndices<PointT>::getClassName;
+        # using FilterIndices<PointT>::indices_;
+        # using FilterIndices<PointT>::input_;
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename pcl::PointCloud<NormalT>::Ptr NormalsPtr;
+        # /** \brief Set number of indices to be sampled.
+        #   * \param[in] sample the number of sample indices
+        void setSample (unsigned int sample)
+        
+        # /** \brief Get the value of the internal \a sample parameter. */
+        unsigned int getSample () const
+        
+        #  \brief Set seed of random function.
+        #   * \param[in] seed the input seed
+        void setSeed (unsigned int seed)
+        
+        # /** \brief Get the value of the internal \a seed parameter. */
+        unsigned int getSeed () const
+        
+        # /** \brief Set the number of bins in x, y and z direction
+        #   * \param[in] binsx number of bins in x direction
+        #   * \param[in] binsy number of bins in y direction
+        #   * \param[in] binsz number of bins in z direction
+        void setBins (unsigned int binsx, unsigned int binsy, unsigned int binsz)
+        
+        # /** \brief Get the number of bins in x, y and z direction
+        #   * \param[out] binsx number of bins in x direction
+        #   * \param[out] binsy number of bins in y direction
+        #   * \param[out] binsz number of bins in z direction
+        void getBins (unsigned int& binsx, unsigned int& binsy, unsigned int& binsz) const
+        
+        # * \brief Set the normals computed on the input point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        # void setNormals (const NormalsPtr &normals)
+        # * \brief Get the normals computed on the input point cloud */
+        # NormalsPtr getNormals () const
+###
+
+# passthrough.h
+# template <typename PointT>
+# class PassThrough : public FilterIndices<PointT>
+cdef extern from "pcl/filters/passthrough.h" namespace "pcl":
+    cdef cppclass PassThrough[T](FilterIndices[T]):
+        PassThrough()
+        void setFilterFieldName (string field_name)
+        string getFilterFieldName ()
+        void setFilterLimits (float min, float max)
+        void getFilterLimits (float &min, float &max)
+        void setFilterLimitsNegative (const bool limit_negative)
+        void getFilterLimitsNegative (bool &limit_negative)
+        bool getFilterLimitsNegative ()
+        # call base Class(PCLBase)
+        # void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # call base Class(FilterIndices)
+        # void filter(cpp.PointCloud[T] c)
+
+
+ctypedef PassThrough[cpp.PointXYZ] PassThrough_t
+ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t
+###
+
+# passthrough.h
+# template<>
+# class PCL_EXPORTS PassThrough<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+# cdef extern from "pcl/filters/passthrough.h" namespace "pcl":
+#     cdef cppclass PassThrough[grb.PointCloud2](Filter[grb.PointCloud2]):
+#         PassThrough(bool extract_removed_indices)
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#     using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#     public:
+#       /** \brief Constructor. */
+#       PassThrough (bool extract_removed_indices = false) :
+#       /** \brief Set whether the filtered points should be kept and set to the
+#         * value given through \a setUserFilterValue (default: NaN), or removed
+#         * from the PointCloud, thus potentially breaking its organized
+#         * structure. By default, points are removed.
+#         * \param[in] val set to true whether the filtered points should be kept and
+#         * set to a given user value (default: NaN)
+#       void setKeepOrganized (bool val)
+#       /** \brief Obtain the value of the internal \a keep_organized_ parameter. */
+#       bool getKeepOrganized ()
+#       /** \brief Provide a value that the filtered points should be set to
+#         * instead of removing them.  Used in conjunction with \a
+#         * setKeepOrganized ().
+#         * \param[in] val the user given value that the filtered point dimensions should be set to
+#       void setUserFilterValue (float val)
+#       /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+#         * points having values outside this interval will be discarded.
+#         * \param[in] field_name the name of the field that contains values used for filtering
+#       void setFilterFieldName (const string &field_name)
+#       /** \brief Get the name of the field used for filtering. */
+#       string const getFilterFieldName ()
+#       /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+#         * \param[in] limit_min the minimum allowed field value
+#         * \param[in] limit_max the maximum allowed field value
+#       void setFilterLimits (const double &limit_min, const double &limit_max)
+#       /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+#         * \param[out] limit_min the minimum allowed field value
+#         * \param[out] limit_max the maximum allowed field value
+#       void getFilterLimits (double &limit_min, double &limit_max)
+#       /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+#         * Default: false.
+#         * \param[in] limit_negative return data inside the interval (false) or outside (true)
+#       void setFilterLimitsNegative (const bool limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       void getFilterLimitsNegative (bool &limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       bool getFilterLimitsNegative ()
+
+
+###
+
+# plane_clipper3D.h
+# template<typename PointT>
+# class PlaneClipper3D : public Clipper3D<PointT>
+cdef extern from "pcl/filters/plane_clipper3D.h" namespace "pcl":
+    cdef cppclass PlaneClipper3D[T](Clipper3D[T]):
+        PlaneClipper3D (eigen3.Vector4f plane_params)
+        # PlaneClipper3D (const Eigen::Vector4f& plane_params);
+        # * \brief Set new plane parameters
+        # * \param plane_params
+        # void setPlaneParameters (const Eigen::Vector4f& plane_params);
+        void setPlaneParameters (const eigen3.Vector4f plane_params);
+        
+        # * \brief return the current plane parameters
+        # * \return the current plane parameters
+        # const Eigen::Vector4f& getPlaneParameters () const;
+        eigen3.Vector4f getPlaneParameters ()
+        # virtual bool clipPoint3D (const PointT& point) const;
+        # virtual bool clipLineSegment3D (PointT& from, PointT& to) const;
+        # virtual void clipPlanarPolygon3D (const std::vector<PointT>& polygon, std::vector<PointT>& clipped_polygon) const;
+        # virtual void clipPointCloud3D (const pcl::PointCloud<PointT> &cloud_in, std::vector<int>& clipped, const std::vector<int>& indices = std::vector<int> ()) const;
+        # virtual Clipper3D<PointT>* clone () const;
+###
+
+# project_inliers.h
+# template<typename PointT>
+# class ProjectInliers : public Filter<PointT>
+cdef extern from "pcl/filters/project_inliers.h" namespace "pcl":
+    cdef cppclass ProjectInliers[T](Filter[T]):
+        ProjectInliers ()
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+
+        # public:
+        # brief The type of model to use (user given parameter).
+        # param model the model type (check \a model_types.h)
+        void setModelType (int model)
+        # brief Get the type of SAC model used. */
+        int getModelType ()
+        # brief Provide a pointer to the model coefficients.
+        # param model a pointer to the model coefficients
+        void setModelCoefficients (cpp.ModelCoefficients * model)
+        # brief Get a pointer to the model coefficients. */
+        cpp.ModelCoefficients * getModelCoefficients ()
+        # brief Set whether all data will be returned, or only the projected inliers.
+        # param val true if all data should be returned, false if only the projected inliers
+        void setCopyAllData (bool val)
+        # brief Get whether all data is being copied (true), or only the projected inliers (false). */
+        bool getCopyAllData ()
+
+ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t
+ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] ProjectInliersPtr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] ProjectInliers_PointXYZI_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGB]] ProjectInliers_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGBA]] ProjectInliers_PointXYZRGBA_Ptr_t
+###
+
+# template<>
+# class PCL_EXPORTS ProjectInliers<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     typedef SampleConsensusModel<PointXYZ>::Ptr SampleConsensusModelPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       ProjectInliers () : model_type_ (), copy_all_data_ (false), copy_all_fields_ (true), model_ (), sacmodel_ ()
+#       /** \brief The type of model to use (user given parameter).
+#         * \param[in] model the model type (check \a model_types.h)
+#       void setModelType (int model)
+#       /** \brief Get the type of SAC model used. */
+#       int getModelType () const
+#       /** \brief Provide a pointer to the model coefficients.
+#         * \param[in] model a pointer to the model coefficients
+#       void setModelCoefficients (const ModelCoefficientsConstPtr &model)
+#       /** \brief Get a pointer to the model coefficients. */
+#       ModelCoefficientsConstPtr getModelCoefficients () const
+#       /** \brief Set whether all fields should be copied, or only the XYZ.
+#         * \param[in] val true if all fields will be returned, false if only XYZ
+#       void setCopyAllFields (bool val)
+#       /** \brief Get whether all fields are being copied (true), or only XYZ (false). */
+#       bool getCopyAllFields () const
+#       /** \brief Set whether all data will be returned, or only the projected inliers.
+#         * \param[in] val true if all data should be returned, false if only the projected inliers
+#       void setCopyAllData (bool val)
+#       /** \brief Get whether all data is being copied (true), or only the projected inliers (false). */
+#       bool getCopyAllData () const
+###
+
+# radius_outlier_removal.h
+# template<typename PointT>
+# class RadiusOutlierRemoval : public FilterIndices<PointT>
+cdef extern from "pcl/filters/radius_outlier_removal.h" namespace "pcl":
+    cdef cppclass RadiusOutlierRemoval[T](FilterIndices[T]):
+        RadiusOutlierRemoval ()
+        # brief Set the radius of the sphere that will determine which points are neighbors.
+        # details The number of points within this distance from the query point will need to be equal or greater
+        # than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
+        # param[in] radius The radius of the sphere for nearest neighbor searching.
+        void setRadiusSearch (double radius)
+        # brief Get the radius of the sphere that will determine which points are neighbors.
+        # details The number of points within this distance from the query point will need to be equal or greater
+        # than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
+        # return The radius of the sphere for nearest neighbor searching.
+        double getRadiusSearch ()
+        # brief Set the number of neighbors that need to be present in order to be classified as an inlier.
+        # details The number of points within setRadiusSearch() from the query point will need to be equal or greater
+        # than this number in order to be classified as an inlier point (i.e. will not be filtered).
+        # param min_pts The minimum number of neighbors (default = 1).
+        void setMinNeighborsInRadius (int min_pts)
+        # brief Get the number of neighbors that need to be present in order to be classified as an inlier.
+        # details The number of points within setRadiusSearch() from the query point will need to be equal or greater
+        # than this number in order to be classified as an inlier point (i.e. will not be filtered).
+        # param min_pts The minimum number of neighbors (default = 1).
+        int getMinNeighborsInRadius ()
+
+ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] RadiusOutlierRemovalPtr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] RadiusOutlierRemoval_PointXYZI_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGB]] RadiusOutlierRemoval_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGBA]] RadiusOutlierRemoval_PointXYZRGBA_Ptr_t
+###
+
+
+
+# template<>
+# class PCL_EXPORTS RadiusOutlierRemoval<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#       using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#       using Filter<sensor_msgs::PointCloud2>::getClassName;
+#       using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#       using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#       typedef pcl::search::Search<pcl::PointXYZ> KdTree;
+#       typedef pcl::search::Search<pcl::PointXYZ>::Ptr KdTreePtr;
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       typedef PointCloud2::Ptr PointCloud2Ptr;
+#       typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       public:
+#       /** \brief Empty constructor. */
+#       RadiusOutlierRemoval (bool extract_removed_indices = false) :
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors for filtering.
+#       * \param radius the sphere radius that is to contain all k-nearest neighbors
+#       */
+#       void setRadiusSearch (double radius)
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       double getRadiusSearch ()
+#       /** \brief Set the minimum number of neighbors that a point needs to have in the given search radius in order to
+#       * be considered an inlier (i.e., valid).
+#       * \param min_pts the minimum number of neighbors
+#       */
+#       void setMinNeighborsInRadius (int min_pts)
+#       /** \brief Get the minimum number of neighbors that a point needs to have in the given search radius to be
+#       * considered an inlier and avoid being filtered. 
+#       */
+#       double getMinNeighborsInRadius ()
+###
+
+# random_sample.h
+# template<typename PointT>
+# class RandomSample : public FilterIndices<PointT>
+# cdef cppclass RandomSample[T](FilterIndices[T]):
+cdef extern from "pcl/filters/random_sample.h" namespace "pcl":
+    cdef cppclass RandomSample[T](FilterIndices[T]):
+        RandomSample ()
+        # using FilterIndices<PointT>::filter_name_;
+        # using FilterIndices<PointT>::getClassName;
+        # using FilterIndices<PointT>::indices_;
+        # using FilterIndices<PointT>::input_;
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # /** \brief Set number of indices to be sampled.
+        #   * \param sample
+        void setSample (unsigned int sample)
+        # /** \brief Get the value of the internal \a sample parameter.
+        unsigned int getSample ()
+        # /** \brief Set seed of random function.
+        #   * \param seed
+        void setSeed (unsigned int seed)
+        # /** \brief Get the value of the internal \a seed parameter.
+        unsigned int getSeed ()
+
+# template<>
+# class PCL_EXPORTS RandomSample<sensor_msgs::PointCloud2> : public FilterIndices<sensor_msgs::PointCloud2>
+#     using FilterIndices<sensor_msgs::PointCloud2>::filter_name_;
+#     using FilterIndices<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       RandomSample () : sample_ (UINT_MAX), seed_ (static_cast<unsigned int> (time (NULL)))
+#       /** \brief Set number of indices to be sampled.
+#         * \param sample
+#       void setSample (unsigned int sample)
+#       /** \brief Get the value of the internal \a sample parameter.
+#       unsigned int getSample ()
+#       /** \brief Set seed of random function.
+#         * \param seed
+#       void setSeed (unsigned int seed)
+#       /** \brief Get the value of the internal \a seed parameter.
+#       unsigned int getSeed ()
+###
+
+# statistical_outlier_removal.h
+# template<typename PointT>
+# class StatisticalOutlierRemoval : public FilterIndices<PointT>
+# NG
+# cdef cppclass StatisticalOutlierRemoval[T](FilterIndices[T]):
+cdef extern from "pcl/filters/statistical_outlier_removal.h" namespace "pcl":
+    cdef cppclass StatisticalOutlierRemoval[T](FilterIndices[T]):
+        StatisticalOutlierRemoval()
+        int getMeanK()
+        void setMeanK (int nr_k)
+        double getStddevMulThresh()
+        void setStddevMulThresh (double std_mul)
+        bool getNegative()
+        # use FilterIndices class function
+        # void setNegative (bool negative)
+        # use PCLBase class function
+        # void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        void filter(cpp.PointCloud[T] &c)
+
+
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t
+###
+
+# template<>
+# class PCL_EXPORTS StatisticalOutlierRemoval<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#     using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#     typedef pcl::search::Search<pcl::PointXYZ> KdTree;
+#     typedef pcl::search::Search<pcl::PointXYZ>::Ptr KdTreePtr;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       StatisticalOutlierRemoval (bool extract_removed_indices = false) :
+#       /** \brief Set the number of points (k) to use for mean distance estimation
+#         * \param nr_k the number of points to use for mean distance estimation
+#       void setMeanK (int nr_k)
+#       /** \brief Get the number of points to use for mean distance estimation. */
+#       int getMeanK ()
+#       /** \brief Set the standard deviation multiplier threshold. All points outside the
+#         * \f[ \mu \pm \sigma \cdot std\_mul \f]
+#         * will be considered outliers, where \f$ \mu \f$ is the estimated mean,
+#         * and \f$ \sigma \f$ is the standard deviation.
+#         * \param std_mul the standard deviation multiplier threshold
+#       void setStddevMulThresh (double std_mul)
+#       /** \brief Get the standard deviation multiplier threshold as set by the user. */
+#       double getStddevMulThresh ()
+#       /** \brief Set whether the indices should be returned, or all points \e except the indices.
+#         * \param negative true if all points \e except the input indices will be returned, false otherwise
+#       void setNegative (bool negative)
+#       /** \brief Get the value of the internal #negative_ parameter. If
+#         * true, all points \e except the input indices will be returned.
+#         * \return The value of the "negative" flag
+#       bool getNegative ()
+#       void applyFilter (PointCloud2 &output);
+###
+
+# voxel_grid.h
+# template <typename PointT>
+# class VoxelGrid : public Filter<PointT>
+cdef extern from "pcl/filters/voxel_grid.h" namespace "pcl":
+    cdef cppclass VoxelGrid[T](Filter[T]):
+        VoxelGrid()
+        
+        # void setLeafSize (const Eigen::Vector4f &leaf_size) 
+        void setLeafSize (float, float, float)
+        
+        # Filter class function
+        # void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        
+        # void filter(cpp.PointCloud[T] c)
+        # /** \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+        #   * \param[in] downsample the new value (true/false)
+        # void setDownsampleAllData (bool downsample)
+        void setDownsampleAllData (bool downsample)
+        
+        # /** \brief Get the state of the internal downsampling parameter (true if
+        #   * all fields need to be downsampled, false if just XYZ). 
+        # bool getDownsampleAllData ()
+        bool getDownsampleAllData ()
+        
+        # /** \brief Set to true if leaf layout information needs to be saved for later access.
+        #   * \param[in] save_leaf_layout the new value (true/false)
+        # void setSaveLeafLayout (bool save_leaf_layout)
+        void setSaveLeafLayout (bool save_leaf_layout)
+        
+        # /** \brief Returns true if leaf layout information will to be saved for later access. */
+        # bool getSaveLeafLayout () { return (save_leaf_layout_); }
+        bool getSaveLeafLayout ()
+        
+        # \brief Get the minimum coordinates of the bounding box (after filtering is performed). 
+        # Eigen::Vector3i getMinBoxCoordinates () { return (min_b_.head<3> ()); }
+        eigen3.Vector3i getMinBoxCoordinates ()
+        
+        # \brief Get the minimum coordinates of the bounding box (after filtering is performed). 
+        # Eigen::Vector3i getMaxBoxCoordinates () { return (max_b_.head<3> ()); }
+        eigen3.Vector3i getMaxBoxCoordinates ()
+        
+        # \brief Get the number of divisions along all 3 axes (after filtering is performed). 
+        # Eigen::Vector3i getNrDivisions () { return (div_b_.head<3> ()); }
+        eigen3.Vector3i getNrDivisions ()
+        
+        # \brief Get the multipliers to be applied to the grid coordinates in order to find the centroid index (after filtering is performed). 
+        # Eigen::Vector3i getDivisionMultiplier () { return (divb_mul_.head<3> ()); }
+        eigen3.Vector3i getDivisionMultiplier ()
+        
+        # /** \brief Returns the index in the resulting downsampled cloud of the specified point.
+        #   * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering 
+        #   * performed, and that the point is inside the grid, to avoid invalid access (or use
+        #   * getGridCoordinates+getCentroidIndexAt)
+        #   * \param[in] p the point to get the index at
+        # int getCentroidIndex (const PointT &p)
+        int getCentroidIndex (const T &p)
+        
+        # /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+        #   * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+        #   * \param[in] reference_point the coordinates of the reference point (corresponding cell is allowed to be empty/out of bounds)
+        #   * \param[in] relative_coordinates matrix with the columns being the coordinates of the requested cells, relative to the reference point's cell
+        #   * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+        # std::vector<int> getNeighborCentroidIndices (const PointT &reference_point, const Eigen::MatrixXi &relative_coordinates)
+        # vector[int] getNeighborCentroidIndices (const T &reference_point, const eigen3.MatrixXi &relative_coordinates)
+        
+        # /** \brief Returns the layout of the leafs for fast access to cells relative to current position.
+        #   * \note position at (i-min_x) + (j-min_y)*div_x + (k-min_z)*div_x*div_y holds the index of the element at coordinates (i,j,k) in the grid (-1 if empty)
+        # vector[int] getLeafLayout ()
+        vector[int] getLeafLayout ()
+        
+        # /** \brief Returns the corresponding (i,j,k) coordinates in the grid of point (x,y,z). 
+        #   * \param[in] x the X point coordinate to get the (i, j, k) index at
+        #   * \param[in] y the Y point coordinate to get the (i, j, k) index at
+        #   * \param[in] z the Z point coordinate to get the (i, j, k) index at
+        # Eigen::Vector3i getGridCoordinates (float x, float y, float z) 
+        eigen3.Vector3i getGridCoordinates (float x, float y, float z) 
+        
+        # /** \brief Returns the index in the downsampled cloud corresponding to a given set of coordinates.
+        #   * \param[in] ijk the coordinates (i,j,k) in the grid (-1 if empty)
+        # int getCentroidIndexAt (const Eigen::Vector3i &ijk)
+        int getCentroidIndexAt (const eigen3.Vector3i &ijk)
+        
+        # /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+        #   * points having values outside this interval will be discarded.
+        #   * \param[in] field_name the name of the field that contains values used for filtering
+        # void setFilterFieldName (const std::string &field_name)
+        void setFilterFieldName (const string &field_name)
+        
+        # /** \brief Get the name of the field used for filtering. */
+        # std::string const getFilterFieldName ()
+        const string getFilterFieldName ()
+        
+        # /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+        #   * \param[in] limit_min the minimum allowed field value
+        #   * \param[in] limit_max the maximum allowed field value
+        # void setFilterLimits (const double &limit_min, const double &limit_max)
+        void setFilterLimits (const double &limit_min, const double &limit_max)
+        
+        # /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+        #   * \param[out] limit_min the minimum allowed field value
+        #   * \param[out] limit_max the maximum allowed field value
+        # void getFilterLimits (double &limit_min, double &limit_max)
+        void getFilterLimits (double &limit_min, double &limit_max)
+        
+        # /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+        #   * Default: false.
+        #   * \param[in] limit_negative return data inside the interval (false) or outside (true)
+        # void setFilterLimitsNegative (const bool limit_negative)
+        void setFilterLimitsNegative (const bool limit_negative)
+        
+        # /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+        #   * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+        # void getFilterLimitsNegative (bool &limit_negative)
+        void getFilterLimitsNegative (bool &limit_negative)
+        
+        # /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+        #   * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+        # bool getFilterLimitsNegative ()
+        bool getFilterLimitsNegative ()
+
+
+###
+
+# template <>
+# class PCL_EXPORTS VoxelGrid<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       VoxelGrid ()
+#       /** \brief Destructor. */
+#       virtual ~VoxelGrid ()
+#       /** \brief Set the voxel grid leaf size.
+#         * \param[in] leaf_size the voxel grid leaf size
+#       void setLeafSize (const Eigen::Vector4f &leaf_size) 
+#       /** \brief Set the voxel grid leaf size.
+#         * \param[in] lx the leaf size for X
+#         * \param[in] ly the leaf size for Y
+#         * \param[in] lz the leaf size for Z
+#       void setLeafSize (float lx, float ly, float lz)
+#       /** \brief Get the voxel grid leaf size. */
+#       Eigen::Vector3f getLeafSize ()
+#       /** \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+#         * \param[in] downsample the new value (true/false)
+#       void setDownsampleAllData (bool downsample)
+#       /** \brief Get the state of the internal downsampling parameter (true if
+#         * all fields need to be downsampled, false if just XYZ). 
+#       bool getDownsampleAllData ()
+#       /** \brief Set to true if leaf layout information needs to be saved for later access.
+#         * \param[in] save_leaf_layout the new value (true/false)
+#       void setSaveLeafLayout (bool save_leaf_layout)
+#       /** \brief Returns true if leaf layout information will to be saved for later access. */
+#       bool getSaveLeafLayout ()
+#       /** \brief Get the minimum coordinates of the bounding box (after
+#         * filtering is performed). 
+#       Eigen::Vector3i getMinBoxCoordinates ()
+#       /** \brief Get the minimum coordinates of the bounding box (after
+#         * filtering is performed). 
+#       Eigen::Vector3i getMaxBoxCoordinates ()
+#       /** \brief Get the number of divisions along all 3 axes (after filtering
+#         * is performed). 
+#       Eigen::Vector3i getNrDivisions ()
+#       /** \brief Get the multipliers to be applied to the grid coordinates in
+#         * order to find the centroid index (after filtering is performed). 
+#       Eigen::Vector3i getDivisionMultiplier ()
+#       /** \brief Returns the index in the resulting downsampled cloud of the specified point.
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed,
+#         * and that the point is inside the grid, to avoid invalid access (or use getGridCoordinates+getCentroidIndexAt)
+#         * \param[in] x the X point coordinate to get the index at
+#         * \param[in] y the Y point coordinate to get the index at
+#         * \param[in] z the Z point coordinate to get the index at
+#       int getCentroidIndex (float x, float y, float z)
+#       /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+#         * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+#         * \param[in] x the X coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] y the Y coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] z the Z coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[out] relative_coordinates matrix with the columns being the coordinates of the requested cells, relative to the reference point's cell
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+#       vector[int] getNeighborCentroidIndices (float x, float y, float z, const Eigen::MatrixXi &relative_coordinates)
+#       /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+#         * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+#         * \param[in] x the X coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] y the Y coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] z the Z coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[out] relative_coordinates vector with the elements being the coordinates of the requested cells, relative to the reference point's cell
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+#       vector[int] getNeighborCentroidIndices (float x, float y, float z, const vector[Eigen::Vector3i] &relative_coordinates)
+#       /** \brief Returns the layout of the leafs for fast access to cells relative to current position.
+#         * \note position at (i-min_x) + (j-min_y)*div_x + (k-min_z)*div_x*div_y holds the index of the element at coordinates (i,j,k) in the grid (-1 if empty)
+#       vector[int] getLeafLayout ()
+#       /** \brief Returns the corresponding (i,j,k) coordinates in the grid of point (x,y,z).
+#         * \param[in] x the X point coordinate to get the (i, j, k) index at
+#         * \param[in] y the Y point coordinate to get the (i, j, k) index at
+#         * \param[in] z the Z point coordinate to get the (i, j, k) index at
+#       Eigen::Vector3i getGridCoordinates (float x, float y, float z) 
+#       /** \brief Returns the index in the downsampled cloud corresponding to a given set of coordinates.
+#         * \param[in] ijk the coordinates (i,j,k) in the grid (-1 if empty)
+#       int getCentroidIndexAt (const Eigen::Vector3i &ijk)
+#       /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+#         * points having values outside this interval will be discarded.
+#         * \param[in] field_name the name of the field that contains values used for filtering
+#       void setFilterFieldName (const string &field_name)
+#       /** \brief Get the name of the field used for filtering. */
+#       std::string const getFilterFieldName ()
+#       /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+#         * \param[in] limit_min the minimum allowed field value
+#         * \param[in] limit_max the maximum allowed field value
+#       void setFilterLimits (const double &limit_min, const double &limit_max)
+#       /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+#         * \param[out] limit_min the minimum allowed field value
+#         * \param[out] limit_max the maximum allowed field value
+#       void getFilterLimits (double &limit_min, double &limit_max)
+#       /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+#         * Default: false.
+#         * \param[in] limit_negative return data inside the interval (false) or outside (true)
+#       void setFilterLimitsNegative (const bool limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       void getFilterLimitsNegative (bool &limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       bool getFilterLimitsNegative ()
+###
+
+ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t
+ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# conditional_removal.h
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+# typedef enum 
+# {
+# GT, GE, LT, LE, EQ
+# }
+# CompareOp;
+
+# NG
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+#     cdef enum CompareOp:
+#         GT
+#         GE
+#         LT
+#         LE
+#         EQ
+# 
+
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+#     cdef enum CompareOp:
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl"
+#   ctypedef enum CythonCompareOp "pcl::ComparisonOps::CompareOp":
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+    ctypedef enum CompareOp2 "pcl::ComparisonOps::CompareOp":
+        COMPAREOP_GT "pcl::ComparisonOps::GT"
+        COMPAREOP_GE "pcl::ComparisonOps::GE"
+        COMPAREOP_LT "pcl::ComparisonOps::LT"
+        COMPAREOP_LE "pcl::ComparisonOps::LE"
+        COMPAREOP_EQ "pcl::ComparisonOps::EQ"
+
+###
\ No newline at end of file
diff --git a/pcl/pcl_filters_172.pxd b/pcl/pcl_filters_172.pxd
new file mode 100644
index 0000000..b6d483f
--- /dev/null
+++ b/pcl/pcl_filters_172.pxd
@@ -0,0 +1,1672 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# import
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# conditional_removal.h
+# template<typename PointT>
+# class ComparisonBase
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ComparisonBase[T]:
+        ComparisonBase()
+        # public:
+        # ctypedef boost::shared_ptr<ComparisonBase<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ComparisonBase<PointT> > ConstPtr;
+        #
+        # brief Return if the comparison is capable.
+        bool isCapable ()
+        
+        # /** \brief Evaluate function. */
+        # virtual bool evaluate (const PointT &point) const = 0;
+
+
+ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t
+ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t
+###
+
+# conditional_removal.h
+# template<typename PointT>
+# class ConditionBase
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionBase[T]:
+        ConditionBase ()
+        # public:
+        # ctypedef typename pcl::ComparisonBase<PointT> ComparisonBase;
+        # ctypedef typename ComparisonBase::Ptr ComparisonBasePtr;
+        # ctypedef typename ComparisonBase::ConstPtr ComparisonBaseConstPtr;
+        # ctypedef boost::shared_ptr<ConditionBase<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionBase<PointT> > ConstPtr;
+        
+        # NG(Cython 24.0.1) : evaluate is virtual Function
+        # void addComparison (ComparisonBase[T] comparison)
+        # void addComparison (const ComparisonBase[T] comparison)
+        # use Cython 0.25.2
+        void addComparison (shared_ptr[ComparisonBase[T]] comparison)
+        void addCondition (shared_ptr[ConditionBase[T]] condition)
+        bool isCapable ()
+
+
+ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t
+ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t
+###
+
+# filter.h
+# template<typename PointT>
+# class Filter : public PCLBase<PointT>
+cdef extern from "pcl/filters/filter.h" namespace "pcl":
+    cdef cppclass Filter[T](cpp.PCLBase[T]):
+        Filter()
+        # public:
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::input_;
+        # ctypedef boost::shared_ptr< Filter<PointT> > Ptr;
+        # ctypedef boost::shared_ptr< const Filter<PointT> > ConstPtr;
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        
+        # /** \brief Get the point indices being removed */
+        cpp.IndicesPtr_t getRemovedIndices ()
+        
+        # \brief Calls the filtering method and returns the filtered dataset in output.
+        # \param[out] output the resultant filtered point cloud dataset
+        void filter (cpp.PointCloud[T] &output)
+
+
+ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t
+###
+
+# template<>
+# class PCL_EXPORTS FilterIndices<pcl::PCLPointCloud2> : public Filter<pcl::PCLPointCloud2>
+        # public:
+        # typedef pcl::PCLPointCloud2 PCLPointCloud2;
+        # 
+        # /** \brief Constructor.
+        #   * \param[in] extract_removed_indices Set to true if you want to extract the indices of points being removed (default = false).
+        #   */
+        # FilterIndices (bool extract_removed_indices = false) :
+        #   negative_ (false), 
+        #   keep_organized_ (false), 
+        #   user_filter_value_ (std::numeric_limits<float>::quiet_NaN ())
+        #   
+        # virtual void filter (PCLPointCloud2 &output)
+        # 
+        # /** \brief Calls the filtering method and returns the filtered point cloud indices.
+        #   * \param[out] indices the resultant filtered point cloud indices
+        #   */
+        # void filter (vector[int] &indices);
+        # 
+        # /** \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+        #   * \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+        #   */
+        # inline void setNegative (bool negative)
+        # 
+        # /** \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+        #   * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        #   */
+        # inline bool getNegative ()
+        # 
+        # /** \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+        #   * or removed from the PointCloud, thus potentially breaking its organized structure.
+        #   * \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+        #   */
+        # inline void setKeepOrganized (bool keep_organized)
+        # 
+        # /** \brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+        #   * or removed from the PointCloud, thus potentially breaking its organized structure.
+        #   *  \return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+        #   */
+        # inline bool getKeepOrganized ()
+        # 
+        # /** \brief Provide a value that the filtered points should be set to instead of removing them.
+        #   * Used in conjunction with \a setKeepOrganized ().
+        #   * \param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+        #   */
+        # inline void setUserFilterValue (float value)
+
+
+###
+
+# filter_indices.h
+# template<typename PointT>
+# class FilterIndices : public Filter<PointT>
+cdef extern from "pcl/filters/filter_indices.h" namespace "pcl":
+    cdef cppclass FilterIndices[T](Filter[T]):
+        FilterIndices()
+        # public:
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        
+        ## filter function
+        # same question
+        # http://stackoverflow.com/questions/37186861/sync-bool-compare-and-swap-with-different-parameter-types-in-cython
+        # taisaku : 
+        # Interfacing with External C Code
+        # http://cython-docs2.readthedocs.io/en/latest/src/userguide/external_C_code.html
+        # void filter (cpp.PointCloud[T] &output)
+        void c_filter "filter" (cpp.PointCloud[T] &output)
+        
+        # brief Calls the filtering method and returns the filtered point cloud indices.
+        # param[out] indices the resultant filtered point cloud indices
+        void filter (vector[int] &indices)
+        ## filter function
+        
+        # \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+        # \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+        void setNegative (bool negative)
+        
+        # \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+        # \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        bool getNegative ()
+        
+        # \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+        # or removed from the PointCloud, thus potentially breaking its organized structure.
+        # \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+        void setKeepOrganized (bool keep_organized)
+        
+        # brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+        # or removed from the PointCloud, thus potentially breaking its organized structure.
+        # return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+        bool getKeepOrganized ()
+        
+        # brief Provide a value that the filtered points should be set to instead of removing them.
+        # Used in conjunction with \a setKeepOrganized ().
+        # param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+        void setUserFilterValue (float value)
+        
+        # brief Get the point indices being removed
+        # return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        cpp.IndicesPtr_t getRemovedIndices ()
+
+
+###
+
+# template<>
+# class PCL_EXPORTS FilterIndices<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#       public:
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       /** \brief Constructor.
+#         * \param[in] extract_removed_indices Set to true if you want to extract the indices of points being removed (default = false).
+#       FilterIndices (bool extract_removed_indices = false) :
+# 
+#       /** \brief Empty virtual destructor. */
+#       virtual ~FilterIndices ()
+#       virtual void filter (PointCloud2 &output)
+# 
+#       /** \brief Calls the filtering method and returns the filtered point cloud indices.
+#         * \param[out] indices the resultant filtered point cloud indices
+#       void filter (vector[int] &indices)
+# 
+#       /** \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+#         * \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+#       void setNegative (bool negative)
+# 
+#       /** \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+#         * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+#       bool getNegative ()
+# 
+#       /** \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+#         * or removed from the PointCloud, thus potentially breaking its organized structure.
+#         * \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+#       void setKeepOrganized (bool keep_organized)
+# 
+#       /** \brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+#         * or removed from the PointCloud, thus potentially breaking its organized structure.
+#         * \return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+#       bool getKeepOrganized ()
+# 
+#       /** \brief Provide a value that the filtered points should be set to instead of removing them.
+#         * Used in conjunction with \a setKeepOrganized ().
+#         * \param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+#       void setUserFilterValue (float value)
+# 
+#       /** \brief Get the point indices being removed
+#         * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+#       IndicesConstPtr const getRemovedIndices ()
+
+
+###
+
+### Inheritance class ###
+
+# approximate_voxel_grid.h
+# NG ###
+# template <typename PointT>
+# struct xNdCopyEigenPointFunctor
+
+# cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+#     cdef struct xNdCopyEigenPointFunctor[T]:
+#         xNdCopyEigenPointFunctor()
+#         # ctypedef typename traits::POD<PointT>::type Pod;
+#         # xNdCopyEigenPointFunctor (const Eigen::VectorXf &p1, PointT &p2)
+#         # template<typename Key> void operator() ()
+# 
+# # template <typename PointT>
+# # struct xNdCopyPointEigenFunctor
+# cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+#     cdef struct xNdCopyPointEigenFunctor[T]:
+#         xNdCopyPointEigenFunctor()
+#         # ctypedef typename traits::POD<PointT>::type Pod;
+#         # xNdCopyPointEigenFunctor (const PointT &p1, Eigen::VectorXf &p2)
+#         # template<typename Key> void operator() ()
+# NG ###
+
+# template <typename PointT>
+# class ApproximateVoxelGrid: public Filter<PointT>
+cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+    cdef cppclass ApproximateVoxelGrid[T](Filter[T]):
+        ApproximateVoxelGrid()
+        # ApproximateVoxelGrid (const ApproximateVoxelGrid &src) : 
+        # ApproximateVoxelGrid& operator = (const ApproximateVoxelGrid &src)
+        # ApproximateVoxelGrid& element "operator()"(ApproximateVoxelGrid src)
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # * \brief Set the voxel grid leaf size.
+        # * \param[in] leaf_size the voxel grid leaf size
+        void setLeafSize (eigen3.Vector3f &leaf_size)
+        
+        # * \brief Set the voxel grid leaf size.
+        # * \param[in] lx the leaf size for X
+        # * \param[in] ly the leaf size for Y
+        # * \param[in] lz the leaf size for Z
+        void setLeafSize (float lx, float ly, float lz)
+        
+        # /** \brief Get the voxel grid leaf size. */
+        eigen3.Vector3f getLeafSize ()
+        
+        # * \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+        # * \param downsample the new value (true/false)
+        void setDownsampleAllData (bool downsample)
+        
+        # * \brief Get the state of the internal downsampling parameter (true if
+        # * all fields need to be downsampled, false if just XYZ). 
+        bool getDownsampleAllData () const
+
+
+ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t
+###
+
+# bilateral.h
+# template<typename PointT>
+# class BilateralFilter : public Filter<PointT>
+cdef extern from "pcl/filters/bilateral.h" namespace "pcl":
+    cdef cppclass BilateralFilter[T](Filter[T]):
+        BilateralFilter()
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # public:
+        # * \brief Filter the input data and store the results into output
+        # * \param[out] output the resultant point cloud message
+        void applyFilter (cpp.PointCloud[T] &output)
+        
+        # * \brief Compute the intensity average for a single point
+        # * \param[in] pid the point index to compute the weight for
+        # * \param[in] indices the set of nearest neighor indices 
+        # * \param[in] distances the set of nearest neighbor distances
+        # * \return the intensity average at a given point index
+        double  computePointWeight (const int pid, const vector[int] &indices, const vector[float] &distances)
+        
+        # * \brief Set the half size of the Gaussian bilateral filter window.
+        # * \param[in] sigma_s the half size of the Gaussian bilateral filter window to use
+        void setHalfSize (const double sigma_s)
+        
+        # * \brief Get the half size of the Gaussian bilateral filter window as set by the user. */
+        double getHalfSize ()
+        
+        # \brief Set the standard deviation parameter
+        # * \param[in] sigma_r the new standard deviation parameter
+        void setStdDev (const double sigma_r)
+        
+        # * \brief Get the value of the current standard deviation parameter of the bilateral filter. */
+        double getStdDev ()
+        
+        # * \brief Provide a pointer to the search object.
+        # * \param[in] tree a pointer to the spatial search object.
+        # void setSearchMethod (const KdTreePtr &tree)
+
+
+###
+
+# clipper3D.h
+# Override class
+# template<typename PointT>
+# class Clipper3D
+cdef extern from "pcl/filters/bilateral.h" namespace "pcl":
+    cdef cppclass Clipper3D[T]:
+        Clipper3D()
+        # public:
+        # \brief interface to clip a single point
+        # \param[in] point the point to check against
+        # * \return true, it point still exists, false if its clipped
+        # virtual bool clipPoint3D (const PointT& point) const = 0;
+        # 
+        # \brief interface to clip a line segment given by two end points. The order of the end points is unimportant and will sty the same after clipping.
+        # This means basically, that the direction of the line will not flip after clipping.
+        # \param[in,out] pt1 start point of the line
+        # \param[in,out] pt2 end point of the line
+        # \return true if the clipped line is not empty, thus the parameters are still valid, false if line completely outside clipping space
+        # virtual bool clipLineSegment3D (PointT& pt1, PointT& pt2) const = 0;
+        # 
+        # \brief interface to clip a planar polygon given by an ordered list of points
+        # \param[in,out] polygon the polygon in any direction (ccw or cw) but ordered, thus two neighboring points define an edge of the polygon
+        # virtual void clipPlanarPolygon3D (std::vector<PointT>& polygon) const = 0;
+        # 
+        # \brief interface to clip a planar polygon given by an ordered list of points
+        # \param[in] polygon the polygon in any direction (ccw or cw) but ordered, thus two neighboring points define an edge of the polygon
+        # \param[out] clipped_polygon the clipped polygon
+        # virtual void clipPlanarPolygon3D (vector[PointT]& polygon, vector[PointT]& clipped_polygon) const = 0;
+        # 
+        # \brief interface to clip a point cloud
+        # \param[in] cloud_in input point cloud
+        # \param[out] clipped indices of points that remain after clipping the input cloud
+        # \param[in] indices the indices of points in the point cloud to be clipped.
+        # \return list of indices of remaining points after clipping.
+        # virtual void clipPointCloud3D (const pcl::PointCloud<PointT> &cloud_in, std::vector<int>& clipped, const std::vector<int>& indices = std::vector<int> ()) const = 0;
+        # 
+        # \brief polymorphic method to clone the underlying clipper with its parameters.
+        # \return the new clipper object from the specific subclass with all its parameters.
+        # virtual Clipper3D<PointT>* clone () const = 0;
+
+
+###
+
+# NG ###
+# no define constructor
+# template<typename PointT>
+# class PointDataAtOffset
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+#     cdef cppclass PointDataAtOffset[T]:
+#         # PointDataAtOffset (uint8_t datatype, uint32_t offset)
+#         # int compare (const T& p, const double& val);
+
+
+###
+
+# template<typename PointT>
+# class FieldComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass FieldComparison[T](ComparisonBase[T]):
+        FieldComparison (string field_name, CompareOp2 op, double compare_val)
+        # FieldComparison (const FieldComparison &src) :
+        # FieldComparison& operator = (const FieldComparison &src)
+        # using ComparisonBase<PointT>::field_name_;
+        # using ComparisonBase<PointT>::op_;
+        # using ComparisonBase<PointT>::capable_;
+        # public:
+        # ctypedef boost::shared_ptr<FieldComparison<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const FieldComparison<PointT> > ConstPtr;
+
+
+ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t
+ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class PackedRGBComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass PackedRGBComparison[T](ComparisonBase[T]):
+        PackedRGBComparison()
+        # PackedRGBComparison (string component_name, CompareOp op, double compare_val)
+        # using ComparisonBase<PointT>::capable_;
+        # using ComparisonBase<PointT>::op_;
+        # virtual boolevaluate (const PointT &point) const;
+###
+
+# template<typename PointT>
+# class PackedHSIComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass PackedHSIComparison[T](ComparisonBase[T]):
+        PackedHSIComparison()
+        # PackedHSIComparison (string component_name, CompareOp op, double compare_val)
+        # using ComparisonBase<PointT>::capable_;
+        # using ComparisonBase<PointT>::op_;
+        # public:
+        # * \brief Construct a PackedHSIComparison 
+        # * \param component_name either "h", "s" or "i"
+        # * \param op the operator to use when making the comparison
+        # * \param compare_val the constant value to compare the component value too
+        # typedef enum
+        # {
+        #   H, // -128 to 127 corresponds to -pi to pi
+        #   S, // 0 to 255
+        #   I  // 0 to 255
+        # } ComponentId;
+###
+
+# template<typename PointT>
+# class TfQuadraticXYZComparison : public pcl::ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass TfQuadraticXYZComparison[T](ComparisonBase[T]):
+        TfQuadraticXYZComparison ()
+        # * \param op the operator "[OP]" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_matrix the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_vector the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_scalar the scalar "c" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_transform the transformation of the comparison.
+        # TfQuadraticXYZComparison (const pcl::ComparisonOps::CompareOp op, const Eigen::Matrix3f &comparison_matrix,
+        #                         const Eigen::Vector3f &comparison_vector, const float &comparison_scalar,
+        #                         const Eigen::Affine3f &comparison_transform = Eigen::Affine3f::Identity ());
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW     //needed whenever there is a fixed size Eigen:: vector or matrix in a class
+        
+        # ctypedef boost::shared_ptr<TfQuadraticXYZComparison<PointT> > Ptr;
+        # typedef boost::shared_ptr<const TfQuadraticXYZComparison<PointT> > ConstPtr;
+        # void setComparisonOperator (const pcl::ComparisonOps::CompareOp op)
+        # * \brief set the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonMatrix (const Eigen::Matrix3f &matrix)
+        
+        # * \brief set the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonMatrix (const Eigen::Matrix4f &homogeneousMatrix)
+        
+        # * \brief set the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonVector (const Eigen::Vector3f &vector)
+        
+        # * \brief set the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonVector (const Eigen::Vector4f &homogeneousVector)
+        
+        # * \brief set the scalar "c" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonScalar (const float &scalar)
+        
+        # * \brief transform the coordinate system of the comparison. If you think of
+        # * the transformation to be a translation and rotation of the comparison in the
+        # * same coordinate system, you have to provide the inverse transformation.
+        # * This function does not change the original definition of the comparison. Thus,
+        # * each call of this function will assume the original definition of the comparison
+        # * as starting point for the transformation.
+        # * @param transform the transformation (rotation and translation) as an affine matrix.
+        # void transformComparison (const Eigen::Matrix4f &transform)
+        
+        # * \brief transform the coordinate system of the comparison. If you think of
+        # * the transformation to be a translation and rotation of the comparison in the
+        # * same coordinate system, you have to provide the inverse transformation.
+        # * This function does not change the original definition of the comparison. Thus,
+        # * each call of this function will assume the original definition of the comparison
+        # * as starting point for the transformation.
+        # * @param transform the transformation (rotation and translation) as an affine matrix.
+        # void transformComparison (const Eigen::Affine3f &transform)
+        
+        # \brief Determine the result of this comparison.
+        # \param point the point to evaluate
+        # \return the result of this comparison.
+        # virtual bool evaluate (const PointT &point) const;
+
+
+###
+# NG end ###
+
+
+# template<typename PointT>
+# class ConditionAnd : public ConditionBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionAnd[T](ConditionBase[T]):
+        ConditionAnd()
+        # using ConditionBase<PointT>::conditions_;
+        # using ConditionBase<PointT>::comparisons_;
+        # public:
+        # ctypedef boost::shared_ptr<ConditionAnd<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionAnd<PointT> > ConstPtr;
+
+
+ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t
+ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class ConditionOr : public ConditionBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionOr[T](ConditionBase[T]):
+        ConditionOr()
+        # using ConditionBase<PointT>::conditions_;
+        # using ConditionBase<PointT>::comparisons_;
+        # public:
+        # ctypedef boost::shared_ptr<ConditionOr<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionOr<PointT> > ConstPtr;
+
+
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class ConditionalRemoval : public Filter<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionalRemoval[T](Filter[T]):
+        ConditionalRemoval()
+        ConditionalRemoval(int)
+        # ConditionalRemoval (ConditionBasePtr condition, bool extract_removed_indices = false)
+        # python invalid default param ?
+        ConditionalRemoval (ConditionBasePtr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZI_Ptr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZRGB_Ptr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZRGBA_Ptr_t condition, bool extract_removed_indices = false)
+        # [with PointT = pcl::PointXYZ, pcl::ConditionalRemoval<PointT>::ConditionBasePtr = boost::shared_ptr<pcl::ConditionBase<pcl::PointXYZ> >]
+        # is deprecated (declared at /usr/include/pcl-1.7/pcl/filters/conditional_removal.h:632): ConditionalRemoval(ConditionBasePtr condition, bool extract_removed_indices = false) is deprecated, 
+        # please use the setCondition (ConditionBasePtr condition) function instead. [-Wdeprecated-declarations]
+        # ConditionalRemoval (shared_ptr[]
+        
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # using Filter<PointT>::removed_indices_;
+        # using Filter<PointT>::extract_removed_indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # ctypedef typename pcl::ConditionBase<PointT> ConditionBase;
+        # ctypedef typename ConditionBase::Ptr ConditionBasePtr;
+        # ctypedef typename ConditionBase::ConstPtr ConditionBaseConstPtr;
+        void setKeepOrganized (bool val)
+        bool getKeepOrganized ()
+        void setUserFilterValue (float val)
+        # void setCondition (ConditionBasePtr condition);
+        void setCondition (ConditionBasePtr_t condition);
+        void setCondition (ConditionBase_PointXYZI_Ptr_t condition);
+        void setCondition (ConditionBase_PointXYZRGB_Ptr_t condition);
+        void setCondition (ConditionBase_PointXYZRGBA_Ptr_t condition);
+
+
+ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t
+ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t
+###
+
+# crop_box.h
+# template<typename PointT>
+# class CropBox : public FilterIndices<PointT>
+cdef extern from "pcl/filters/crop_box.h" namespace "pcl":
+    cdef cppclass CropBox[T](FilterIndices[T]):
+        CropBox()
+        # public:
+        # \brief Set the minimum point of the box
+        # \param[in] min_pt the minimum point of the box
+        void setMin (const eigen3.Vector4f &min_pt)
+        
+        # """
+        # brief Get the value of the minimum point of the box, as set by the user
+        # return the value of the internal \a min_pt parameter.
+        # """
+        eigen3.Vector4f getMin ()
+        
+        # brief Set the maximum point of the box
+        # param[in] max_pt the maximum point of the box
+        void setMax (const eigen3.Vector4f &max_pt)
+        
+        # brief Get the value of the maxiomum point of the box, as set by the user
+        # return the value of the internal \a max_pt parameter.
+        eigen3.Vector4f getMax () const
+        
+        # brief Set a translation value for the box
+        # param[in] translation the (tx,ty,tz) values that the box should be translated by
+        void setTranslation (const eigen3.Vector3f &translation)
+        
+        # brief Get the value of the box translation parameter as set by the user. */
+        eigen3.Vector3f getTranslation () const
+        
+        # brief Set a rotation value for the box
+        # param[in] rotation the (rx,ry,rz) values that the box should be rotated by
+        void setRotation (const eigen3.Vector3f &rotation)
+        
+        # brief Get the value of the box rotatation parameter, as set by the user. */
+        eigen3.Vector3f getRotation () const
+        
+        # brief Set a transformation that should be applied to the cloud before filtering
+        # param[in] transform an affine transformation that needs to be applied to the cloud before filtering
+        void setTransform (const eigen3.Affine3f &transform)
+        
+        # brief Get the value of the transformation parameter, as set by the user. */
+        eigen3.Affine3f getTransform () const
+
+
+ctypedef CropBox[cpp.PointXYZ] CropBox_t
+ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t
+###
+
+# Sensor
+# template<>
+# class PCL_EXPORTS CropBox<pcl::PCLPointCloud2> : public FilterIndices<pcl::PCLPointCloud2>
+#       using Filter<pcl::PCLPointCloud2>::filter_name_;
+#       using Filter<pcl::PCLPointCloud2>::getClassName;
+#       typedef pcl::PCLPointCloud2 PCLPointCloud2;
+#       typedef PCLPointCloud2::Ptr PCLPointCloud2Ptr;
+#       typedef PCLPointCloud2::ConstPtr PCLPointCloud2ConstPtr;
+#       public:
+#       /** \brief Empty constructor. */
+#       CropBox () :
+#       /** \brief Set the minimum point of the box
+#        * \param[in] min_pt the minimum point of the box
+#       void setMin (const Eigen::Vector4f& min_pt)
+#       /** \brief Get the value of the minimum point of the box, as set by the user
+#        * \return the value of the internal \a min_pt parameter.
+#       Eigen::Vector4f getMin () const
+#       /** \brief Set the maximum point of the box
+#        * \param[in] max_pt the maximum point of the box
+#       void setMax (const Eigen::Vector4f &max_pt)
+#       /** \brief Get the value of the maxiomum point of the box, as set by the user
+#        * \return the value of the internal \a max_pt parameter.
+#       Eigen::Vector4f getMax () const
+#       /** \brief Set a translation value for the box
+#        * \param[in] translation the (tx,ty,tz) values that the box should be translated by
+#       void setTranslation (const Eigen::Vector3f &translation)
+#       /** \brief Get the value of the box translation parameter as set by the user. */
+#       Eigen::Vector3f getTranslation () const
+#       /** \brief Set a rotation value for the box
+#         * \param[in] rotation the (rx,ry,rz) values that the box should be rotated by
+#       void setRotation (const Eigen::Vector3f &rotation)
+#       /** \brief Get the value of the box rotatation parameter, as set by the user. */
+#       Eigen::Vector3f getRotation () const
+#       /** \brief Set a transformation that should be applied to the cloud before filtering
+#        * \param[in] transform an affine transformation that needs to be applied to the cloud before filtering
+#       void setTransform (const Eigen::Affine3f &transform)
+#       /** \brief Get the value of the transformation parameter, as set by the user. */
+#       Eigen::Affine3f getTransform () const
+
+
+###
+
+# crop_hull.h
+#  template<typename PointT>
+#  class CropHull: public FilterIndices<PointT>
+cdef extern from "pcl/filters/crop_hull.h" namespace "pcl":
+    cdef cppclass CropHull[T](FilterIndices[T]):
+        CropHull()
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::indices_;
+        # using Filter<PointT>::input_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # brief Set the vertices of the hull used to filter points.
+        # param[in] polygons Vector of polygons (Vertices structures) forming
+        # the hull used for filtering points.
+        void setHullIndices (const vector[cpp.Vertices]& polygons)
+        
+        # brief Get the vertices of the hull used to filter points.
+        vector[cpp.Vertices] getHullIndices () const
+        
+        # \brief Set the point cloud that the hull indices refer to
+        # \param[in] points the point cloud that the hull indices refer to
+        # void setHullCloud (cpp.PointCloudPtr_t points)
+        void setHullCloud (shared_ptr[cpp.PointCloud[T]] points)
+        
+        #/\brief Get the point cloud that the hull indices refer to. */
+        # cpp.PointCloudPtr_t getHullCloud () const
+        shared_ptr[cpp.PointCloud[T]] getHullCloud ()
+        
+        # brief Set the dimensionality of the hull to be used.
+        # This should be set to correspond to the dimensionality of the
+        # convex/concave hull produced by the pcl::ConvexHull and
+        # pcl::ConcaveHull classes.
+        # param[in] dim Dimensionailty of the hull used to filter points.
+        void setDim (int dim)
+        
+        # \brief Remove points outside the hull (default), or those inside the hull.
+        # \param[in] crop_outside If true, the filter will remove points
+        # outside the hull. If false, those inside will be removed.
+        void setCropOutside(bool crop_outside)
+
+
+ctypedef CropHull[cpp.PointXYZ] CropHull_t
+ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t
+###
+
+# extract_indices.h
+# template<typename PointT>
+# class ExtractIndices : public FilterIndices<PointT>
+cdef extern from "pcl/filters/extract_indices.h" namespace "pcl":
+    cdef cppclass ExtractIndices[T](FilterIndices[T]):
+        ExtractIndices()
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename pcl::traits::fieldList<PointT>::type FieldList;
+        
+        # * \brief Apply the filter and store the results directly in the input cloud.
+        # * \details This method will save the time and memory copy of an output cloud but can not alter the original size of the input cloud:
+        # * It operates as though setKeepOrganized() is true and will overwrite the filtered points instead of remove them.
+        # * All fields of filtered points are replaced with the value set by setUserFilterValue() (default = NaN).
+        # * This method also automatically alters the input cloud set via setInputCloud().
+        # * It does not alter the value of the internal keep organized boolean as set by setKeepOrganized().
+        # * \param[in/out] cloud The point cloud used for input and output.
+        void filterDirectly (cpp.PointCloudPtr_t &cloud);
+
+###
+
+# template<>
+# class PCL_EXPORTS ExtractIndices<sensor_msgs::PointCloud2> : public FilterIndices<sensor_msgs::PointCloud2>
+# public:
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       typedef PointCloud2::Ptr PointCloud2Ptr;
+#       typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       /** \brief Empty constructor. */
+#       ExtractIndices ()
+#     protected:
+#       using PCLBase<PointCloud2>::input_;
+#       using PCLBase<PointCloud2>::indices_;
+#       using PCLBase<PointCloud2>::use_indices_;
+#       using Filter<PointCloud2>::filter_name_;
+#       using Filter<PointCloud2>::getClassName;
+#       using FilterIndices<PointCloud2>::negative_;
+#       using FilterIndices<PointCloud2>::keep_organized_;
+#       using FilterIndices<PointCloud2>::user_filter_value_;
+#       /** \brief Extract point indices into a separate PointCloud
+#         * \param[out] output the resultant point cloud
+#       void applyFilter (PointCloud2 &output);
+#       /** \brief Extract point indices
+#         * \param indices the resultant indices
+#       void applyFilter (std::vector<int> &indices);
+
+###
+
+# normal_space.h
+# template<typename PointT, typename NormalT>
+# class NormalSpaceSampling : public FilterIndices<PointT>
+cdef extern from "pcl/filters/normal_space.h" namespace "pcl":
+    cdef cppclass NormalSpaceSampling[T, Normal](FilterIndices[T]):
+        NormalSpaceSampling()
+        # using FilterIndices<PointT>::filter_name_;
+        # using FilterIndices<PointT>::getClassName;
+        # using FilterIndices<PointT>::indices_;
+        # using FilterIndices<PointT>::input_;
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename pcl::PointCloud<NormalT>::Ptr NormalsPtr;
+        # /** \brief Set number of indices to be sampled.
+        #   * \param[in] sample the number of sample indices
+        void setSample (unsigned int sample)
+        
+        # /** \brief Get the value of the internal \a sample parameter. */
+        unsigned int getSample () const
+        
+        #  \brief Set seed of random function.
+        #   * \param[in] seed the input seed
+        void setSeed (unsigned int seed)
+        
+        # /** \brief Get the value of the internal \a seed parameter. */
+        unsigned int getSeed () const
+        
+        # /** \brief Set the number of bins in x, y and z direction
+        #   * \param[in] binsx number of bins in x direction
+        #   * \param[in] binsy number of bins in y direction
+        #   * \param[in] binsz number of bins in z direction
+        void setBins (unsigned int binsx, unsigned int binsy, unsigned int binsz)
+        
+        # /** \brief Get the number of bins in x, y and z direction
+        #   * \param[out] binsx number of bins in x direction
+        #   * \param[out] binsy number of bins in y direction
+        #   * \param[out] binsz number of bins in z direction
+        void getBins (unsigned int& binsx, unsigned int& binsy, unsigned int& binsz) const
+        
+        # * \brief Set the normals computed on the input point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        # void setNormals (const NormalsPtr &normals)
+        # * \brief Get the normals computed on the input point cloud */
+        # NormalsPtr getNormals () const
+###
+
+# passthrough.h
+# template <typename PointT>
+# class PassThrough : public FilterIndices<PointT>
+cdef extern from "pcl/filters/passthrough.h" namespace "pcl":
+    cdef cppclass PassThrough[T](FilterIndices[T]):
+        PassThrough()
+        void setFilterFieldName (string field_name)
+        string getFilterFieldName ()
+        void setFilterLimits (float min, float max)
+        void getFilterLimits (float &min, float &max)
+        void setFilterLimitsNegative (const bool limit_negative)
+        void getFilterLimitsNegative (bool &limit_negative)
+        bool getFilterLimitsNegative ()
+        # call base Class(PCLBase)
+        # void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # void filter(cpp.PointCloud[T] c)
+
+
+ctypedef PassThrough[cpp.PointXYZ] PassThrough_t
+ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t
+###
+
+# passthrough.h
+# template<>
+# class PCL_EXPORTS PassThrough<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+# cdef extern from "pcl/filters/passthrough.h" namespace "pcl":
+#     cdef cppclass PassThrough[grb.PointCloud2](Filter[grb.PointCloud2]):
+#         PassThrough(bool extract_removed_indices)
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#     using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#     public:
+#       /** \brief Constructor. */
+#       PassThrough (bool extract_removed_indices = false) :
+#       /** \brief Set whether the filtered points should be kept and set to the
+#         * value given through \a setUserFilterValue (default: NaN), or removed
+#         * from the PointCloud, thus potentially breaking its organized
+#         * structure. By default, points are removed.
+#         * \param[in] val set to true whether the filtered points should be kept and
+#         * set to a given user value (default: NaN)
+#       void setKeepOrganized (bool val)
+#       /** \brief Obtain the value of the internal \a keep_organized_ parameter. */
+#       bool getKeepOrganized ()
+#       /** \brief Provide a value that the filtered points should be set to
+#         * instead of removing them.  Used in conjunction with \a
+#         * setKeepOrganized ().
+#         * \param[in] val the user given value that the filtered point dimensions should be set to
+#       void setUserFilterValue (float val)
+#       /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+#         * points having values outside this interval will be discarded.
+#         * \param[in] field_name the name of the field that contains values used for filtering
+#       void setFilterFieldName (const string &field_name)
+#       /** \brief Get the name of the field used for filtering. */
+#       string const getFilterFieldName ()
+#       /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+#         * \param[in] limit_min the minimum allowed field value
+#         * \param[in] limit_max the maximum allowed field value
+#       void setFilterLimits (const double &limit_min, const double &limit_max)
+#       /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+#         * \param[out] limit_min the minimum allowed field value
+#         * \param[out] limit_max the maximum allowed field value
+#       void getFilterLimits (double &limit_min, double &limit_max)
+#       /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+#         * Default: false.
+#         * \param[in] limit_negative return data inside the interval (false) or outside (true)
+#       void setFilterLimitsNegative (const bool limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       void getFilterLimitsNegative (bool &limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       bool getFilterLimitsNegative ()
+
+
+###
+
+# plane_clipper3D.h
+# template<typename PointT>
+# class PlaneClipper3D : public Clipper3D<PointT>
+cdef extern from "pcl/filters/plane_clipper3D.h" namespace "pcl":
+    cdef cppclass PlaneClipper3D[T](Clipper3D[T]):
+        PlaneClipper3D (eigen3.Vector4f plane_params)
+        # PlaneClipper3D (const Eigen::Vector4f& plane_params);
+        # * \brief Set new plane parameters
+        # * \param plane_params
+        # void setPlaneParameters (const Eigen::Vector4f& plane_params);
+        void setPlaneParameters (const eigen3.Vector4f plane_params);
+        
+        # * \brief return the current plane parameters
+        # * \return the current plane parameters
+        # const Eigen::Vector4f& getPlaneParameters () const;
+        eigen3.Vector4f getPlaneParameters ()
+        # virtual bool clipPoint3D (const PointT& point) const;
+        # virtual bool clipLineSegment3D (PointT& from, PointT& to) const;
+        # virtual void clipPlanarPolygon3D (const std::vector<PointT>& polygon, std::vector<PointT>& clipped_polygon) const;
+        # virtual void clipPointCloud3D (const pcl::PointCloud<PointT> &cloud_in, std::vector<int>& clipped, const std::vector<int>& indices = std::vector<int> ()) const;
+        # virtual Clipper3D<PointT>* clone () const;
+###
+
+# project_inliers.h
+# template<typename PointT>
+# class ProjectInliers : public Filter<PointT>
+cdef extern from "pcl/filters/project_inliers.h" namespace "pcl":
+    cdef cppclass ProjectInliers[T](Filter[T]):
+        ProjectInliers ()
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+
+        # public:
+        # brief The type of model to use (user given parameter).
+        # param model the model type (check \a model_types.h)
+        void setModelType (int model)
+        # brief Get the type of SAC model used. */
+        int getModelType ()
+        # brief Provide a pointer to the model coefficients.
+        # param model a pointer to the model coefficients
+        void setModelCoefficients (cpp.ModelCoefficients * model)
+        # brief Get a pointer to the model coefficients. */
+        cpp.ModelCoefficients * getModelCoefficients ()
+        # brief Set whether all data will be returned, or only the projected inliers.
+        # param val true if all data should be returned, false if only the projected inliers
+        void setCopyAllData (bool val)
+        # brief Get whether all data is being copied (true), or only the projected inliers (false). */
+        bool getCopyAllData ()
+
+ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t
+ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] ProjectInliersPtr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] ProjectInliers_PointXYZI_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGB]] ProjectInliers_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGBA]] ProjectInliers_PointXYZRGBA_Ptr_t
+###
+
+# template<>
+# class PCL_EXPORTS ProjectInliers<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     typedef SampleConsensusModel<PointXYZ>::Ptr SampleConsensusModelPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       ProjectInliers () : model_type_ (), copy_all_data_ (false), copy_all_fields_ (true), model_ (), sacmodel_ ()
+#       /** \brief The type of model to use (user given parameter).
+#         * \param[in] model the model type (check \a model_types.h)
+#       void setModelType (int model)
+#       /** \brief Get the type of SAC model used. */
+#       int getModelType () const
+#       /** \brief Provide a pointer to the model coefficients.
+#         * \param[in] model a pointer to the model coefficients
+#       void setModelCoefficients (const ModelCoefficientsConstPtr &model)
+#       /** \brief Get a pointer to the model coefficients. */
+#       ModelCoefficientsConstPtr getModelCoefficients () const
+#       /** \brief Set whether all fields should be copied, or only the XYZ.
+#         * \param[in] val true if all fields will be returned, false if only XYZ
+#       void setCopyAllFields (bool val)
+#       /** \brief Get whether all fields are being copied (true), or only XYZ (false). */
+#       bool getCopyAllFields () const
+#       /** \brief Set whether all data will be returned, or only the projected inliers.
+#         * \param[in] val true if all data should be returned, false if only the projected inliers
+#       void setCopyAllData (bool val)
+#       /** \brief Get whether all data is being copied (true), or only the projected inliers (false). */
+#       bool getCopyAllData () const
+###
+
+# radius_outlier_removal.h
+# template<typename PointT>
+# class RadiusOutlierRemoval : public FilterIndices<PointT>
+cdef extern from "pcl/filters/radius_outlier_removal.h" namespace "pcl":
+    cdef cppclass RadiusOutlierRemoval[T](FilterIndices[T]):
+        RadiusOutlierRemoval ()
+        # brief Set the radius of the sphere that will determine which points are neighbors.
+        # details The number of points within this distance from the query point will need to be equal or greater
+        # than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
+        # param[in] radius The radius of the sphere for nearest neighbor searching.
+        void setRadiusSearch (double radius)
+        # brief Get the radius of the sphere that will determine which points are neighbors.
+        # details The number of points within this distance from the query point will need to be equal or greater
+        # than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
+        # return The radius of the sphere for nearest neighbor searching.
+        double getRadiusSearch ()
+        # brief Set the number of neighbors that need to be present in order to be classified as an inlier.
+        # details The number of points within setRadiusSearch() from the query point will need to be equal or greater
+        # than this number in order to be classified as an inlier point (i.e. will not be filtered).
+        # param min_pts The minimum number of neighbors (default = 1).
+        void setMinNeighborsInRadius (int min_pts)
+        # brief Get the number of neighbors that need to be present in order to be classified as an inlier.
+        # details The number of points within setRadiusSearch() from the query point will need to be equal or greater
+        # than this number in order to be classified as an inlier point (i.e. will not be filtered).
+        # param min_pts The minimum number of neighbors (default = 1).
+        int getMinNeighborsInRadius ()
+
+ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] RadiusOutlierRemovalPtr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] RadiusOutlierRemoval_PointXYZI_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGB]] RadiusOutlierRemoval_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGBA]] RadiusOutlierRemoval_PointXYZRGBA_Ptr_t
+###
+
+
+
+# template<>
+# class PCL_EXPORTS RadiusOutlierRemoval<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#       using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#       using Filter<sensor_msgs::PointCloud2>::getClassName;
+#       using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#       using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#       typedef pcl::search::Search<pcl::PointXYZ> KdTree;
+#       typedef pcl::search::Search<pcl::PointXYZ>::Ptr KdTreePtr;
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       typedef PointCloud2::Ptr PointCloud2Ptr;
+#       typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       public:
+#       /** \brief Empty constructor. */
+#       RadiusOutlierRemoval (bool extract_removed_indices = false) :
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors for filtering.
+#       * \param radius the sphere radius that is to contain all k-nearest neighbors
+#       */
+#       void setRadiusSearch (double radius)
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       double getRadiusSearch ()
+#       /** \brief Set the minimum number of neighbors that a point needs to have in the given search radius in order to
+#       * be considered an inlier (i.e., valid).
+#       * \param min_pts the minimum number of neighbors
+#       */
+#       void setMinNeighborsInRadius (int min_pts)
+#       /** \brief Get the minimum number of neighbors that a point needs to have in the given search radius to be
+#       * considered an inlier and avoid being filtered. 
+#       */
+#       double getMinNeighborsInRadius ()
+###
+
+# random_sample.h
+# template<typename PointT>
+# class RandomSample : public FilterIndices<PointT>
+# cdef cppclass RandomSample[T](FilterIndices[T]):
+cdef extern from "pcl/filters/random_sample.h" namespace "pcl":
+    cdef cppclass RandomSample[T](FilterIndices[T]):
+        RandomSample ()
+        # using FilterIndices<PointT>::filter_name_;
+        # using FilterIndices<PointT>::getClassName;
+        # using FilterIndices<PointT>::indices_;
+        # using FilterIndices<PointT>::input_;
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # /** \brief Set number of indices to be sampled.
+        #   * \param sample
+        void setSample (unsigned int sample)
+        # /** \brief Get the value of the internal \a sample parameter.
+        unsigned int getSample ()
+        # /** \brief Set seed of random function.
+        #   * \param seed
+        void setSeed (unsigned int seed)
+        # /** \brief Get the value of the internal \a seed parameter.
+        unsigned int getSeed ()
+
+# template<>
+# class PCL_EXPORTS RandomSample<sensor_msgs::PointCloud2> : public FilterIndices<sensor_msgs::PointCloud2>
+#     using FilterIndices<sensor_msgs::PointCloud2>::filter_name_;
+#     using FilterIndices<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       RandomSample () : sample_ (UINT_MAX), seed_ (static_cast<unsigned int> (time (NULL)))
+#       /** \brief Set number of indices to be sampled.
+#         * \param sample
+#       void setSample (unsigned int sample)
+#       /** \brief Get the value of the internal \a sample parameter.
+#       unsigned int getSample ()
+#       /** \brief Set seed of random function.
+#         * \param seed
+#       void setSeed (unsigned int seed)
+#       /** \brief Get the value of the internal \a seed parameter.
+#       unsigned int getSeed ()
+###
+
+# statistical_outlier_removal.h
+# template<typename PointT>
+# class StatisticalOutlierRemoval : public FilterIndices<PointT>
+# NG
+# cdef cppclass StatisticalOutlierRemoval[T](FilterIndices[T]):
+cdef extern from "pcl/filters/statistical_outlier_removal.h" namespace "pcl":
+    cdef cppclass StatisticalOutlierRemoval[T]:
+        StatisticalOutlierRemoval()
+        int getMeanK()
+        void setMeanK (int nr_k)
+        double getStddevMulThresh()
+        void setStddevMulThresh (double std_mul)
+        bool getNegative()
+        void setNegative (bool negative)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        void filter(cpp.PointCloud[T] &c)
+
+
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t
+###
+
+# template<>
+# class PCL_EXPORTS StatisticalOutlierRemoval<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#     using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#     typedef pcl::search::Search<pcl::PointXYZ> KdTree;
+#     typedef pcl::search::Search<pcl::PointXYZ>::Ptr KdTreePtr;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       StatisticalOutlierRemoval (bool extract_removed_indices = false) :
+#       /** \brief Set the number of points (k) to use for mean distance estimation
+#         * \param nr_k the number of points to use for mean distance estimation
+#       void setMeanK (int nr_k)
+#       /** \brief Get the number of points to use for mean distance estimation. */
+#       int getMeanK ()
+#       /** \brief Set the standard deviation multiplier threshold. All points outside the
+#         * \f[ \mu \pm \sigma \cdot std\_mul \f]
+#         * will be considered outliers, where \f$ \mu \f$ is the estimated mean,
+#         * and \f$ \sigma \f$ is the standard deviation.
+#         * \param std_mul the standard deviation multiplier threshold
+#       void setStddevMulThresh (double std_mul)
+#       /** \brief Get the standard deviation multiplier threshold as set by the user. */
+#       double getStddevMulThresh ()
+#       /** \brief Set whether the indices should be returned, or all points \e except the indices.
+#         * \param negative true if all points \e except the input indices will be returned, false otherwise
+#       void setNegative (bool negative)
+#       /** \brief Get the value of the internal #negative_ parameter. If
+#         * true, all points \e except the input indices will be returned.
+#         * \return The value of the "negative" flag
+#       bool getNegative ()
+#       void applyFilter (PointCloud2 &output);
+###
+
+# pcl 1.7.2
+# voxel_grid.h
+# namespace pcl
+# /** \brief Obtain the maximum and minimum points in 3D from a given point cloud.
+#   * \param[in] cloud the pointer to a pcl::PCLPointCloud2 dataset
+#   * \param[in] x_idx the index of the X channel
+#   * \param[in] y_idx the index of the Y channel
+#   * \param[in] z_idx the index of the Z channel
+#   * \param[out] min_pt the minimum data point 
+#   * \param[out] max_pt the maximum data point
+#   */
+#   PCL_EXPORTS void 
+#   getMinMax3D (const pcl::PCLPointCloud2ConstPtr &cloud, int x_idx, int y_idx, int z_idx,
+#                Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt);
+###
+
+# pcl 1.7.2
+# voxel_grid.h
+# namespace pcl
+#   /** \brief Obtain the maximum and minimum points in 3D from a given point cloud. 
+#     * \note Performs internal data filtering as well.
+#     * \param[in] cloud the pointer to a pcl::PCLPointCloud2 dataset
+#     * \param[in] x_idx the index of the X channel
+#     * \param[in] y_idx the index of the Y channel
+#     * \param[in] z_idx the index of the Z channel
+#     * \param[in] distance_field_name the name of the dimension to filter data along to
+#     * \param[in] min_distance the minimum acceptable value in \a distance_field_name data
+#     * \param[in] max_distance the maximum acceptable value in \a distance_field_name data
+#     * \param[out] min_pt the minimum data point 
+#     * \param[out] max_pt the maximum data point
+#     * \param[in] limit_negative \b false if data \b inside of the [min_distance; max_distance] interval should be
+#     * considered, \b true otherwise.
+#     */
+#   PCL_EXPORTS void 
+#   getMinMax3D (const pcl::PCLPointCloud2ConstPtr &cloud, int x_idx, int y_idx, int z_idx,
+#                const std::string &distance_field_name, float min_distance, float max_distance, 
+#                Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt, bool limit_negative = false);
+###
+
+# pcl 1.7.2
+# voxel_grid.h
+# namespace pcl
+# /** \brief Get the relative cell indices of the "upper half" 13 neighbors.
+#   * \note Useful in combination with getNeighborCentroidIndices() from \ref VoxelGrid
+#   * \ingroup filters
+#   */
+# inline Eigen::MatrixXi getHalfNeighborCellIndices ()
+###
+
+# pcl 1.7.2
+# voxel_grid.h
+# namespace pcl
+# /** \brief Get the relative cell indices of all the 26 neighbors.
+#   * \note Useful in combination with getNeighborCentroidIndices() from \ref VoxelGrid
+#   * \ingroup filters
+#   */
+# inline Eigen::MatrixXi getAllNeighborCellIndices ()
+###
+
+# pcl 1.7.2
+# voxel_grid.h
+# namespace pcl
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions
+#   * in a given pointcloud, without considering points outside of a distance threshold from the laser origin
+#   * \param[in] cloud the point cloud data message
+#   * \param[in] distance_field_name the field name that contains the distance values
+#   * \param[in] min_distance the minimum distance a point will be considered from
+#   * \param[in] max_distance the maximum distance a point will be considered to
+#   * \param[out] min_pt the resultant minimum bounds
+#   * \param[out] max_pt the resultant maximum bounds
+#   * \param[in] limit_negative if set to true, then all points outside of the interval (min_distance;max_distace) are considered
+#   * \ingroup filters
+#   */
+# template <typename PointT> void 
+# getMinMax3D (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, 
+#              const std::string &distance_field_name, float min_distance, float max_distance,
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt, bool limit_negative = false);
+###
+
+# pcl 1.7.2
+# voxel_grid.h
+# namespace pcl
+# /** \brief Get the minimum and maximum values on each of the 3 (x-y-z) dimensions
+#   * in a given pointcloud, without considering points outside of a distance threshold from the laser origin
+#   * \param[in] cloud the point cloud data message
+#   * \param[in] indices the vector of indices to use
+#   * \param[in] distance_field_name the field name that contains the distance values
+#   * \param[in] min_distance the minimum distance a point will be considered from
+#   * \param[in] max_distance the maximum distance a point will be considered to
+#   * \param[out] min_pt the resultant minimum bounds
+#   * \param[out] max_pt the resultant maximum bounds
+#   * \param[in] limit_negative if set to true, then all points outside of the interval (min_distance;max_distace) are considered
+#   * \ingroup filters
+#   */
+# template <typename PointT> void 
+# getMinMax3D (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, 
+#              const std::vector<int> &indices,
+#              const std::string &distance_field_name, float min_distance, float max_distance,
+#              Eigen::Vector4f &min_pt, Eigen::Vector4f &max_pt, bool limit_negative = false);
+###
+
+# voxel_grid.h
+# template <typename PointT>
+# class VoxelGrid : public Filter<PointT>
+cdef extern from "pcl/filters/voxel_grid.h" namespace "pcl":
+    cdef cppclass VoxelGrid[T](Filter[T]):
+        VoxelGrid()
+        
+        void setLeafSize (float, float, float)
+        # void "setLeafSize" setLeafSize_Eigen(const Eigen::Vector4f &leaf_size) 
+        
+        # inline Eigen::Vector3f getLeafSize ()
+        
+        # use base Class
+        # void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # void filter(cpp.PointCloud[T] c)
+        # /** \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+        #   * \param[in] downsample the new value (true/false)
+        void setDownsampleAllData (bool downsample)
+        
+        # /** \brief Get the state of the internal downsampling parameter (true if
+        #   * all fields need to be downsampled, false if just XYZ). 
+        bool getDownsampleAllData ()
+        
+        # inline void setMinimumPointsNumberPerVoxel (unsigned int min_points_per_voxel)
+        void setMinimumPointsNumberPerVoxel (unsigned int min_points_per_voxel)
+        
+        # inline unsigned int getMinimumPointsNumberPerVoxel ()
+        unsigned int getMinimumPointsNumberPerVoxel ()
+        
+        # /** \brief Set to true if leaf layout information needs to be saved for later access.
+        #   * \param[in] save_leaf_layout the new value (true/false)
+        void setSaveLeafLayout (bool save_leaf_layout)
+        
+        # /** \brief Returns true if leaf layout information will to be saved for later access. */
+        bool getSaveLeafLayout ()
+        
+        # \brief Get the minimum coordinates of the bounding box (after filtering is performed). 
+        # Eigen::Vector3i getMinBoxCoordinates () { return (min_b_.head<3> ()); }
+        eigen3.Vector3i getMinBoxCoordinates ()
+        
+        # \brief Get the minimum coordinates of the bounding box (after filtering is performed). 
+        # Eigen::Vector3i getMaxBoxCoordinates () { return (max_b_.head<3> ()); }
+        eigen3.Vector3i getMaxBoxCoordinates ()
+        
+        # \brief Get the number of divisions along all 3 axes (after filtering is performed). 
+        # Eigen::Vector3i getNrDivisions () { return (div_b_.head<3> ()); }
+        eigen3.Vector3i getNrDivisions ()
+        
+        # \brief Get the multipliers to be applied to the grid coordinates in order to find the centroid index (after filtering is performed). 
+        # Eigen::Vector3i getDivisionMultiplier () { return (divb_mul_.head<3> ()); }
+        eigen3.Vector3i getDivisionMultiplier ()
+        
+        # /** \brief Returns the index in the resulting downsampled cloud of the specified point.
+        #   * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering 
+        #   * performed, and that the point is inside the grid, to avoid invalid access (or use
+        #   * getGridCoordinates+getCentroidIndexAt)
+        #   * \param[in] p the point to get the index at
+        # int getCentroidIndex (const PointT &p)
+        int getCentroidIndex (const T &p)
+        
+        # /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+        #   * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+        #   * \param[in] reference_point the coordinates of the reference point (corresponding cell is allowed to be empty/out of bounds)
+        #   * \param[in] relative_coordinates matrix with the columns being the coordinates of the requested cells, relative to the reference point's cell
+        #   * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+        # std::vector<int> getNeighborCentroidIndices (const PointT &reference_point, const Eigen::MatrixXi &relative_coordinates)
+        # vector[int] getNeighborCentroidIndices (const T &reference_point, const eigen3.MatrixXi &relative_coordinates)
+        
+        # /** \brief Returns the layout of the leafs for fast access to cells relative to current position.
+        #   * \note position at (i-min_x) + (j-min_y)*div_x + (k-min_z)*div_x*div_y holds the index of the element at coordinates (i,j,k) in the grid (-1 if empty)
+        # vector[int] getLeafLayout ()
+        vector[int] getLeafLayout ()
+        
+        # /** \brief Returns the corresponding (i,j,k) coordinates in the grid of point (x,y,z). 
+        #   * \param[in] x the X point coordinate to get the (i, j, k) index at
+        #   * \param[in] y the Y point coordinate to get the (i, j, k) index at
+        #   * \param[in] z the Z point coordinate to get the (i, j, k) index at
+        # Eigen::Vector3i getGridCoordinates (float x, float y, float z) 
+        eigen3.Vector3i getGridCoordinates (float x, float y, float z) 
+        
+        # /** \brief Returns the index in the downsampled cloud corresponding to a given set of coordinates.
+        #   * \param[in] ijk the coordinates (i,j,k) in the grid (-1 if empty)
+        # int getCentroidIndexAt (const Eigen::Vector3i &ijk)
+        int getCentroidIndexAt (const eigen3.Vector3i &ijk)
+        
+        # /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+        #   * points having values outside this interval will be discarded.
+        #   * \param[in] field_name the name of the field that contains values used for filtering
+        # void setFilterFieldName (const std::string &field_name)
+        void setFilterFieldName (const string &field_name)
+        
+        # /** \brief Get the name of the field used for filtering. */
+        # std::string const getFilterFieldName ()
+        const string getFilterFieldName ()
+        
+        # /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+        #   * \param[in] limit_min the minimum allowed field value
+        #   * \param[in] limit_max the maximum allowed field value
+        # void setFilterLimits (const double &limit_min, const double &limit_max)
+        void setFilterLimits (const double &limit_min, const double &limit_max)
+        
+        # /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+        #   * \param[out] limit_min the minimum allowed field value
+        #   * \param[out] limit_max the maximum allowed field value
+        # void getFilterLimits (double &limit_min, double &limit_max)
+        void getFilterLimits (double &limit_min, double &limit_max)
+        
+        # /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+        #   * Default: false.
+        #   * \param[in] limit_negative return data inside the interval (false) or outside (true)
+        # void setFilterLimitsNegative (const bool limit_negative)
+        void setFilterLimitsNegative (const bool limit_negative)
+        
+        # /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+        #   * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+        # void getFilterLimitsNegative (bool &limit_negative)
+        void getFilterLimitsNegative (bool &limit_negative)
+        
+        # /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+        #   * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+        # bool getFilterLimitsNegative ()
+        bool getFilterLimitsNegative ()
+
+
+###
+
+
+# template <>
+# class PCL_EXPORTS VoxelGrid<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       VoxelGrid ()
+#       /** \brief Destructor. */
+#       virtual ~VoxelGrid ()
+#       /** \brief Set the voxel grid leaf size.
+#         * \param[in] leaf_size the voxel grid leaf size
+#       void setLeafSize (const Eigen::Vector4f &leaf_size) 
+#       /** \brief Set the voxel grid leaf size.
+#         * \param[in] lx the leaf size for X
+#         * \param[in] ly the leaf size for Y
+#         * \param[in] lz the leaf size for Z
+#       void setLeafSize (float lx, float ly, float lz)
+#       /** \brief Get the voxel grid leaf size. */
+#       Eigen::Vector3f getLeafSize ()
+#       /** \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+#         * \param[in] downsample the new value (true/false)
+#       void setDownsampleAllData (bool downsample)
+#       /** \brief Get the state of the internal downsampling parameter (true if
+#         * all fields need to be downsampled, false if just XYZ). 
+#       bool getDownsampleAllData ()
+#       /** \brief Set to true if leaf layout information needs to be saved for later access.
+#         * \param[in] save_leaf_layout the new value (true/false)
+#       void setSaveLeafLayout (bool save_leaf_layout)
+#       /** \brief Returns true if leaf layout information will to be saved for later access. */
+#       bool getSaveLeafLayout ()
+#       /** \brief Get the minimum coordinates of the bounding box (after
+#         * filtering is performed). 
+#       Eigen::Vector3i getMinBoxCoordinates ()
+#       /** \brief Get the minimum coordinates of the bounding box (after
+#         * filtering is performed). 
+#       Eigen::Vector3i getMaxBoxCoordinates ()
+#       /** \brief Get the number of divisions along all 3 axes (after filtering
+#         * is performed). 
+#       Eigen::Vector3i getNrDivisions ()
+#       /** \brief Get the multipliers to be applied to the grid coordinates in
+#         * order to find the centroid index (after filtering is performed). 
+#       Eigen::Vector3i getDivisionMultiplier ()
+#       /** \brief Returns the index in the resulting downsampled cloud of the specified point.
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed,
+#         * and that the point is inside the grid, to avoid invalid access (or use getGridCoordinates+getCentroidIndexAt)
+#         * \param[in] x the X point coordinate to get the index at
+#         * \param[in] y the Y point coordinate to get the index at
+#         * \param[in] z the Z point coordinate to get the index at
+#       int getCentroidIndex (float x, float y, float z)
+#       /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+#         * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+#         * \param[in] x the X coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] y the Y coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] z the Z coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[out] relative_coordinates matrix with the columns being the coordinates of the requested cells, relative to the reference point's cell
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+#       vector[int] getNeighborCentroidIndices (float x, float y, float z, const Eigen::MatrixXi &relative_coordinates)
+#       /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+#         * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+#         * \param[in] x the X coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] y the Y coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] z the Z coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[out] relative_coordinates vector with the elements being the coordinates of the requested cells, relative to the reference point's cell
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+#       vector[int] getNeighborCentroidIndices (float x, float y, float z, const vector[Eigen::Vector3i] &relative_coordinates)
+#       /** \brief Returns the layout of the leafs for fast access to cells relative to current position.
+#         * \note position at (i-min_x) + (j-min_y)*div_x + (k-min_z)*div_x*div_y holds the index of the element at coordinates (i,j,k) in the grid (-1 if empty)
+#       vector[int] getLeafLayout ()
+#       /** \brief Returns the corresponding (i,j,k) coordinates in the grid of point (x,y,z).
+#         * \param[in] x the X point coordinate to get the (i, j, k) index at
+#         * \param[in] y the Y point coordinate to get the (i, j, k) index at
+#         * \param[in] z the Z point coordinate to get the (i, j, k) index at
+#       Eigen::Vector3i getGridCoordinates (float x, float y, float z) 
+#       /** \brief Returns the index in the downsampled cloud corresponding to a given set of coordinates.
+#         * \param[in] ijk the coordinates (i,j,k) in the grid (-1 if empty)
+#       int getCentroidIndexAt (const Eigen::Vector3i &ijk)
+#       /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+#         * points having values outside this interval will be discarded.
+#         * \param[in] field_name the name of the field that contains values used for filtering
+#       void setFilterFieldName (const string &field_name)
+#       /** \brief Get the name of the field used for filtering. */
+#       std::string const getFilterFieldName ()
+#       /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+#         * \param[in] limit_min the minimum allowed field value
+#         * \param[in] limit_max the maximum allowed field value
+#       void setFilterLimits (const double &limit_min, const double &limit_max)
+#       /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+#         * \param[out] limit_min the minimum allowed field value
+#         * \param[out] limit_max the maximum allowed field value
+#       void getFilterLimits (double &limit_min, double &limit_max)
+#       /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+#         * Default: false.
+#         * \param[in] limit_negative return data inside the interval (false) or outside (true)
+#       void setFilterLimitsNegative (const bool limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       void getFilterLimitsNegative (bool &limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       bool getFilterLimitsNegative ()
+###
+
+ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t
+ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# conditional_removal.h
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+# typedef enum 
+# {
+# GT, GE, LT, LE, EQ
+# }
+# CompareOp;
+
+# NG
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+#     cdef enum CompareOp:
+#         GT
+#         GE
+#         LT
+#         LE
+#         EQ
+# 
+
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+#     cdef enum CompareOp:
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl"
+#   ctypedef enum CythonCompareOp "pcl::ComparisonOps::CompareOp":
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+    ctypedef enum CompareOp2 "pcl::ComparisonOps::CompareOp":
+        COMPAREOP_GT "pcl::ComparisonOps::GT"
+        COMPAREOP_GE "pcl::ComparisonOps::GE"
+        COMPAREOP_LT "pcl::ComparisonOps::LT"
+        COMPAREOP_LE "pcl::ComparisonOps::LE"
+        COMPAREOP_EQ "pcl::ComparisonOps::EQ"
+
+###
+
+# 1.7.2
+# approximate_voxel_grid.h
+# bilateral.h
+# boost.h
+# box_clipper3D.h
+# clipper3D.h
+# conditional_removal.h
+# convolution.h
+# convolution_3d.h
+# covariance_sampling.h
+# crop_box.h
+# crop_hull.h
+# extract_indices.h
+# fast_bilateral.h
+# fast_bilateral_omp.h
+# filter.h
+# filter_indices.h
+# frustum_culling.h
+# grid_minimum.h
+# local_maximum.h
+# median_filter.h
+# model_outlier_removal.h
+# morphological_filter.h
+# normal_refinement.h
+# normal_space.h
+# passthrough.h
+# plane_clipper3D.h
+# project_inliers.h
+# radius_outlier_removal.h
+# random_sample.h
+# sampling_surface_normal.h
+# shadowpoints.h
+# statistical_outlier_removal.h
+# voxel_grid.h
+# voxel_grid_covariance.h
+# voxel_grid_label.h
+# voxel_grid_occlusion_estimation.h
+### 
diff --git a/pcl/pcl_filters_180.pxd b/pcl/pcl_filters_180.pxd
new file mode 100644
index 0000000..c272819
--- /dev/null
+++ b/pcl/pcl_filters_180.pxd
@@ -0,0 +1,1563 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# import
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# conditional_removal.h
+# template<typename PointT>
+# class ComparisonBase
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ComparisonBase[T]:
+        ComparisonBase()
+        # public:
+        # ctypedef boost::shared_ptr<ComparisonBase<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ComparisonBase<PointT> > ConstPtr;
+        #
+        # brief Return if the comparison is capable.
+        bool isCapable ()
+        
+        # /** \brief Evaluate function. */
+        # virtual bool evaluate (const PointT &point) const = 0;
+
+
+ctypedef ComparisonBase[cpp.PointXYZ] ComparisonBase_t
+ctypedef ComparisonBase[cpp.PointXYZI] ComparisonBase_PointXYZI_t
+ctypedef ComparisonBase[cpp.PointXYZRGB] ComparisonBase_PointXYZRGB_t
+ctypedef ComparisonBase[cpp.PointXYZRGBA] ComparisonBase_PointXYZRGBA_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZ]] ComparisonBasePtr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_Ptr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZ]] ComparisonBaseConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZI]] ComparisonBase_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGB]] ComparisonBase_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ComparisonBase[cpp.PointXYZRGBA]] ComparisonBase_PointXYZRGBA_ConstPtr_t
+###
+
+# conditional_removal.h
+# template<typename PointT>
+# class ConditionBase
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionBase[T]:
+        ConditionBase ()
+        # public:
+        # ctypedef typename pcl::ComparisonBase<PointT> ComparisonBase;
+        # ctypedef typename ComparisonBase::Ptr ComparisonBasePtr;
+        # ctypedef typename ComparisonBase::ConstPtr ComparisonBaseConstPtr;
+        # ctypedef boost::shared_ptr<ConditionBase<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionBase<PointT> > ConstPtr;
+        
+        # NG(Cython 24.0.1) : evaluate is virtual Function
+        # void addComparison (ComparisonBase[T] comparison)
+        # void addComparison (const ComparisonBase[T] comparison)
+        # use Cython 0.25.2
+        void addComparison (shared_ptr[ComparisonBase[T]] comparison)
+        void addCondition (shared_ptr[ConditionBase[T]] condition)
+        bool isCapable ()
+
+
+ctypedef ConditionBase[cpp.PointXYZ] ConditionBase_t
+ctypedef ConditionBase[cpp.PointXYZI] ConditionBase_PointXYZI_t
+ctypedef ConditionBase[cpp.PointXYZRGB] ConditionBase_PointXYZRGB_t
+ctypedef ConditionBase[cpp.PointXYZRGBA] ConditionBase_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZ]] ConditionBasePtr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZ]] ConditionBaseConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZI]] ConditionBase_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGB]] ConditionBase_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionBase[cpp.PointXYZRGBA]] ConditionBase_PointXYZRGBA_ConstPtr_t
+###
+
+# filter.h
+# template<typename PointT>
+# class Filter : public PCLBase<PointT>
+cdef extern from "pcl/filters/filter.h" namespace "pcl":
+    cdef cppclass Filter[T](cpp.PCLBase[T]):
+        Filter()
+        # public:
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::input_;
+        # ctypedef boost::shared_ptr< Filter<PointT> > Ptr;
+        # ctypedef boost::shared_ptr< const Filter<PointT> > ConstPtr;
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        
+        # /** \brief Get the point indices being removed */
+        cpp.IndicesPtr_t getRemovedIndices ()
+        
+        # \brief Calls the filtering method and returns the filtered dataset in output.
+        # \param[out] output the resultant filtered point cloud dataset
+        void filter (cpp.PointCloud[T] &output)
+
+
+ctypedef shared_ptr[Filter[cpp.PointXYZ]] FilterPtr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZI]] Filter_PointXYZI_Ptr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZ]] FilterConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZI]] Filter_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZRGB]] Filter_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const Filter[cpp.PointXYZRGBA]] Filter_PointXYZRGBA_ConstPtr_t
+###
+
+# template<>
+# class PCL_EXPORTS FilterIndices<pcl::PCLPointCloud2> : public Filter<pcl::PCLPointCloud2>
+        # public:
+        # typedef pcl::PCLPointCloud2 PCLPointCloud2;
+        # 
+        # /** \brief Constructor.
+        #   * \param[in] extract_removed_indices Set to true if you want to extract the indices of points being removed (default = false).
+        #   */
+        # FilterIndices (bool extract_removed_indices = false) :
+        #   negative_ (false), 
+        #   keep_organized_ (false), 
+        #   user_filter_value_ (std::numeric_limits<float>::quiet_NaN ())
+        #   
+        # virtual void filter (PCLPointCloud2 &output)
+        # 
+        # /** \brief Calls the filtering method and returns the filtered point cloud indices.
+        #   * \param[out] indices the resultant filtered point cloud indices
+        #   */
+        # void filter (vector[int] &indices);
+        # 
+        # /** \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+        #   * \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+        #   */
+        # inline void setNegative (bool negative)
+        # 
+        # /** \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+        #   * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        #   */
+        # inline bool getNegative ()
+        # 
+        # /** \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+        #   * or removed from the PointCloud, thus potentially breaking its organized structure.
+        #   * \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+        #   */
+        # inline void setKeepOrganized (bool keep_organized)
+        # 
+        # /** \brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+        #   * or removed from the PointCloud, thus potentially breaking its organized structure.
+        #   *  \return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+        #   */
+        # inline bool getKeepOrganized ()
+        # 
+        # /** \brief Provide a value that the filtered points should be set to instead of removing them.
+        #   * Used in conjunction with \a setKeepOrganized ().
+        #   * \param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+        #   */
+        # inline void setUserFilterValue (float value)
+
+
+###
+
+# filter_indices.h
+# template<typename PointT>
+# class FilterIndices : public Filter<PointT>
+cdef extern from "pcl/filters/filter_indices.h" namespace "pcl":
+    cdef cppclass FilterIndices[T](Filter[T]):
+        FilterIndices()
+        # public:
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        
+        ## filter function
+        # same question
+        # http://stackoverflow.com/questions/37186861/sync-bool-compare-and-swap-with-different-parameter-types-in-cython
+        # taisaku : 
+        # Interfacing with External C Code
+        # http://cython-docs2.readthedocs.io/en/latest/src/userguide/external_C_code.html
+        # void filter (cpp.PointCloud[T] &output)
+        void c_filter "filter" (cpp.PointCloud[T] &output)
+        
+        # brief Calls the filtering method and returns the filtered point cloud indices.
+        # param[out] indices the resultant filtered point cloud indices
+        void filter (vector[int] &indices)
+        ## filter function
+        
+        # \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+        # \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+        void setNegative (bool negative)
+        
+        # \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+        # \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        bool getNegative ()
+        
+        # \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+        # or removed from the PointCloud, thus potentially breaking its organized structure.
+        # \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+        void setKeepOrganized (bool keep_organized)
+        
+        # brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+        # or removed from the PointCloud, thus potentially breaking its organized structure.
+        # return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+        bool getKeepOrganized ()
+        
+        # brief Provide a value that the filtered points should be set to instead of removing them.
+        # Used in conjunction with \a setKeepOrganized ().
+        # param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+        void setUserFilterValue (float value)
+        
+        # brief Get the point indices being removed
+        # return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+        cpp.IndicesPtr_t getRemovedIndices ()
+
+
+###
+
+# template<>
+# class PCL_EXPORTS FilterIndices<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#       public:
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       /** \brief Constructor.
+#         * \param[in] extract_removed_indices Set to true if you want to extract the indices of points being removed (default = false).
+#       FilterIndices (bool extract_removed_indices = false) :
+# 
+#       /** \brief Empty virtual destructor. */
+#       virtual ~FilterIndices ()
+#       virtual void filter (PointCloud2 &output)
+# 
+#       /** \brief Calls the filtering method and returns the filtered point cloud indices.
+#         * \param[out] indices the resultant filtered point cloud indices
+#       void filter (vector[int] &indices)
+# 
+#       /** \brief Set whether the regular conditions for points filtering should apply, or the inverted conditions.
+#         * \param[in] negative false = normal filter behavior (default), true = inverted behavior.
+#       void setNegative (bool negative)
+# 
+#       /** \brief Get whether the regular conditions for points filtering should apply, or the inverted conditions.
+#         * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+#       bool getNegative ()
+# 
+#       /** \brief Set whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default: NaN),
+#         * or removed from the PointCloud, thus potentially breaking its organized structure.
+#         * \param[in] keep_organized false = remove points (default), true = redefine points, keep structure.
+#       void setKeepOrganized (bool keep_organized)
+# 
+#       /** \brief Get whether the filtered points should be kept and set to the value given through \a setUserFilterValue (default = NaN),
+#         * or removed from the PointCloud, thus potentially breaking its organized structure.
+#         * \return The value of the internal \a keep_organized_ parameter; false = remove points (default), true = redefine points, keep structure.
+#       bool getKeepOrganized ()
+# 
+#       /** \brief Provide a value that the filtered points should be set to instead of removing them.
+#         * Used in conjunction with \a setKeepOrganized ().
+#         * \param[in] value the user given value that the filtered point dimensions should be set to (default = NaN).
+#       void setUserFilterValue (float value)
+# 
+#       /** \brief Get the point indices being removed
+#         * \return The value of the internal \a negative_ parameter; false = normal filter behavior (default), true = inverted behavior.
+#       IndicesConstPtr const getRemovedIndices ()
+
+
+###
+
+### Inheritance class ###
+
+# approximate_voxel_grid.h
+# NG ###
+# template <typename PointT>
+# struct xNdCopyEigenPointFunctor
+
+# cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+#     cdef struct xNdCopyEigenPointFunctor[T]:
+#         xNdCopyEigenPointFunctor()
+#         # ctypedef typename traits::POD<PointT>::type Pod;
+#         # xNdCopyEigenPointFunctor (const Eigen::VectorXf &p1, PointT &p2)
+#         # template<typename Key> void operator() ()
+# 
+# # template <typename PointT>
+# # struct xNdCopyPointEigenFunctor
+# cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+#     cdef struct xNdCopyPointEigenFunctor[T]:
+#         xNdCopyPointEigenFunctor()
+#         # ctypedef typename traits::POD<PointT>::type Pod;
+#         # xNdCopyPointEigenFunctor (const PointT &p1, Eigen::VectorXf &p2)
+#         # template<typename Key> void operator() ()
+# NG ###
+
+# template <typename PointT>
+# class ApproximateVoxelGrid: public Filter<PointT>
+cdef extern from "pcl/filters/approximate_voxel_grid.h" namespace "pcl":
+    cdef cppclass ApproximateVoxelGrid[T](Filter[T]):
+        ApproximateVoxelGrid()
+        # ApproximateVoxelGrid (const ApproximateVoxelGrid &src) : 
+        # ApproximateVoxelGrid& operator = (const ApproximateVoxelGrid &src)
+        # ApproximateVoxelGrid& element "operator()"(ApproximateVoxelGrid src)
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # * \brief Set the voxel grid leaf size.
+        # * \param[in] leaf_size the voxel grid leaf size
+        void setLeafSize (eigen3.Vector3f &leaf_size)
+        
+        # * \brief Set the voxel grid leaf size.
+        # * \param[in] lx the leaf size for X
+        # * \param[in] ly the leaf size for Y
+        # * \param[in] lz the leaf size for Z
+        void setLeafSize (float lx, float ly, float lz)
+        
+        # /** \brief Get the voxel grid leaf size. */
+        eigen3.Vector3f getLeafSize ()
+        
+        # * \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+        # * \param downsample the new value (true/false)
+        void setDownsampleAllData (bool downsample)
+        
+        # * \brief Get the state of the internal downsampling parameter (true if
+        # * all fields need to be downsampled, false if just XYZ). 
+        bool getDownsampleAllData () const
+
+
+ctypedef ApproximateVoxelGrid[cpp.PointXYZ] ApproximateVoxelGrid_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZI] ApproximateVoxelGrid_PointXYZI_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZRGB] ApproximateVoxelGrid_PointXYZRGB_t
+ctypedef ApproximateVoxelGrid[cpp.PointXYZRGBA] ApproximateVoxelGrid_PointXYZRGBA_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZ]] ApproximateVoxelGridPtr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZI]] ApproximateVoxelGrid_PointXYZI_Ptr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGB]] ApproximateVoxelGrid_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ApproximateVoxelGrid[cpp.PointXYZRGBA]] ApproximateVoxelGrid_PointXYZRGBA_Ptr_t
+###
+
+# bilateral.h
+# template<typename PointT>
+# class BilateralFilter : public Filter<PointT>
+cdef extern from "pcl/filters/bilateral.h" namespace "pcl":
+    cdef cppclass BilateralFilter[T](Filter[T]):
+        BilateralFilter()
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # public:
+        # * \brief Filter the input data and store the results into output
+        # * \param[out] output the resultant point cloud message
+        void applyFilter (cpp.PointCloud[T] &output)
+        
+        # * \brief Compute the intensity average for a single point
+        # * \param[in] pid the point index to compute the weight for
+        # * \param[in] indices the set of nearest neighor indices 
+        # * \param[in] distances the set of nearest neighbor distances
+        # * \return the intensity average at a given point index
+        double  computePointWeight (const int pid, const vector[int] &indices, const vector[float] &distances)
+        
+        # * \brief Set the half size of the Gaussian bilateral filter window.
+        # * \param[in] sigma_s the half size of the Gaussian bilateral filter window to use
+        void setHalfSize (const double sigma_s)
+        
+        # * \brief Get the half size of the Gaussian bilateral filter window as set by the user. */
+        double getHalfSize ()
+        
+        # \brief Set the standard deviation parameter
+        # * \param[in] sigma_r the new standard deviation parameter
+        void setStdDev (const double sigma_r)
+        
+        # * \brief Get the value of the current standard deviation parameter of the bilateral filter. */
+        double getStdDev ()
+        
+        # * \brief Provide a pointer to the search object.
+        # * \param[in] tree a pointer to the spatial search object.
+        # void setSearchMethod (const KdTreePtr &tree)
+
+
+###
+
+# clipper3D.h
+# Override class
+# template<typename PointT>
+# class Clipper3D
+cdef extern from "pcl/filters/bilateral.h" namespace "pcl":
+    cdef cppclass Clipper3D[T]:
+        Clipper3D()
+        # public:
+        # \brief interface to clip a single point
+        # \param[in] point the point to check against
+        # * \return true, it point still exists, false if its clipped
+        # virtual bool clipPoint3D (const PointT& point) const = 0;
+        # 
+        # \brief interface to clip a line segment given by two end points. The order of the end points is unimportant and will sty the same after clipping.
+        # This means basically, that the direction of the line will not flip after clipping.
+        # \param[in,out] pt1 start point of the line
+        # \param[in,out] pt2 end point of the line
+        # \return true if the clipped line is not empty, thus the parameters are still valid, false if line completely outside clipping space
+        # virtual bool clipLineSegment3D (PointT& pt1, PointT& pt2) const = 0;
+        # 
+        # \brief interface to clip a planar polygon given by an ordered list of points
+        # \param[in,out] polygon the polygon in any direction (ccw or cw) but ordered, thus two neighboring points define an edge of the polygon
+        # virtual void clipPlanarPolygon3D (std::vector<PointT>& polygon) const = 0;
+        # 
+        # \brief interface to clip a planar polygon given by an ordered list of points
+        # \param[in] polygon the polygon in any direction (ccw or cw) but ordered, thus two neighboring points define an edge of the polygon
+        # \param[out] clipped_polygon the clipped polygon
+        # virtual void clipPlanarPolygon3D (vector[PointT]& polygon, vector[PointT]& clipped_polygon) const = 0;
+        # 
+        # \brief interface to clip a point cloud
+        # \param[in] cloud_in input point cloud
+        # \param[out] clipped indices of points that remain after clipping the input cloud
+        # \param[in] indices the indices of points in the point cloud to be clipped.
+        # \return list of indices of remaining points after clipping.
+        # virtual void clipPointCloud3D (const pcl::PointCloud<PointT> &cloud_in, std::vector<int>& clipped, const std::vector<int>& indices = std::vector<int> ()) const = 0;
+        # 
+        # \brief polymorphic method to clone the underlying clipper with its parameters.
+        # \return the new clipper object from the specific subclass with all its parameters.
+        # virtual Clipper3D<PointT>* clone () const = 0;
+
+
+###
+
+# NG ###
+# no define constructor
+# template<typename PointT>
+# class PointDataAtOffset
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+#     cdef cppclass PointDataAtOffset[T]:
+#         # PointDataAtOffset (uint8_t datatype, uint32_t offset)
+#         # int compare (const T& p, const double& val);
+
+
+###
+
+# template<typename PointT>
+# class FieldComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass FieldComparison[T](ComparisonBase[T]):
+        FieldComparison (string field_name, CompareOp2 op, double compare_val)
+        # FieldComparison (const FieldComparison &src) :
+        # FieldComparison& operator = (const FieldComparison &src)
+        # using ComparisonBase<PointT>::field_name_;
+        # using ComparisonBase<PointT>::op_;
+        # using ComparisonBase<PointT>::capable_;
+        # public:
+        # ctypedef boost::shared_ptr<FieldComparison<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const FieldComparison<PointT> > ConstPtr;
+
+
+ctypedef FieldComparison[cpp.PointXYZ] FieldComparison_t
+ctypedef FieldComparison[cpp.PointXYZI] FieldComparison_PointXYZI_t
+ctypedef FieldComparison[cpp.PointXYZRGB] FieldComparison_PointXYZRGB_t
+ctypedef FieldComparison[cpp.PointXYZRGBA] FieldComparison_PointXYZRGBA_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZ]] FieldComparisonPtr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_Ptr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZ]] FieldComparisonConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZI]] FieldComparison_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGB]] FieldComparison_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const FieldComparison[cpp.PointXYZRGBA]] FieldComparison_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class PackedRGBComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass PackedRGBComparison[T](ComparisonBase[T]):
+        PackedRGBComparison()
+        # PackedRGBComparison (string component_name, CompareOp op, double compare_val)
+        # using ComparisonBase<PointT>::capable_;
+        # using ComparisonBase<PointT>::op_;
+        # virtual boolevaluate (const PointT &point) const;
+###
+
+# template<typename PointT>
+# class PackedHSIComparison : public ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass PackedHSIComparison[T](ComparisonBase[T]):
+        PackedHSIComparison()
+        # PackedHSIComparison (string component_name, CompareOp op, double compare_val)
+        # using ComparisonBase<PointT>::capable_;
+        # using ComparisonBase<PointT>::op_;
+        # public:
+        # * \brief Construct a PackedHSIComparison 
+        # * \param component_name either "h", "s" or "i"
+        # * \param op the operator to use when making the comparison
+        # * \param compare_val the constant value to compare the component value too
+        # typedef enum
+        # {
+        #   H, // -128 to 127 corresponds to -pi to pi
+        #   S, // 0 to 255
+        #   I  // 0 to 255
+        # } ComponentId;
+###
+
+# template<typename PointT>
+# class TfQuadraticXYZComparison : public pcl::ComparisonBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass TfQuadraticXYZComparison[T](ComparisonBase[T]):
+        TfQuadraticXYZComparison ()
+        # * \param op the operator "[OP]" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_matrix the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_vector the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_scalar the scalar "c" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # * \param comparison_transform the transformation of the comparison.
+        # TfQuadraticXYZComparison (const pcl::ComparisonOps::CompareOp op, const Eigen::Matrix3f &comparison_matrix,
+        #                         const Eigen::Vector3f &comparison_vector, const float &comparison_scalar,
+        #                         const Eigen::Affine3f &comparison_transform = Eigen::Affine3f::Identity ());
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW     //needed whenever there is a fixed size Eigen:: vector or matrix in a class
+        
+        # ctypedef boost::shared_ptr<TfQuadraticXYZComparison<PointT> > Ptr;
+        # typedef boost::shared_ptr<const TfQuadraticXYZComparison<PointT> > ConstPtr;
+        # void setComparisonOperator (const pcl::ComparisonOps::CompareOp op)
+        # * \brief set the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonMatrix (const Eigen::Matrix3f &matrix)
+        
+        # * \brief set the matrix "A" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonMatrix (const Eigen::Matrix4f &homogeneousMatrix)
+        
+        # * \brief set the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonVector (const Eigen::Vector3f &vector)
+        
+        # * \brief set the vector "v" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonVector (const Eigen::Vector4f &homogeneousVector)
+        
+        # * \brief set the scalar "c" of the comparison "p'Ap + 2v'p + c [OP] 0".
+        # void setComparisonScalar (const float &scalar)
+        
+        # * \brief transform the coordinate system of the comparison. If you think of
+        # * the transformation to be a translation and rotation of the comparison in the
+        # * same coordinate system, you have to provide the inverse transformation.
+        # * This function does not change the original definition of the comparison. Thus,
+        # * each call of this function will assume the original definition of the comparison
+        # * as starting point for the transformation.
+        # * @param transform the transformation (rotation and translation) as an affine matrix.
+        # void transformComparison (const Eigen::Matrix4f &transform)
+        
+        # * \brief transform the coordinate system of the comparison. If you think of
+        # * the transformation to be a translation and rotation of the comparison in the
+        # * same coordinate system, you have to provide the inverse transformation.
+        # * This function does not change the original definition of the comparison. Thus,
+        # * each call of this function will assume the original definition of the comparison
+        # * as starting point for the transformation.
+        # * @param transform the transformation (rotation and translation) as an affine matrix.
+        # void transformComparison (const Eigen::Affine3f &transform)
+        
+        # \brief Determine the result of this comparison.
+        # \param point the point to evaluate
+        # \return the result of this comparison.
+        # virtual bool evaluate (const PointT &point) const;
+
+
+###
+# NG end ###
+
+
+# template<typename PointT>
+# class ConditionAnd : public ConditionBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionAnd[T](ConditionBase[T]):
+        ConditionAnd()
+        # using ConditionBase<PointT>::conditions_;
+        # using ConditionBase<PointT>::comparisons_;
+        # public:
+        # ctypedef boost::shared_ptr<ConditionAnd<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionAnd<PointT> > ConstPtr;
+
+
+ctypedef ConditionAnd[cpp.PointXYZ] ConditionAnd_t
+ctypedef ConditionAnd[cpp.PointXYZI] ConditionAnd_PointXYZI_t
+ctypedef ConditionAnd[cpp.PointXYZRGB] ConditionAnd_PointXYZRGB_t
+ctypedef ConditionAnd[cpp.PointXYZRGBA] ConditionAnd_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZ]] ConditionAndPtr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZ]] ConditionAndConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZI]] ConditionAnd_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGB]] ConditionAnd_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionAnd[cpp.PointXYZRGBA]] ConditionAnd_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class ConditionOr : public ConditionBase<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionOr[T](ConditionBase[T]):
+        ConditionOr()
+        # using ConditionBase<PointT>::conditions_;
+        # using ConditionBase<PointT>::comparisons_;
+        # public:
+        # ctypedef boost::shared_ptr<ConditionOr<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const ConditionOr<PointT> > ConstPtr;
+
+
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZ]] ConditionOrPtr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZ]] ConditionOrConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZI]] ConditionOr_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGB]] ConditionOr_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionOr[cpp.PointXYZRGBA]] ConditionOr_PointXYZRGBA_ConstPtr_t
+###
+
+# template<typename PointT>
+# class ConditionalRemoval : public Filter<PointT>
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl":
+    cdef cppclass ConditionalRemoval[T](Filter[T]):
+        ConditionalRemoval()
+        ConditionalRemoval(int)
+        # ConditionalRemoval (ConditionBasePtr condition, bool extract_removed_indices = false)
+        # python invalid default param ?
+        ConditionalRemoval (ConditionBasePtr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZI_Ptr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZRGB_Ptr_t condition, bool extract_removed_indices = false)
+        ConditionalRemoval (ConditionBase_PointXYZRGBA_Ptr_t condition, bool extract_removed_indices = false)
+        # [with PointT = pcl::PointXYZ, pcl::ConditionalRemoval<PointT>::ConditionBasePtr = boost::shared_ptr<pcl::ConditionBase<pcl::PointXYZ> >]
+        # is deprecated (declared at /usr/include/pcl-1.7/pcl/filters/conditional_removal.h:632): ConditionalRemoval(ConditionBasePtr condition, bool extract_removed_indices = false) is deprecated, 
+        # please use the setCondition (ConditionBasePtr condition) function instead. [-Wdeprecated-declarations]
+        # ConditionalRemoval (shared_ptr[]
+        
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # using Filter<PointT>::removed_indices_;
+        # using Filter<PointT>::extract_removed_indices_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # ctypedef typename pcl::ConditionBase<PointT> ConditionBase;
+        # ctypedef typename ConditionBase::Ptr ConditionBasePtr;
+        # ctypedef typename ConditionBase::ConstPtr ConditionBaseConstPtr;
+        void setKeepOrganized (bool val)
+        bool getKeepOrganized ()
+        void setUserFilterValue (float val)
+        # void setCondition (ConditionBasePtr condition);
+        void setCondition (ConditionBasePtr_t condition);
+        void setCondition (ConditionBase_PointXYZI_Ptr_t condition);
+        void setCondition (ConditionBase_PointXYZRGB_Ptr_t condition);
+        void setCondition (ConditionBase_PointXYZRGBA_Ptr_t condition);
+
+
+ctypedef ConditionalRemoval[cpp.PointXYZ] ConditionalRemoval_t
+ctypedef ConditionalRemoval[cpp.PointXYZI] ConditionalRemoval_PointXYZI_t
+ctypedef ConditionalRemoval[cpp.PointXYZRGB] ConditionalRemoval_PointXYZRGB_t
+ctypedef ConditionalRemoval[cpp.PointXYZRGBA] ConditionalRemoval_PointXYZRGBA_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalPtr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_Ptr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZ]] ConditionalRemovalConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZI]] ConditionalRemoval_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGB]] ConditionalRemoval_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const ConditionalRemoval[cpp.PointXYZRGBA]] ConditionalRemoval_PointXYZRGBA_ConstPtr_t
+###
+
+# crop_box.h
+# template<typename PointT>
+# class CropBox : public FilterIndices<PointT>
+cdef extern from "pcl/filters/crop_box.h" namespace "pcl":
+    cdef cppclass CropBox[T](FilterIndices[T]):
+        CropBox()
+        # public:
+        # \brief Set the minimum point of the box
+        # \param[in] min_pt the minimum point of the box
+        void setMin (const eigen3.Vector4f &min_pt)
+        
+        # """
+        # brief Get the value of the minimum point of the box, as set by the user
+        # return the value of the internal \a min_pt parameter.
+        # """
+        eigen3.Vector4f getMin ()
+        
+        # brief Set the maximum point of the box
+        # param[in] max_pt the maximum point of the box
+        void setMax (const eigen3.Vector4f &max_pt)
+        
+        # brief Get the value of the maxiomum point of the box, as set by the user
+        # return the value of the internal \a max_pt parameter.
+        eigen3.Vector4f getMax () const
+        
+        # brief Set a translation value for the box
+        # param[in] translation the (tx,ty,tz) values that the box should be translated by
+        void setTranslation (const eigen3.Vector3f &translation)
+        
+        # brief Get the value of the box translation parameter as set by the user. */
+        eigen3.Vector3f getTranslation () const
+        
+        # brief Set a rotation value for the box
+        # param[in] rotation the (rx,ry,rz) values that the box should be rotated by
+        void setRotation (const eigen3.Vector3f &rotation)
+        
+        # brief Get the value of the box rotatation parameter, as set by the user. */
+        eigen3.Vector3f getRotation () const
+        
+        # brief Set a transformation that should be applied to the cloud before filtering
+        # param[in] transform an affine transformation that needs to be applied to the cloud before filtering
+        void setTransform (const eigen3.Affine3f &transform)
+        
+        # brief Get the value of the transformation parameter, as set by the user. */
+        eigen3.Affine3f getTransform () const
+
+
+ctypedef CropBox[cpp.PointXYZ] CropBox_t
+ctypedef CropBox[cpp.PointXYZI] CropBox_PointXYZI_t
+ctypedef CropBox[cpp.PointXYZRGB] CropBox_PointXYZRGB_t
+ctypedef CropBox[cpp.PointXYZRGBA] CropBox_PointXYZRGBA_t
+###
+
+# Sensor
+# template<>
+# class PCL_EXPORTS CropBox<pcl::PCLPointCloud2> : public FilterIndices<pcl::PCLPointCloud2>
+#       using Filter<pcl::PCLPointCloud2>::filter_name_;
+#       using Filter<pcl::PCLPointCloud2>::getClassName;
+#       typedef pcl::PCLPointCloud2 PCLPointCloud2;
+#       typedef PCLPointCloud2::Ptr PCLPointCloud2Ptr;
+#       typedef PCLPointCloud2::ConstPtr PCLPointCloud2ConstPtr;
+#       public:
+#       /** \brief Empty constructor. */
+#       CropBox () :
+#       /** \brief Set the minimum point of the box
+#        * \param[in] min_pt the minimum point of the box
+#       void setMin (const Eigen::Vector4f& min_pt)
+#       /** \brief Get the value of the minimum point of the box, as set by the user
+#        * \return the value of the internal \a min_pt parameter.
+#       Eigen::Vector4f getMin () const
+#       /** \brief Set the maximum point of the box
+#        * \param[in] max_pt the maximum point of the box
+#       void setMax (const Eigen::Vector4f &max_pt)
+#       /** \brief Get the value of the maxiomum point of the box, as set by the user
+#        * \return the value of the internal \a max_pt parameter.
+#       Eigen::Vector4f getMax () const
+#       /** \brief Set a translation value for the box
+#        * \param[in] translation the (tx,ty,tz) values that the box should be translated by
+#       void setTranslation (const Eigen::Vector3f &translation)
+#       /** \brief Get the value of the box translation parameter as set by the user. */
+#       Eigen::Vector3f getTranslation () const
+#       /** \brief Set a rotation value for the box
+#         * \param[in] rotation the (rx,ry,rz) values that the box should be rotated by
+#       void setRotation (const Eigen::Vector3f &rotation)
+#       /** \brief Get the value of the box rotatation parameter, as set by the user. */
+#       Eigen::Vector3f getRotation () const
+#       /** \brief Set a transformation that should be applied to the cloud before filtering
+#        * \param[in] transform an affine transformation that needs to be applied to the cloud before filtering
+#       void setTransform (const Eigen::Affine3f &transform)
+#       /** \brief Get the value of the transformation parameter, as set by the user. */
+#       Eigen::Affine3f getTransform () const
+
+
+###
+
+# crop_hull.h
+#  template<typename PointT>
+#  class CropHull: public FilterIndices<PointT>
+cdef extern from "pcl/filters/crop_hull.h" namespace "pcl":
+    cdef cppclass CropHull[T](FilterIndices[T]):
+        CropHull()
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::indices_;
+        # using Filter<PointT>::input_;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # brief Set the vertices of the hull used to filter points.
+        # param[in] polygons Vector of polygons (Vertices structures) forming
+        # the hull used for filtering points.
+        void setHullIndices (const vector[cpp.Vertices]& polygons)
+        
+        # brief Get the vertices of the hull used to filter points.
+        vector[cpp.Vertices] getHullIndices () const
+        
+        # \brief Set the point cloud that the hull indices refer to
+        # \param[in] points the point cloud that the hull indices refer to
+        # void setHullCloud (cpp.PointCloudPtr_t points)
+        void setHullCloud (shared_ptr[cpp.PointCloud[T]] points)
+        
+        #/\brief Get the point cloud that the hull indices refer to. */
+        # cpp.PointCloudPtr_t getHullCloud () const
+        shared_ptr[cpp.PointCloud[T]] getHullCloud ()
+        
+        # brief Set the dimensionality of the hull to be used.
+        # This should be set to correspond to the dimensionality of the
+        # convex/concave hull produced by the pcl::ConvexHull and
+        # pcl::ConcaveHull classes.
+        # param[in] dim Dimensionailty of the hull used to filter points.
+        void setDim (int dim)
+        
+        # \brief Remove points outside the hull (default), or those inside the hull.
+        # \param[in] crop_outside If true, the filter will remove points
+        # outside the hull. If false, those inside will be removed.
+        void setCropOutside(bool crop_outside)
+
+
+ctypedef CropHull[cpp.PointXYZ] CropHull_t
+ctypedef CropHull[cpp.PointXYZI] CropHull_PointXYZI_t
+ctypedef CropHull[cpp.PointXYZRGB] CropHull_PointXYZRGB_t
+ctypedef CropHull[cpp.PointXYZRGBA] CropHull_PointXYZRGBA_t
+###
+
+# extract_indices.h
+# template<typename PointT>
+# class ExtractIndices : public FilterIndices<PointT>
+cdef extern from "pcl/filters/extract_indices.h" namespace "pcl":
+    cdef cppclass ExtractIndices[T](FilterIndices[T]):
+        ExtractIndices()
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename pcl::traits::fieldList<PointT>::type FieldList;
+        
+        # * \brief Apply the filter and store the results directly in the input cloud.
+        # * \details This method will save the time and memory copy of an output cloud but can not alter the original size of the input cloud:
+        # * It operates as though setKeepOrganized() is true and will overwrite the filtered points instead of remove them.
+        # * All fields of filtered points are replaced with the value set by setUserFilterValue() (default = NaN).
+        # * This method also automatically alters the input cloud set via setInputCloud().
+        # * It does not alter the value of the internal keep organized boolean as set by setKeepOrganized().
+        # * \param[in/out] cloud The point cloud used for input and output.
+        void filterDirectly (cpp.PointCloudPtr_t &cloud);
+
+###
+
+# template<>
+# class PCL_EXPORTS ExtractIndices<sensor_msgs::PointCloud2> : public FilterIndices<sensor_msgs::PointCloud2>
+# public:
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       typedef PointCloud2::Ptr PointCloud2Ptr;
+#       typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       /** \brief Empty constructor. */
+#       ExtractIndices ()
+#     protected:
+#       using PCLBase<PointCloud2>::input_;
+#       using PCLBase<PointCloud2>::indices_;
+#       using PCLBase<PointCloud2>::use_indices_;
+#       using Filter<PointCloud2>::filter_name_;
+#       using Filter<PointCloud2>::getClassName;
+#       using FilterIndices<PointCloud2>::negative_;
+#       using FilterIndices<PointCloud2>::keep_organized_;
+#       using FilterIndices<PointCloud2>::user_filter_value_;
+#       /** \brief Extract point indices into a separate PointCloud
+#         * \param[out] output the resultant point cloud
+#       void applyFilter (PointCloud2 &output);
+#       /** \brief Extract point indices
+#         * \param indices the resultant indices
+#       void applyFilter (std::vector<int> &indices);
+
+###
+
+# normal_space.h
+# template<typename PointT, typename NormalT>
+# class NormalSpaceSampling : public FilterIndices<PointT>
+cdef extern from "pcl/filters/normal_space.h" namespace "pcl":
+    cdef cppclass NormalSpaceSampling[T, Normal](FilterIndices[T]):
+        NormalSpaceSampling()
+        # using FilterIndices<PointT>::filter_name_;
+        # using FilterIndices<PointT>::getClassName;
+        # using FilterIndices<PointT>::indices_;
+        # using FilterIndices<PointT>::input_;
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename pcl::PointCloud<NormalT>::Ptr NormalsPtr;
+        # /** \brief Set number of indices to be sampled.
+        #   * \param[in] sample the number of sample indices
+        void setSample (unsigned int sample)
+        
+        # /** \brief Get the value of the internal \a sample parameter. */
+        unsigned int getSample () const
+        
+        #  \brief Set seed of random function.
+        #   * \param[in] seed the input seed
+        void setSeed (unsigned int seed)
+        
+        # /** \brief Get the value of the internal \a seed parameter. */
+        unsigned int getSeed () const
+        
+        # /** \brief Set the number of bins in x, y and z direction
+        #   * \param[in] binsx number of bins in x direction
+        #   * \param[in] binsy number of bins in y direction
+        #   * \param[in] binsz number of bins in z direction
+        void setBins (unsigned int binsx, unsigned int binsy, unsigned int binsz)
+        
+        # /** \brief Get the number of bins in x, y and z direction
+        #   * \param[out] binsx number of bins in x direction
+        #   * \param[out] binsy number of bins in y direction
+        #   * \param[out] binsz number of bins in z direction
+        void getBins (unsigned int& binsx, unsigned int& binsy, unsigned int& binsz) const
+        
+        # * \brief Set the normals computed on the input point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        # void setNormals (const NormalsPtr &normals)
+        # * \brief Get the normals computed on the input point cloud */
+        # NormalsPtr getNormals () const
+###
+
+# passthrough.h
+# template <typename PointT>
+# class PassThrough : public FilterIndices<PointT>
+cdef extern from "pcl/filters/passthrough.h" namespace "pcl":
+    cdef cppclass PassThrough[T](FilterIndices[T]):
+        PassThrough()
+        void setFilterFieldName (string field_name)
+        string getFilterFieldName ()
+        void setFilterLimits (float min, float max)
+        void getFilterLimits (float &min, float &max)
+        void setFilterLimitsNegative (const bool limit_negative)
+        void getFilterLimitsNegative (bool &limit_negative)
+        bool getFilterLimitsNegative ()
+        # call base Class(PCLBase)
+        # void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # void filter(cpp.PointCloud[T] c)
+
+
+ctypedef PassThrough[cpp.PointXYZ] PassThrough_t
+ctypedef PassThrough[cpp.PointXYZI] PassThrough_PointXYZI_t
+ctypedef PassThrough[cpp.PointXYZRGB] PassThrough_PointXYZRGB_t
+ctypedef PassThrough[cpp.PointXYZRGBA] PassThrough_PointXYZRGBA_t
+###
+
+# passthrough.h
+# template<>
+# class PCL_EXPORTS PassThrough<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+# cdef extern from "pcl/filters/passthrough.h" namespace "pcl":
+#     cdef cppclass PassThrough[grb.PointCloud2](Filter[grb.PointCloud2]):
+#         PassThrough(bool extract_removed_indices)
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#     using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#     public:
+#       /** \brief Constructor. */
+#       PassThrough (bool extract_removed_indices = false) :
+#       /** \brief Set whether the filtered points should be kept and set to the
+#         * value given through \a setUserFilterValue (default: NaN), or removed
+#         * from the PointCloud, thus potentially breaking its organized
+#         * structure. By default, points are removed.
+#         * \param[in] val set to true whether the filtered points should be kept and
+#         * set to a given user value (default: NaN)
+#       void setKeepOrganized (bool val)
+#       /** \brief Obtain the value of the internal \a keep_organized_ parameter. */
+#       bool getKeepOrganized ()
+#       /** \brief Provide a value that the filtered points should be set to
+#         * instead of removing them.  Used in conjunction with \a
+#         * setKeepOrganized ().
+#         * \param[in] val the user given value that the filtered point dimensions should be set to
+#       void setUserFilterValue (float val)
+#       /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+#         * points having values outside this interval will be discarded.
+#         * \param[in] field_name the name of the field that contains values used for filtering
+#       void setFilterFieldName (const string &field_name)
+#       /** \brief Get the name of the field used for filtering. */
+#       string const getFilterFieldName ()
+#       /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+#         * \param[in] limit_min the minimum allowed field value
+#         * \param[in] limit_max the maximum allowed field value
+#       void setFilterLimits (const double &limit_min, const double &limit_max)
+#       /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+#         * \param[out] limit_min the minimum allowed field value
+#         * \param[out] limit_max the maximum allowed field value
+#       void getFilterLimits (double &limit_min, double &limit_max)
+#       /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+#         * Default: false.
+#         * \param[in] limit_negative return data inside the interval (false) or outside (true)
+#       void setFilterLimitsNegative (const bool limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       void getFilterLimitsNegative (bool &limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       bool getFilterLimitsNegative ()
+
+
+###
+
+# plane_clipper3D.h
+# template<typename PointT>
+# class PlaneClipper3D : public Clipper3D<PointT>
+cdef extern from "pcl/filters/plane_clipper3D.h" namespace "pcl":
+    cdef cppclass PlaneClipper3D[T](Clipper3D[T]):
+        PlaneClipper3D (eigen3.Vector4f plane_params)
+        # PlaneClipper3D (const Eigen::Vector4f& plane_params);
+        # * \brief Set new plane parameters
+        # * \param plane_params
+        # void setPlaneParameters (const Eigen::Vector4f& plane_params);
+        void setPlaneParameters (const eigen3.Vector4f plane_params);
+        
+        # * \brief return the current plane parameters
+        # * \return the current plane parameters
+        # const Eigen::Vector4f& getPlaneParameters () const;
+        eigen3.Vector4f getPlaneParameters ()
+        # virtual bool clipPoint3D (const PointT& point) const;
+        # virtual bool clipLineSegment3D (PointT& from, PointT& to) const;
+        # virtual void clipPlanarPolygon3D (const std::vector<PointT>& polygon, std::vector<PointT>& clipped_polygon) const;
+        # virtual void clipPointCloud3D (const pcl::PointCloud<PointT> &cloud_in, std::vector<int>& clipped, const std::vector<int>& indices = std::vector<int> ()) const;
+        # virtual Clipper3D<PointT>* clone () const;
+###
+
+# project_inliers.h
+# template<typename PointT>
+# class ProjectInliers : public Filter<PointT>
+cdef extern from "pcl/filters/project_inliers.h" namespace "pcl":
+    cdef cppclass ProjectInliers[T](Filter[T]):
+        ProjectInliers ()
+        # using Filter<PointT>::input_;
+        # using Filter<PointT>::indices_;
+        # using Filter<PointT>::filter_name_;
+        # using Filter<PointT>::getClassName;
+        # ctypedef typename Filter<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # ctypedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+
+        # public:
+        # brief The type of model to use (user given parameter).
+        # param model the model type (check \a model_types.h)
+        void setModelType (int model)
+        # brief Get the type of SAC model used. */
+        int getModelType ()
+        # brief Provide a pointer to the model coefficients.
+        # param model a pointer to the model coefficients
+        void setModelCoefficients (cpp.ModelCoefficients * model)
+        # brief Get a pointer to the model coefficients. */
+        cpp.ModelCoefficients * getModelCoefficients ()
+        # brief Set whether all data will be returned, or only the projected inliers.
+        # param val true if all data should be returned, false if only the projected inliers
+        void setCopyAllData (bool val)
+        # brief Get whether all data is being copied (true), or only the projected inliers (false). */
+        bool getCopyAllData ()
+
+ctypedef ProjectInliers[cpp.PointXYZ] ProjectInliers_t
+ctypedef ProjectInliers[cpp.PointXYZI] ProjectInliers_PointXYZI_t
+ctypedef ProjectInliers[cpp.PointXYZRGB] ProjectInliers_PointXYZRGB_t
+ctypedef ProjectInliers[cpp.PointXYZRGBA] ProjectInliers_PointXYZRGBA_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] ProjectInliersPtr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] ProjectInliers_PointXYZI_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGB]] ProjectInliers_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGBA]] ProjectInliers_PointXYZRGBA_Ptr_t
+###
+
+# template<>
+# class PCL_EXPORTS ProjectInliers<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     typedef SampleConsensusModel<PointXYZ>::Ptr SampleConsensusModelPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       ProjectInliers () : model_type_ (), copy_all_data_ (false), copy_all_fields_ (true), model_ (), sacmodel_ ()
+#       /** \brief The type of model to use (user given parameter).
+#         * \param[in] model the model type (check \a model_types.h)
+#       void setModelType (int model)
+#       /** \brief Get the type of SAC model used. */
+#       int getModelType () const
+#       /** \brief Provide a pointer to the model coefficients.
+#         * \param[in] model a pointer to the model coefficients
+#       void setModelCoefficients (const ModelCoefficientsConstPtr &model)
+#       /** \brief Get a pointer to the model coefficients. */
+#       ModelCoefficientsConstPtr getModelCoefficients () const
+#       /** \brief Set whether all fields should be copied, or only the XYZ.
+#         * \param[in] val true if all fields will be returned, false if only XYZ
+#       void setCopyAllFields (bool val)
+#       /** \brief Get whether all fields are being copied (true), or only XYZ (false). */
+#       bool getCopyAllFields () const
+#       /** \brief Set whether all data will be returned, or only the projected inliers.
+#         * \param[in] val true if all data should be returned, false if only the projected inliers
+#       void setCopyAllData (bool val)
+#       /** \brief Get whether all data is being copied (true), or only the projected inliers (false). */
+#       bool getCopyAllData () const
+###
+
+# radius_outlier_removal.h
+# template<typename PointT>
+# class RadiusOutlierRemoval : public FilterIndices<PointT>
+cdef extern from "pcl/filters/radius_outlier_removal.h" namespace "pcl":
+    cdef cppclass RadiusOutlierRemoval[T](FilterIndices[T]):
+        RadiusOutlierRemoval ()
+        # brief Set the radius of the sphere that will determine which points are neighbors.
+        # details The number of points within this distance from the query point will need to be equal or greater
+        # than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
+        # param[in] radius The radius of the sphere for nearest neighbor searching.
+        void setRadiusSearch (double radius)
+        # brief Get the radius of the sphere that will determine which points are neighbors.
+        # details The number of points within this distance from the query point will need to be equal or greater
+        # than setMinNeighborsInRadius() in order to be classified as an inlier point (i.e. will not be filtered).
+        # return The radius of the sphere for nearest neighbor searching.
+        double getRadiusSearch ()
+        # brief Set the number of neighbors that need to be present in order to be classified as an inlier.
+        # details The number of points within setRadiusSearch() from the query point will need to be equal or greater
+        # than this number in order to be classified as an inlier point (i.e. will not be filtered).
+        # param min_pts The minimum number of neighbors (default = 1).
+        void setMinNeighborsInRadius (int min_pts)
+        # brief Get the number of neighbors that need to be present in order to be classified as an inlier.
+        # details The number of points within setRadiusSearch() from the query point will need to be equal or greater
+        # than this number in order to be classified as an inlier point (i.e. will not be filtered).
+        # param min_pts The minimum number of neighbors (default = 1).
+        int getMinNeighborsInRadius ()
+
+ctypedef RadiusOutlierRemoval[cpp.PointXYZ] RadiusOutlierRemoval_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZI] RadiusOutlierRemoval_PointXYZI_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZRGB] RadiusOutlierRemoval_PointXYZRGB_t
+ctypedef RadiusOutlierRemoval[cpp.PointXYZRGBA] RadiusOutlierRemoval_PointXYZRGBA_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZ]] RadiusOutlierRemovalPtr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZI]] RadiusOutlierRemoval_PointXYZI_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGB]] RadiusOutlierRemoval_PointXYZRGB_Ptr_t
+# ctypedef shared_ptr[cpp.ProjectInliers[cpp.PointXYZRGBA]] RadiusOutlierRemoval_PointXYZRGBA_Ptr_t
+###
+
+
+
+# template<>
+# class PCL_EXPORTS RadiusOutlierRemoval<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#       using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#       using Filter<sensor_msgs::PointCloud2>::getClassName;
+#       using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#       using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#       typedef pcl::search::Search<pcl::PointXYZ> KdTree;
+#       typedef pcl::search::Search<pcl::PointXYZ>::Ptr KdTreePtr;
+#       typedef sensor_msgs::PointCloud2 PointCloud2;
+#       typedef PointCloud2::Ptr PointCloud2Ptr;
+#       typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#       public:
+#       /** \brief Empty constructor. */
+#       RadiusOutlierRemoval (bool extract_removed_indices = false) :
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors for filtering.
+#       * \param radius the sphere radius that is to contain all k-nearest neighbors
+#       */
+#       void setRadiusSearch (double radius)
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       double getRadiusSearch ()
+#       /** \brief Set the minimum number of neighbors that a point needs to have in the given search radius in order to
+#       * be considered an inlier (i.e., valid).
+#       * \param min_pts the minimum number of neighbors
+#       */
+#       void setMinNeighborsInRadius (int min_pts)
+#       /** \brief Get the minimum number of neighbors that a point needs to have in the given search radius to be
+#       * considered an inlier and avoid being filtered. 
+#       */
+#       double getMinNeighborsInRadius ()
+###
+
+# random_sample.h
+# template<typename PointT>
+# class RandomSample : public FilterIndices<PointT>
+# cdef cppclass RandomSample[T](FilterIndices[T]):
+cdef extern from "pcl/filters/random_sample.h" namespace "pcl":
+    cdef cppclass RandomSample[T](FilterIndices[T]):
+        RandomSample ()
+        # using FilterIndices<PointT>::filter_name_;
+        # using FilterIndices<PointT>::getClassName;
+        # using FilterIndices<PointT>::indices_;
+        # using FilterIndices<PointT>::input_;
+        # ctypedef typename FilterIndices<PointT>::PointCloud PointCloud;
+        # ctypedef typename PointCloud::Ptr PointCloudPtr;
+        # ctypedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # /** \brief Set number of indices to be sampled.
+        #   * \param sample
+        void setSample (unsigned int sample)
+        # /** \brief Get the value of the internal \a sample parameter.
+        unsigned int getSample ()
+        # /** \brief Set seed of random function.
+        #   * \param seed
+        void setSeed (unsigned int seed)
+        # /** \brief Get the value of the internal \a seed parameter.
+        unsigned int getSeed ()
+
+# template<>
+# class PCL_EXPORTS RandomSample<sensor_msgs::PointCloud2> : public FilterIndices<sensor_msgs::PointCloud2>
+#     using FilterIndices<sensor_msgs::PointCloud2>::filter_name_;
+#     using FilterIndices<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       RandomSample () : sample_ (UINT_MAX), seed_ (static_cast<unsigned int> (time (NULL)))
+#       /** \brief Set number of indices to be sampled.
+#         * \param sample
+#       void setSample (unsigned int sample)
+#       /** \brief Get the value of the internal \a sample parameter.
+#       unsigned int getSample ()
+#       /** \brief Set seed of random function.
+#         * \param seed
+#       void setSeed (unsigned int seed)
+#       /** \brief Get the value of the internal \a seed parameter.
+#       unsigned int getSeed ()
+###
+
+# statistical_outlier_removal.h
+# template<typename PointT>
+# class StatisticalOutlierRemoval : public FilterIndices<PointT>
+# NG
+# cdef cppclass StatisticalOutlierRemoval[T](FilterIndices[T]):
+cdef extern from "pcl/filters/statistical_outlier_removal.h" namespace "pcl":
+    cdef cppclass StatisticalOutlierRemoval[T]:
+        StatisticalOutlierRemoval()
+        int getMeanK()
+        void setMeanK (int nr_k)
+        double getStddevMulThresh()
+        void setStddevMulThresh (double std_mul)
+        bool getNegative()
+        void setNegative (bool negative)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        void filter(cpp.PointCloud[T] &c)
+
+
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZ] StatisticalOutlierRemoval_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZI] StatisticalOutlierRemoval_PointXYZI_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGB] StatisticalOutlierRemoval_PointXYZRGB_t
+ctypedef StatisticalOutlierRemoval[cpp.PointXYZRGBA] StatisticalOutlierRemoval_PointXYZRGBA_t
+###
+
+# template<>
+# class PCL_EXPORTS StatisticalOutlierRemoval<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     using Filter<sensor_msgs::PointCloud2>::removed_indices_;
+#     using Filter<sensor_msgs::PointCloud2>::extract_removed_indices_;
+#     typedef pcl::search::Search<pcl::PointXYZ> KdTree;
+#     typedef pcl::search::Search<pcl::PointXYZ>::Ptr KdTreePtr;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       StatisticalOutlierRemoval (bool extract_removed_indices = false) :
+#       /** \brief Set the number of points (k) to use for mean distance estimation
+#         * \param nr_k the number of points to use for mean distance estimation
+#       void setMeanK (int nr_k)
+#       /** \brief Get the number of points to use for mean distance estimation. */
+#       int getMeanK ()
+#       /** \brief Set the standard deviation multiplier threshold. All points outside the
+#         * \f[ \mu \pm \sigma \cdot std\_mul \f]
+#         * will be considered outliers, where \f$ \mu \f$ is the estimated mean,
+#         * and \f$ \sigma \f$ is the standard deviation.
+#         * \param std_mul the standard deviation multiplier threshold
+#       void setStddevMulThresh (double std_mul)
+#       /** \brief Get the standard deviation multiplier threshold as set by the user. */
+#       double getStddevMulThresh ()
+#       /** \brief Set whether the indices should be returned, or all points \e except the indices.
+#         * \param negative true if all points \e except the input indices will be returned, false otherwise
+#       void setNegative (bool negative)
+#       /** \brief Get the value of the internal #negative_ parameter. If
+#         * true, all points \e except the input indices will be returned.
+#         * \return The value of the "negative" flag
+#       bool getNegative ()
+#       void applyFilter (PointCloud2 &output);
+###
+
+# voxel_grid.h
+# template <typename PointT>
+# class VoxelGrid : public Filter<PointT>
+cdef extern from "pcl/filters/voxel_grid.h" namespace "pcl":
+    cdef cppclass VoxelGrid[T](Filter[T]):
+        VoxelGrid()
+        # void setLeafSize (const Eigen::Vector4f &leaf_size) 
+        void setLeafSize (float, float, float)
+        # void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # void filter(cpp.PointCloud[T] c)
+        # /** \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+        #   * \param[in] downsample the new value (true/false)
+        # void setDownsampleAllData (bool downsample)
+        void setDownsampleAllData (bool downsample)
+        
+        # /** \brief Get the state of the internal downsampling parameter (true if
+        #   * all fields need to be downsampled, false if just XYZ). 
+        # bool getDownsampleAllData ()
+        bool getDownsampleAllData ()
+        
+        # /** \brief Set to true if leaf layout information needs to be saved for later access.
+        #   * \param[in] save_leaf_layout the new value (true/false)
+        # void setSaveLeafLayout (bool save_leaf_layout)
+        void setSaveLeafLayout (bool save_leaf_layout)
+        
+        # /** \brief Returns true if leaf layout information will to be saved for later access. */
+        # bool getSaveLeafLayout () { return (save_leaf_layout_); }
+        bool getSaveLeafLayout ()
+        
+        # \brief Get the minimum coordinates of the bounding box (after filtering is performed). 
+        # Eigen::Vector3i getMinBoxCoordinates () { return (min_b_.head<3> ()); }
+        # eigen3.Vector3i getMinBoxCoordinates ()
+        
+        # \brief Get the minimum coordinates of the bounding box (after filtering is performed). 
+        # Eigen::Vector3i getMaxBoxCoordinates () { return (max_b_.head<3> ()); }
+        # eigen3.Vector3i getMaxBoxCoordinates ()
+        
+        # \brief Get the number of divisions along all 3 axes (after filtering is performed). 
+        # Eigen::Vector3i getNrDivisions () { return (div_b_.head<3> ()); }
+        # eigen3.Vector3i getNrDivisions ()
+        
+        # \brief Get the multipliers to be applied to the grid coordinates in order to find the centroid index (after filtering is performed). 
+        # Eigen::Vector3i getDivisionMultiplier () { return (divb_mul_.head<3> ()); }
+        # eigen3.Vector3i getDivisionMultiplier ()
+        
+        # /** \brief Returns the index in the resulting downsampled cloud of the specified point.
+        #   * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering 
+        #   * performed, and that the point is inside the grid, to avoid invalid access (or use
+        #   * getGridCoordinates+getCentroidIndexAt)
+        #   * \param[in] p the point to get the index at
+        # int getCentroidIndex (const PointT &p)
+        int getCentroidIndex (const T &p)
+        
+        # /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+        #   * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+        #   * \param[in] reference_point the coordinates of the reference point (corresponding cell is allowed to be empty/out of bounds)
+        #   * \param[in] relative_coordinates matrix with the columns being the coordinates of the requested cells, relative to the reference point's cell
+        #   * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+        # std::vector<int> getNeighborCentroidIndices (const PointT &reference_point, const Eigen::MatrixXi &relative_coordinates)
+        # vector[int] getNeighborCentroidIndices (const T &reference_point, const eigen3.MatrixXi &relative_coordinates)
+        
+        # /** \brief Returns the layout of the leafs for fast access to cells relative to current position.
+        #   * \note position at (i-min_x) + (j-min_y)*div_x + (k-min_z)*div_x*div_y holds the index of the element at coordinates (i,j,k) in the grid (-1 if empty)
+        # vector[int] getLeafLayout ()
+        vector[int] getLeafLayout ()
+        
+        # /** \brief Returns the corresponding (i,j,k) coordinates in the grid of point (x,y,z). 
+        #   * \param[in] x the X point coordinate to get the (i, j, k) index at
+        #   * \param[in] y the Y point coordinate to get the (i, j, k) index at
+        #   * \param[in] z the Z point coordinate to get the (i, j, k) index at
+        # Eigen::Vector3i getGridCoordinates (float x, float y, float z) 
+        # eigen3.Vector3i getGridCoordinates (float x, float y, float z) 
+        
+        # /** \brief Returns the index in the downsampled cloud corresponding to a given set of coordinates.
+        #   * \param[in] ijk the coordinates (i,j,k) in the grid (-1 if empty)
+        # int getCentroidIndexAt (const Eigen::Vector3i &ijk)
+        # int getCentroidIndexAt (const eigen3.Vector3i &ijk)
+        
+        # /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+        #   * points having values outside this interval will be discarded.
+        #   * \param[in] field_name the name of the field that contains values used for filtering
+        # void setFilterFieldName (const std::string &field_name)
+        void setFilterFieldName (const string &field_name)
+        
+        # /** \brief Get the name of the field used for filtering. */
+        # std::string const getFilterFieldName ()
+        const string getFilterFieldName ()
+        
+        # /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+        #   * \param[in] limit_min the minimum allowed field value
+        #   * \param[in] limit_max the maximum allowed field value
+        # void setFilterLimits (const double &limit_min, const double &limit_max)
+        void setFilterLimits (const double &limit_min, const double &limit_max)
+        
+        # /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+        #   * \param[out] limit_min the minimum allowed field value
+        #   * \param[out] limit_max the maximum allowed field value
+        # void getFilterLimits (double &limit_min, double &limit_max)
+        void getFilterLimits (double &limit_min, double &limit_max)
+        
+        # /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+        #   * Default: false.
+        #   * \param[in] limit_negative return data inside the interval (false) or outside (true)
+        # void setFilterLimitsNegative (const bool limit_negative)
+        void setFilterLimitsNegative (const bool limit_negative)
+        
+        # /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+        #   * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+        # void getFilterLimitsNegative (bool &limit_negative)
+        void getFilterLimitsNegative (bool &limit_negative)
+        
+        # /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+        #   * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+        # bool getFilterLimitsNegative ()
+        bool getFilterLimitsNegative ()
+
+
+###
+
+# template <>
+# class PCL_EXPORTS VoxelGrid<sensor_msgs::PointCloud2> : public Filter<sensor_msgs::PointCloud2>
+#     using Filter<sensor_msgs::PointCloud2>::filter_name_;
+#     using Filter<sensor_msgs::PointCloud2>::getClassName;
+#     typedef sensor_msgs::PointCloud2 PointCloud2;
+#     typedef PointCloud2::Ptr PointCloud2Ptr;
+#     typedef PointCloud2::ConstPtr PointCloud2ConstPtr;
+#     public:
+#       /** \brief Empty constructor. */
+#       VoxelGrid ()
+#       /** \brief Destructor. */
+#       virtual ~VoxelGrid ()
+#       /** \brief Set the voxel grid leaf size.
+#         * \param[in] leaf_size the voxel grid leaf size
+#       void setLeafSize (const Eigen::Vector4f &leaf_size) 
+#       /** \brief Set the voxel grid leaf size.
+#         * \param[in] lx the leaf size for X
+#         * \param[in] ly the leaf size for Y
+#         * \param[in] lz the leaf size for Z
+#       void setLeafSize (float lx, float ly, float lz)
+#       /** \brief Get the voxel grid leaf size. */
+#       Eigen::Vector3f getLeafSize ()
+#       /** \brief Set to true if all fields need to be downsampled, or false if just XYZ.
+#         * \param[in] downsample the new value (true/false)
+#       void setDownsampleAllData (bool downsample)
+#       /** \brief Get the state of the internal downsampling parameter (true if
+#         * all fields need to be downsampled, false if just XYZ). 
+#       bool getDownsampleAllData ()
+#       /** \brief Set to true if leaf layout information needs to be saved for later access.
+#         * \param[in] save_leaf_layout the new value (true/false)
+#       void setSaveLeafLayout (bool save_leaf_layout)
+#       /** \brief Returns true if leaf layout information will to be saved for later access. */
+#       bool getSaveLeafLayout ()
+#       /** \brief Get the minimum coordinates of the bounding box (after
+#         * filtering is performed). 
+#       Eigen::Vector3i getMinBoxCoordinates ()
+#       /** \brief Get the minimum coordinates of the bounding box (after
+#         * filtering is performed). 
+#       Eigen::Vector3i getMaxBoxCoordinates ()
+#       /** \brief Get the number of divisions along all 3 axes (after filtering
+#         * is performed). 
+#       Eigen::Vector3i getNrDivisions ()
+#       /** \brief Get the multipliers to be applied to the grid coordinates in
+#         * order to find the centroid index (after filtering is performed). 
+#       Eigen::Vector3i getDivisionMultiplier ()
+#       /** \brief Returns the index in the resulting downsampled cloud of the specified point.
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed,
+#         * and that the point is inside the grid, to avoid invalid access (or use getGridCoordinates+getCentroidIndexAt)
+#         * \param[in] x the X point coordinate to get the index at
+#         * \param[in] y the Y point coordinate to get the index at
+#         * \param[in] z the Z point coordinate to get the index at
+#       int getCentroidIndex (float x, float y, float z)
+#       /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+#         * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+#         * \param[in] x the X coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] y the Y coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] z the Z coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[out] relative_coordinates matrix with the columns being the coordinates of the requested cells, relative to the reference point's cell
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+#       vector[int] getNeighborCentroidIndices (float x, float y, float z, const Eigen::MatrixXi &relative_coordinates)
+#       /** \brief Returns the indices in the resulting downsampled cloud of the points at the specified grid coordinates,
+#         * relative to the grid coordinates of the specified point (or -1 if the cell was empty/out of bounds).
+#         * \param[in] x the X coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] y the Y coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[in] z the Z coordinate of the reference point (corresponding cell is allowed to be empty/out of bounds)
+#         * \param[out] relative_coordinates vector with the elements being the coordinates of the requested cells, relative to the reference point's cell
+#         * \note for efficiency, user must make sure that the saving of the leaf layout is enabled and filtering performed
+#       vector[int] getNeighborCentroidIndices (float x, float y, float z, const vector[Eigen::Vector3i] &relative_coordinates)
+#       /** \brief Returns the layout of the leafs for fast access to cells relative to current position.
+#         * \note position at (i-min_x) + (j-min_y)*div_x + (k-min_z)*div_x*div_y holds the index of the element at coordinates (i,j,k) in the grid (-1 if empty)
+#       vector[int] getLeafLayout ()
+#       /** \brief Returns the corresponding (i,j,k) coordinates in the grid of point (x,y,z).
+#         * \param[in] x the X point coordinate to get the (i, j, k) index at
+#         * \param[in] y the Y point coordinate to get the (i, j, k) index at
+#         * \param[in] z the Z point coordinate to get the (i, j, k) index at
+#       Eigen::Vector3i getGridCoordinates (float x, float y, float z) 
+#       /** \brief Returns the index in the downsampled cloud corresponding to a given set of coordinates.
+#         * \param[in] ijk the coordinates (i,j,k) in the grid (-1 if empty)
+#       int getCentroidIndexAt (const Eigen::Vector3i &ijk)
+#       /** \brief Provide the name of the field to be used for filtering data. In conjunction with  \a setFilterLimits,
+#         * points having values outside this interval will be discarded.
+#         * \param[in] field_name the name of the field that contains values used for filtering
+#       void setFilterFieldName (const string &field_name)
+#       /** \brief Get the name of the field used for filtering. */
+#       std::string const getFilterFieldName ()
+#       /** \brief Set the field filter limits. All points having field values outside this interval will be discarded.
+#         * \param[in] limit_min the minimum allowed field value
+#         * \param[in] limit_max the maximum allowed field value
+#       void setFilterLimits (const double &limit_min, const double &limit_max)
+#       /** \brief Get the field filter limits (min/max) set by the user. The default values are -FLT_MAX, FLT_MAX. 
+#         * \param[out] limit_min the minimum allowed field value
+#         * \param[out] limit_max the maximum allowed field value
+#       void getFilterLimits (double &limit_min, double &limit_max)
+#       /** \brief Set to true if we want to return the data outside the interval specified by setFilterLimits (min, max).
+#         * Default: false.
+#         * \param[in] limit_negative return data inside the interval (false) or outside (true)
+#       void setFilterLimitsNegative (const bool limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \param[out] limit_negative true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       void getFilterLimitsNegative (bool &limit_negative)
+#       /** \brief Get whether the data outside the interval (min/max) is to be returned (true) or inside (false). 
+#         * \return true if data \b outside the interval [min; max] is to be returned, false otherwise
+#       bool getFilterLimitsNegative ()
+###
+
+ctypedef VoxelGrid[cpp.PointXYZ] VoxelGrid_t
+ctypedef VoxelGrid[cpp.PointXYZI] VoxelGrid_PointXYZI_t
+ctypedef VoxelGrid[cpp.PointXYZRGB] VoxelGrid_PointXYZRGB_t
+ctypedef VoxelGrid[cpp.PointXYZRGBA] VoxelGrid_PointXYZRGBA_t
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# conditional_removal.h
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+# typedef enum 
+# {
+# GT, GE, LT, LE, EQ
+# }
+# CompareOp;
+
+# NG
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+#     cdef enum CompareOp:
+#         GT
+#         GE
+#         LT
+#         LE
+#         EQ
+# 
+
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+#     cdef enum CompareOp:
+# cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl"
+#   ctypedef enum CythonCompareOp "pcl::ComparisonOps::CompareOp":
+cdef extern from "pcl/filters/conditional_removal.h" namespace "pcl::ComparisonOps":
+    ctypedef enum CompareOp2 "pcl::ComparisonOps::CompareOp":
+        COMPAREOP_GT "pcl::ComparisonOps::GT"
+        COMPAREOP_GE "pcl::ComparisonOps::GE"
+        COMPAREOP_LT "pcl::ComparisonOps::LT"
+        COMPAREOP_LE "pcl::ComparisonOps::LE"
+        COMPAREOP_EQ "pcl::ComparisonOps::EQ"
+
+###
+
+# 1.7.2
+# approximate_voxel_grid.h
+# bilateral.h
+# boost.h
+# box_clipper3D.h
+# clipper3D.h
+# conditional_removal.h
+# convolution.h
+# convolution_3d.h
+# covariance_sampling.h
+# crop_box.h
+# crop_hull.h
+# extract_indices.h
+# fast_bilateral.h
+# fast_bilateral_omp.h
+# filter.h
+# filter_indices.h
+# frustum_culling.h
+# grid_minimum.h
+# local_maximum.h
+# median_filter.h
+# model_outlier_removal.h
+# morphological_filter.h
+# normal_refinement.h
+# normal_space.h
+# passthrough.h
+# plane_clipper3D.h
+# project_inliers.h
+# radius_outlier_removal.h
+# random_sample.h
+# sampling_surface_normal.h
+# shadowpoints.h
+# statistical_outlier_removal.h
+# voxel_grid.h
+# voxel_grid_covariance.h
+# voxel_grid_label.h
+# voxel_grid_occlusion_estimation.h
+### 
diff --git a/pcl/pcl_grabber.pxd b/pcl/pcl_grabber.pxd
new file mode 100644
index 0000000..70d28c6
--- /dev/null
+++ b/pcl/pcl_grabber.pxd
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Header for pcl_grabber.pyx functionality that needs sharing with other modules.
+
+cimport pcl_grabber as cpp
+
+# # class override(PointCloud)
+# cdef class PointCloud:
+#     cdef cpp.PointCloudPtr_t thisptr_shared     # XYZ
+#     
+#     # Buffer protocol support.
+#     cdef Py_ssize_t _shape[2]
+#     cdef Py_ssize_t _view_count
+#     
+#     cdef inline cpp.PointCloud[cpp.PointXYZ] *thisptr(self) nogil:
+#         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+#         return self.thisptr_shared.get()
+# 
+# 
+# # class override(PointCloud_PointXYZI)
+# cdef class PointCloud_PointXYZI:
+#     cdef cpp.PointCloud_PointXYZI_Ptr_t thisptr_shared     # XYZI
+#     
+#     # Buffer protocol support.
+#     cdef Py_ssize_t _shape[2]
+#     cdef Py_ssize_t _view_count
+#     
+#     cdef inline cpp.PointCloud[cpp.PointXYZI] *thisptr(self) nogil:
+#         # Shortcut to get raw pointer to underlying PointCloud<PointXYZ>.
+#         return self.thisptr_shared.get()
+# 
+# 
+# # class override(PointCloud_PointXYZRGB)
+# cdef class PointCloud_PointXYZRGB:
+#     cdef cpp.PointCloud_PointXYZRGB_Ptr_t thisptr_shared
+#     
+#     # Buffer protocol support.
+#     cdef Py_ssize_t _shape[2]
+#     cdef Py_ssize_t _view_count
+#     
+#     cdef inline cpp.PointCloud[cpp.PointXYZRGB] *thisptr(self) nogil:
+#         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGB>.
+#         return self.thisptr_shared.get()
+# 
+# 
+# # class override(PointCloud_PointXYZRGBA)
+# cdef class PointCloud_PointXYZRGBA:
+#     cdef cpp.PointCloud_PointXYZRGBA_Ptr_t thisptr_shared   # XYZRGBA
+#     
+#     # Buffer protocol support.
+#     cdef Py_ssize_t _shape[2]
+#     cdef Py_ssize_t _view_count
+#     
+#     cdef inline cpp.PointCloud[cpp.PointXYZRGBA] *thisptr(self) nogil:
+#         # Shortcut to get raw pointer to underlying PointCloud<PointXYZRGBA>.
+#         return self.thisptr_shared.get()
+# 
diff --git a/pcl/pcl_grabber.pyx b/pcl/pcl_grabber.pyx
new file mode 100644
index 0000000..8711270
--- /dev/null
+++ b/pcl/pcl_grabber.pyx
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# cython: embedsignature=True
+#
+# Copyright 2014 Netherlands eScience Center
+
+from libcpp cimport bool
+
+cimport numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_grabber as pcl_grb
+from boost_shared_ptr cimport shared_ptr
+# https://groups.google.com/forum/#!topic/cython-users/Eeqp4NkbAAA
+cimport _bind_defs 
+
+# from grabber_callback cimport PyLibCallBack
+# from grabber_callback cimport callback
+
+
+### Enum Setting ###
+# pcl_visualization_defs.pxd
+# cdef enum RenderingProperties:
+# Re: [Cython] resolving name conflict -- does not work for enums !? 
+# https://www.mail-archive.com/cython-dev@codespeak.net/msg02494.html
+# PCLVISUALIZER_POINT_SIZE = pcl_grb.PCL_VISUALIZER_POINT_SIZE
+# PCLVISUALIZER_OPACITY = pcl_grb.PCL_VISUALIZER_OPACITY
+# PCLVISUALIZER_LINE_WIDTH = pcl_grb.PCL_VISUALIZER_LINE_WIDTH
+# PCLVISUALIZER_FONT_SIZE = pcl_grb.PCL_VISUALIZER_FONT_SIZE
+# PCLVISUALIZER_COLOR = pcl_grb.PCL_VISUALIZER_COLOR
+# PCLVISUALIZER_REPRESENTATION = pcl_grb.PCL_VISUALIZER_REPRESENTATION
+# PCLVISUALIZER_IMMEDIATE_RENDERING = pcl_grb.PCL_VISUALIZER_IMMEDIATE_RENDERING
+### Enum Setting(define Class InternalType) ###
+
+# CallbackTest
+# include "pxi/Grabber/PyGrabberCallback.pxi"
+# include "pxi/Grabber/PyGrabberNode.pxi"
+
+# -*- coding: utf-8 -*-
+cimport pcl_grabber as pcl_grb
+
+# cdef class PyGrabberCallback:
+#     cdef PyLibCallBack* thisptr
+# 
+#     def __cinit__(self, method):
+#         # 'callback' :: The pattern/converter method to fire a Python 
+#         #               object method from C typed infos
+#         # 'method'   :: The effective method passed by the Python user 
+#         self.thisptr = new PyLibCallBack(callback, <void*>method)
+# 
+#     def __dealloc__(self):
+#        if self.thisptr:
+#            del self.thisptr
+# 
+#     cpdef double execute(self, parameter):
+#         # 'parameter' :: The parameter to be passed to the 'method'
+#         return self.thisptr.cy_execute(<void*>parameter)
+# 
+# cdef class PyGrabberNode:
+#     cdef double d_prop
+# 
+#     # def __cinit__(self):
+#     #     self.thisptr = new PyLibCallBack(callback, <void*>method)
+# 
+#     # def __dealloc__(self):
+#     #    if self.thisptr:
+#     #        del self.thisptr
+# 
+#     def Test(self):
+#         print('PyGrabberNode - Test')
+#         d_prop = 10.0
+
+
+# Grabber
+# pcl 1.8.0 no use
+# include "pxi/Grabber/ONIGrabber.pxi"
+include "pxi/Grabber/OpenNIGrabber.pxi"
+
diff --git a/pcl/pcl_grabber_172.pyx b/pcl/pcl_grabber_172.pyx
new file mode 100644
index 0000000..307669c
--- /dev/null
+++ b/pcl/pcl_grabber_172.pyx
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# cython: embedsignature=True
+#
+# Copyright 2014 Netherlands eScience Center
+
+from libcpp cimport bool
+
+cimport numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_grabber_defs_172 as pcl_grb
+from boost_shared_ptr cimport shared_ptr
+
+
+### Enum Setting ###
+# pcl_visualization_defs.pxd
+# cdef enum RenderingProperties:
+# Re: [Cython] resolving name conflict -- does not work for enums !? 
+# https://www.mail-archive.com/cython-dev@codespeak.net/msg02494.html
+# PCLVISUALIZER_POINT_SIZE = pcl_grb.PCL_VISUALIZER_POINT_SIZE
+# PCLVISUALIZER_OPACITY = pcl_grb.PCL_VISUALIZER_OPACITY
+# PCLVISUALIZER_LINE_WIDTH = pcl_grb.PCL_VISUALIZER_LINE_WIDTH
+# PCLVISUALIZER_FONT_SIZE = pcl_grb.PCL_VISUALIZER_FONT_SIZE
+# PCLVISUALIZER_COLOR = pcl_grb.PCL_VISUALIZER_COLOR
+# PCLVISUALIZER_REPRESENTATION = pcl_grb.PCL_VISUALIZER_REPRESENTATION
+# PCLVISUALIZER_IMMEDIATE_RENDERING = pcl_grb.PCL_VISUALIZER_IMMEDIATE_RENDERING
+### Enum Setting(define Class InternalType) ###
+
+# Grabber Callback
+# include "pxi/Grabber/PyGrabberCallback.pxi"
+
+# Grabber
+# include "pxi/Grabber/ONIGrabber.pxi"
+# include "pxi/Grabber/OpenNIGrabber.pxi"
+
diff --git a/pcl/pcl_grabber_180.pyx b/pcl/pcl_grabber_180.pyx
new file mode 100644
index 0000000..d13c67f
--- /dev/null
+++ b/pcl/pcl_grabber_180.pyx
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+# cython: embedsignature=True
+#
+# Copyright 2014 Netherlands eScience Center
+
+from libcpp cimport bool
+
+cimport numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_grabber_defs_180 as pcl_grb
+from boost_shared_ptr cimport shared_ptr
+
+
+### Enum Setting ###
+# pcl_visualization_defs.pxd
+# cdef enum RenderingProperties:
+# Re: [Cython] resolving name conflict -- does not work for enums !? 
+# https://www.mail-archive.com/cython-dev@codespeak.net/msg02494.html
+# PCLVISUALIZER_POINT_SIZE = pcl_grb.PCL_VISUALIZER_POINT_SIZE
+# PCLVISUALIZER_OPACITY = pcl_grb.PCL_VISUALIZER_OPACITY
+# PCLVISUALIZER_LINE_WIDTH = pcl_grb.PCL_VISUALIZER_LINE_WIDTH
+# PCLVISUALIZER_FONT_SIZE = pcl_grb.PCL_VISUALIZER_FONT_SIZE
+# PCLVISUALIZER_COLOR = pcl_grb.PCL_VISUALIZER_COLOR
+# PCLVISUALIZER_REPRESENTATION = pcl_grb.PCL_VISUALIZER_REPRESENTATION
+# PCLVISUALIZER_IMMEDIATE_RENDERING = pcl_grb.PCL_VISUALIZER_IMMEDIATE_RENDERING
+### Enum Setting(define Class InternalType) ###
+
+# Grabber
+# include "pxi/Grabber/ONIGrabber.pxi"
+# include "pxi/Grabber/OpenNIGrabber.pxi"
+
diff --git a/pcl/pcl_grabber_defs.pxd b/pcl/pcl_grabber_defs.pxd
new file mode 100644
index 0000000..313622b
--- /dev/null
+++ b/pcl/pcl_grabber_defs.pxd
@@ -0,0 +1,434 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# main
+cimport pcl_defs as cpp
+
+from boost_shared_ptr cimport shared_ptr
+# from boost_function cimport function
+# from boost_signal2_connection cimport connection
+# bind
+from _bind_defs cimport connection
+from _bind_defs cimport arg
+from _bind_defs cimport function
+from _bind_defs cimport callback_t
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# grabber.h
+# namespace pcl
+# /** \brief Grabber interface for PCL 1.x device drivers
+#  * \author Suat Gedikli <gedikli@willowgarage.com>
+#  * \ingroup io
+#  */
+# class PCL_EXPORTS Grabber
+cdef extern from "pcl/io/grabber.h" namespace "pcl":
+    cdef cppclass Grabber:
+        Grabber ()
+        # public:
+        # /** \brief registers a callback function/method to a signal with the corresponding signature
+        #   * \param[in] callback: the callback function/method
+        #   * \return Connection object, that can be used to disconnect the callback method from the signal again.
+        # template<typename T> boost::signals2::connection registerCallback (const boost::function<T>& callback);
+        # connection registerCallback[T](function[T]& callback)
+        connection registerCallback[T](function[T] callback)
+        
+        # /** \brief indicates whether a signal with given parameter-type exists or not
+        #   * \return true if signal exists, false otherwise
+        # template<typename T> bool providesCallback () const;
+        bool providesCallback[T]()
+        
+        # 
+        # /** \brief For devices that are streaming, the streams are started by calling this method.
+        #   *        Trigger-based devices, just trigger the device once for each call of start.
+        # virtual void start () = 0;
+        # 
+        # /** \brief For devices that are streaming, the streams are stopped.
+        #   *        This method has no effect for triggered devices.
+        # virtual void stop () = 0;
+        # 
+        # /** \brief returns the name of the concrete subclass.
+        #   * \return the name of the concrete driver.
+        # virtual std::string getName () const = 0;
+        # 
+        # /** \brief Indicates whether the grabber is streaming or not. This value is not defined for triggered devices.
+        #   * \return true if grabber is running / streaming. False otherwise.
+        # virtual bool isRunning () const = 0;
+        # 
+        # /** \brief returns fps. 0 if trigger based. */
+        # virtual float getFramesPerSecond () const = 0;
+
+
+# template<typename T> boost::signals2::signal<T>* Grabber::find_signal () const
+# template<typename T> void Grabber::disconnect_all_slots ()
+# template<typename T> void Grabber::block_signal ()
+# template<typename T> void Grabber::unblock_signal ()
+# void Grabber::block_signals ()
+# void Grabber::unblock_signals ()
+# template<typename T> int Grabber::num_slots () const
+# template<typename T> boost::signals2::signal<T>* Grabber::createSignal ()
+# template<typename T> boost::signals2::connection Grabber::registerCallback (const boost::function<T> & callback)
+# template<typename T> bool Grabber::providesCallback () const
+
+
+###
+
+# oni_grabber.h
+# namespace pcl
+#     struct PointXYZ;
+#     struct PointXYZRGB;
+#     struct PointXYZRGBA;
+#     struct PointXYZI;
+# template <typename T> class PointCloud;
+# /** \brief A simple ONI grabber.
+#  * \author Suat Gedikli
+# class PCL_EXPORTS ONIGrabber : public Grabber
+# cdef extern from "pcl/io/oni_grabber.h" namespace "pcl":
+#     cdef cppclass ONIGrabber(Grabber):
+#         ONIGrabber (string file_name, bool repeat, bool stream)
+        # public:
+        # //define callback signature typedefs
+        # typedef void (sig_cb_openni_image) (const boost::shared_ptr<openni_wrapper::Image>&);
+        # typedef void (sig_cb_openni_depth_image) (const boost::shared_ptr<openni_wrapper::DepthImage>&);
+        # typedef void (sig_cb_openni_ir_image) (const boost::shared_ptr<openni_wrapper::IRImage>&);
+        # typedef void (sig_cb_openni_image_depth_image) (const boost::shared_ptr<openni_wrapper::Image>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_ir_depth_image) (const boost::shared_ptr<openni_wrapper::IRImage>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_openni_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # /** \brief For devices that are streaming, the streams are started by calling this method.
+        #   * Trigger-based devices, just trigger the device once for each call of start.
+        # void start ()
+        # 
+        # /** \brief For devices that are streaming, the streams are stopped.
+        #  *        This method has no effect for triggered devices.
+        #  */
+        # void stop ()
+        #
+        # /** \brief returns the name of the concrete subclass.
+        #  * \return the name of the concrete driver.
+        #  */
+        # string getName ()
+        #
+        # /** \brief Indicates whether the grabber is streaming or not. This value is not defined for triggered devices.
+        #  * \return true if grabber is running / streaming. False otherwise.
+        #  */
+        # bool isRunning ()
+        # 
+        # /** \brief returns the frames pre second. 0 if it is trigger based. */
+        # float getFramesPerSecond ()
+        # 
+        # protected:
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles image streams */
+        # void imageCallback (boost::shared_ptr<openni_wrapper::Image> image, void* cookie);
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles depth streams */
+        # void depthCallback (boost::shared_ptr<openni_wrapper::DepthImage> depth_image, void* cookie);
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles IR streams */
+        # void irCallback (boost::shared_ptr<openni_wrapper::IRImage> ir_image, void* cookie);
+        # /** \brief internal callback that handles synchronized image + depth streams */
+        # void imageDepthImageCallback (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                         const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image);
+        # /** \brief internal callback that handles synchronized IR + depth streams */
+        # void irDepthImageCallback (const boost::shared_ptr<openni_wrapper::IRImage> &image,
+        #                      const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image);
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZ> > convertToXYZPointCloud (const boost::shared_ptr<openni_wrapper::DepthImage> &depth) const;
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZRGB> >
+        # convertToXYZRGBPointCloud (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                           const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZRGBA> >
+        # convertToXYZRGBAPointCloud (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                            const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZI> >
+        # convertToXYZIPointCloud (const boost::shared_ptr<openni_wrapper::IRImage> &image,
+        #                         const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief synchronizer object to synchronize image and depth streams*/
+        # Synchronizer<boost::shared_ptr<openni_wrapper::Image>, boost::shared_ptr<openni_wrapper::DepthImage> > rgb_sync_;
+        # 
+        # /** \brief synchronizer object to synchronize IR and depth streams*/
+        # Synchronizer<boost::shared_ptr<openni_wrapper::IRImage>, boost::shared_ptr<openni_wrapper::DepthImage> > ir_sync_;
+        # 
+        # /** \brief the actual openni device*/
+        # boost::shared_ptr<openni_wrapper::DeviceONI> device_;
+        # std::string rgb_frame_id_;
+        # std::string depth_frame_id_;
+        # bool running_;
+        # unsigned image_width_;
+        # unsigned image_height_;
+        # unsigned depth_width_;
+        # unsigned depth_height_;
+        # openni_wrapper::OpenNIDevice::CallbackHandle depth_callback_handle;
+        # openni_wrapper::OpenNIDevice::CallbackHandle image_callback_handle;
+        # openni_wrapper::OpenNIDevice::CallbackHandle ir_callback_handle;
+        # boost::signals2::signal<sig_cb_openni_image >*            image_signal_;
+        # boost::signals2::signal<sig_cb_openni_depth_image >*      depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_image >*         ir_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_image_depth_image>* image_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_depth_image>*    ir_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud >*      point_cloud_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_i >*    point_cloud_i_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgb >*  point_cloud_rgb_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgba >*  point_cloud_rgba_signal_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+
+###
+
+# openni_grabber.h
+# namespace pcl
+#   struct PointXYZ;
+#   struct PointXYZRGB;
+#   struct PointXYZRGBA;
+#   struct PointXYZI;
+#   template <typename T> class PointCloud;
+# 
+# /** \brief Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
+#   * \author Nico Blodow <blodow@cs.tum.edu>, Suat Gedikli <gedikli@willowgarage.com>
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS OpenNIGrabber : public Grabber
+cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+    cdef cppclass OpenNIGrabber(Grabber):
+        # OpenNIGrabber ()
+        OpenNIGrabber (string device_id, Mode2 depth_mode, Mode2 image_mode)
+        # OpenNIGrabber (const std::string& device_id = "",
+        #                const Mode& depth_mode = OpenNI_Default_Mode,
+        #                const Mode& image_mode = OpenNI_Default_Mode);
+        # public:
+        # //define callback signature typedefs
+        # typedef void (sig_cb_openni_image) (const boost::shared_ptr<openni_wrapper::Image>&);
+        # typedef void (sig_cb_openni_depth_image) (const boost::shared_ptr<openni_wrapper::DepthImage>&);
+        # typedef void (sig_cb_openni_ir_image) (const boost::shared_ptr<openni_wrapper::IRImage>&);
+        # typedef void (sig_cb_openni_image_depth_image) (const boost::shared_ptr<openni_wrapper::Image>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_ir_depth_image) (const boost::shared_ptr<openni_wrapper::IRImage>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_openni_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # typedef void (sig_cb_openni_point_cloud_eigen) (const boost::shared_ptr<const pcl::PointCloud<Eigen::MatrixXf> >&);
+        # public:
+        # /** \brief Start the data acquisition. */
+        void start ()
+        
+        # /** \brief Stop the data acquisition. */
+        void stop ()
+        
+        # /** \brief Check if the data acquisition is still running. */
+        bool isRunning ()
+        
+        string getName ()
+        
+        # /** \brief Obtain the number of frames per second (FPS). */
+        float getFramesPerSecond () const
+        
+        # /** \brief Get a boost shared pointer to the \ref OpenNIDevice object. */
+        # inline shared_ptr[openni_wrapper::OpenNIDevice] getDevice () const;
+        # /** \brief Obtain a list of the available depth modes that this device supports. */
+        # vector[pair[int, XnMapOutputMode] ] getAvailableDepthModes ()
+        # /** \brief Obtain a list of the available image modes that this device supports. */
+        # vector[pair[int, XnMapOutputMode] ] getAvailableImageModes ()
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+# 
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#   cdef boost::shared_ptr<openni_wrapper::OpenNIDevice>
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#   cdef OpenNIGrabber::getDevice () const
+###
+
+# pcd_grabber.h
+# namespace pcl
+# /** \brief Base class for PCD file grabber.
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS PCDGrabberBase : public Grabber
+cdef extern from "pcl/io/pcd_grabber.h" namespace "pcl":
+    cdef cppclass PCDGrabberBase(Grabber):
+        PCDGrabberBase ()
+        # public:
+        # /** \brief Constructor taking just one PCD file or one TAR file containing multiple PCD files.
+        #   * \param[in] pcd_file path to the PCD file
+        #   * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        #   * \param[in] repeat whether to play PCD file in an endless loop or not.
+        #   */
+        # PCDGrabberBase (const std::string& pcd_file, float frames_per_second, bool repeat);
+        # 
+        # /** \brief Constructor taking a list of paths to PCD files, that are played in the order they appear in the list.
+        #   * \param[in] pcd_files vector of paths to PCD files.
+        #   * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        #   * \param[in] repeat whether to play PCD file in an endless loop or not.
+        #   */
+        # PCDGrabberBase (const std::vector<std::string>& pcd_files, float frames_per_second, bool repeat);
+        # 
+        # /** \brief Copy constructor.
+        #   * \param[in] src the PCD Grabber base object to copy into this
+        #   */
+        # PCDGrabberBase (const PCDGrabberBase &src) : impl_ ()
+        # /** \brief Copy operator.
+        #   * \param[in] src the PCD Grabber base object to copy into this
+        #   */
+        # PCDGrabberBase&
+        # operator = (const PCDGrabberBase &src)
+        # {
+        #   impl_ = src.impl_;
+        #   return (*this);
+        # }
+        # 
+        # /** \brief Virtual destructor. */
+        # virtual ~PCDGrabberBase () throw ();
+        # 
+        # /** \brief Starts playing the list of PCD files if frames_per_second is > 0. Otherwise it works as a trigger: publishes only the next PCD file in the list. */
+        # virtual void 
+        # start ();
+        # 
+        # /** \brief Stops playing the list of PCD files if frames_per_second is > 0. Otherwise the method has no effect. */
+        # virtual void 
+        # stop ();
+        # 
+        # /** \brief Triggers a callback with new data */
+        # virtual void 
+        # trigger ();
+        # 
+        # /** \brief whether the grabber is started (publishing) or not.
+        #   * \return true only if publishing.
+        #   */
+        # virtual bool 
+        # isRunning () const;
+        # 
+        # /** \return The name of the grabber */
+        # virtual std::string 
+        # getName () const;
+        # 
+        # /** \brief Rewinds to the first PCD file in the list.*/
+        # virtual void 
+        # rewind ();
+        # 
+        # /** \brief Returns the frames_per_second. 0 if grabber is trigger-based */
+        # virtual float 
+        # getFramesPerSecond () const;
+        # 
+        # /** \brief Returns whether the repeat flag is on */
+        # bool 
+        # isRepeatOn () const;
+
+
+###
+
+# template <typename PointT> class PCDGrabber : public PCDGrabberBase
+cdef extern from "pcl/io/pcd_grabber.h" namespace "pcl":
+    cdef cppclass PCDGrabber[T](PCDGrabberBase):
+        PCDGrabber ()
+        # PCDGrabber (const std::string& pcd_path, float frames_per_second = 0, bool repeat = false);
+        # PCDGrabber (const std::vector<std::string>& pcd_files, float frames_per_second = 0, bool repeat = false);
+        # protected:
+        # virtual void publish (const sensor_msgs::PointCloud2& blob, const Eigen::Vector4f& origin, const Eigen::Quaternionf& orientation) const;
+        # boost::signals2::signal<void (const boost::shared_ptr<const pcl::PointCloud<PointT> >&)>* signal_;
+        # #ifdef HAVE_OPENNI
+        #   boost::signals2::signal<void (const boost::shared_ptr<openni_wrapper::DepthImage>&)>*     depth_image_signal_;
+        # # #endif
+# 
+#   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#   template<typename PointT>
+#   PCDGrabber<PointT>::PCDGrabber (const std::string& pcd_path, float frames_per_second, bool repeat)
+#   : PCDGrabberBase (pcd_path, frames_per_second, repeat)
+#   {
+#     signal_ = createSignal<void (const boost::shared_ptr<const pcl::PointCloud<PointT> >&)>();
+# #ifdef HAVE_OPENNI
+#     depth_image_signal_ = createSignal <void (const boost::shared_ptr<openni_wrapper::DepthImage>&)> ();
+# #endif
+#   }
+# 
+#   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#   template<typename PointT>
+#   PCDGrabber<PointT>::PCDGrabber (const std::vector<std::string>& pcd_files, float frames_per_second, bool repeat)
+#     : PCDGrabberBase (pcd_files, frames_per_second, repeat), signal_ ()
+#   {
+#     signal_ = createSignal<void (const boost::shared_ptr<const pcl::PointCloud<PointT> >&)>();
+# #ifdef HAVE_OPENNI
+#     depth_image_signal_ = createSignal <void (const boost::shared_ptr<openni_wrapper::DepthImage>&)> ();
+# #endif
+#   }
+# 
+#   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#   template<typename PointT> void 
+#   PCDGrabber<PointT>::publish (const sensor_msgs::PointCloud2& blob, const Eigen::Vector4f& origin, const Eigen::Quaternionf& orientation) const
+#   {
+#     typename pcl::PointCloud<PointT>::Ptr cloud (new pcl::PointCloud<PointT> ());
+#     pcl::fromROSMsg (blob, *cloud);
+#     cloud->sensor_origin_ = origin;
+#     cloud->sensor_orientation_ = orientation;
+# 
+#     signal_->operator () (cloud);
+# 
+# #ifdef HAVE_OPENNI
+#     // If dataset is not organized, return
+#     if (!cloud->isOrganized ())
+#       return;
+# 
+#     boost::shared_ptr<xn::DepthMetaData> depth_meta_data (new xn::DepthMetaData);
+#     depth_meta_data->AllocateData (cloud->width, cloud->height);
+#     XnDepthPixel* depth_map = depth_meta_data->WritableData ();
+#     uint32_t k = 0;
+#     for (uint32_t i = 0; i < cloud->height; ++i)
+#       for (uint32_t j = 0; j < cloud->width; ++j)
+#       {
+#         depth_map[k] = static_cast<XnDepthPixel> ((*cloud)[k].z * 1000);
+#         ++k;
+#       }
+# 
+#     boost::shared_ptr<openni_wrapper::DepthImage> depth_image (new openni_wrapper::DepthImage (depth_meta_data, 0.075f, 525, 0, 0));
+#     if (depth_image_signal_->num_slots() > 0)
+#       depth_image_signal_->operator()(depth_image);
+# #endif
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#     cdef cppclass OpenNIGrabber(Grabber):
+#         # public:
+#         # typedef enum
+#         #   OpenNI_Default_Mode = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+#         #   OpenNI_SXGA_15Hz = 1,    // Only supported by the Kinect
+#         #   OpenNI_VGA_30Hz = 2,     // Supported by PSDK, Xtion and Kinect
+#         #   OpenNI_VGA_25Hz = 3,     // Supportged by PSDK and Xtion
+#         #   OpenNI_QVGA_25Hz = 4,    // Supported by PSDK and Xtion
+#         #   OpenNI_QVGA_30Hz = 5,    // Supported by PSDK, Xtion and Kinect
+#         #   OpenNI_QVGA_60Hz = 6,    // Supported by PSDK and Xtion
+#         #   OpenNI_QQVGA_25Hz = 7,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         #   OpenNI_QQVGA_30Hz = 8,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         #   OpenNI_QQVGA_60Hz = 9    // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         # } Mode;
+cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+    ctypedef enum Mode2 "pcl::OpenNIGrabber":
+        Grabber_OpenNI_Default_Mode "pcl::OpenNIGrabber::OpenNI_Default_Mode"   # = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+        Grabber_OpenNI_SXGA_15Hz "pcl::OpenNIGrabber::OpenNI_SXGA_15Hz"         # = 1, // Only supported by the Kinect
+        Grabber_OpenNI_VGA_30Hz "pcl::OpenNIGrabber::OpenNI_VGA_30Hz"           # = 2, // Supported by PSDK, Xtion and Kinect
+        Grabber_OpenNI_VGA_25Hz "pcl::OpenNIGrabber::OpenNI_VGA_25Hz"           # = 3, // Supportged by PSDK and Xtion
+        Grabber_OpenNI_QVGA_25Hz "pcl::OpenNIGrabber::OpenNI_QVGA_25Hz"         # = 4, // Supported by PSDK and Xtion
+        Grabber_OpenNI_QVGA_30Hz "pcl::OpenNIGrabber::OpenNI_QVGA_30Hz"         # = 5, // Supported by PSDK, Xtion and Kinect
+        Grabber_OpenNI_QVGA_60Hz "pcl::OpenNIGrabber::OpenNI_QVGA_60Hz"         # = 6, // Supported by PSDK and Xtion
+        Grabber_OpenNI_QQVGA_25Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_25Hz"       # = 7, // Not supported -> using software downsampling (only for integer scale factor and only NN)
+        Grabber_OpenNI_QQVGA_30Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_30Hz"       # = 8, // Not supported -> using software downsampling (only for integer scale factor and only NN)
+        Grabber_OpenNI_QQVGA_60Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_60Hz"       # = 9  // Not supported -> using software downsampling (only for integer scale factor and only NN)
+
+
diff --git a/pcl/pcl_grabber_defs_172.pxd b/pcl/pcl_grabber_defs_172.pxd
new file mode 100644
index 0000000..ec918be
--- /dev/null
+++ b/pcl/pcl_grabber_defs_172.pxd
@@ -0,0 +1,1415 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# main
+cimport pcl_defs as cpp
+
+from boost_shared_ptr cimport shared_ptr
+# from boost_function cimport function
+# from boost_signal2_connection cimport connection
+# bind
+from _bind_defs cimport connection
+from _bind_defs cimport arg
+from _bind_defs cimport function
+from _bind_defs cimport callback_t
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# grabber.h
+# namespace pcl
+# /** \brief Grabber interface for PCL 1.x device drivers
+#  * \author Suat Gedikli <gedikli@willowgarage.com>
+#  * \ingroup io
+#  */
+# class PCL_EXPORTS Grabber
+cdef extern from "pcl/io/grabber.h" namespace "pcl":
+    cdef cppclass Grabber:
+        Grabber ()
+        # public:
+        # /** \brief registers a callback function/method to a signal with the corresponding signature
+        #   * \param[in] callback: the callback function/method
+        #   * \return Connection object, that can be used to disconnect the callback method from the signal again.
+        # template<typename T> boost::signals2::connection registerCallback (const boost::function<T>& callback);
+        # connection registerCallback[T](function[T]& callback)
+        connection registerCallback[T](function[T] callback)
+        
+        # /** \brief indicates whether a signal with given parameter-type exists or not
+        #   * \return true if signal exists, false otherwise
+        # template<typename T> bool providesCallback () const;
+        bool providesCallback[T]()
+        
+        # 
+        # /** \brief For devices that are streaming, the streams are started by calling this method.
+        #   *        Trigger-based devices, just trigger the device once for each call of start.
+        # virtual void start () = 0;
+        # 
+        # /** \brief For devices that are streaming, the streams are stopped.
+        #   *        This method has no effect for triggered devices.
+        # virtual void stop () = 0;
+        # 
+        # /** \brief returns the name of the concrete subclass.
+        #   * \return the name of the concrete driver.
+        # virtual std::string getName () const = 0;
+        # 
+        # /** \brief Indicates whether the grabber is streaming or not. This value is not defined for triggered devices.
+        #   * \return true if grabber is running / streaming. False otherwise.
+        # virtual bool isRunning () const = 0;
+        # 
+        # /** \brief returns fps. 0 if trigger based. */
+        # virtual float getFramesPerSecond () const = 0;
+
+
+# template<typename T> boost::signals2::signal<T>* Grabber::find_signal () const
+# template<typename T> void Grabber::disconnect_all_slots ()
+# template<typename T> void Grabber::block_signal ()
+# template<typename T> void Grabber::unblock_signal ()
+# void Grabber::block_signals ()
+# void Grabber::unblock_signals ()
+# template<typename T> int Grabber::num_slots () const
+# template<typename T> boost::signals2::signal<T>* Grabber::createSignal ()
+# template<typename T> boost::signals2::connection Grabber::registerCallback (const boost::function<T> & callback)
+# template<typename T> bool Grabber::providesCallback () const
+
+
+###
+
+# Syncronization contains mutex
+# oni_grabber.h defined Syncronization protected member
+# http://stackoverflow.com/questions/9284352/boost-mutex-strange-error-with-private-member
+# oni_grabber.h
+# namespace pcl
+#     struct PointXYZ;
+#     struct PointXYZRGB;
+#     struct PointXYZRGBA;
+#     struct PointXYZI;
+# template <typename T> class PointCloud;
+# /** \brief A simple ONI grabber.
+#  * \author Suat Gedikli
+# class PCL_EXPORTS ONIGrabber : public Grabber
+# cdef extern from "pcl/io/oni_grabber.h" namespace "pcl":
+#     cdef cppclass ONIGrabber(Grabber):
+#         ONIGrabber (string file_name, bool repeat, bool stream)
+        # public:
+        # //define callback signature typedefs
+        # typedef void (sig_cb_openni_image) (const boost::shared_ptr<openni_wrapper::Image>&);
+        # typedef void (sig_cb_openni_depth_image) (const boost::shared_ptr<openni_wrapper::DepthImage>&);
+        # typedef void (sig_cb_openni_ir_image) (const boost::shared_ptr<openni_wrapper::IRImage>&);
+        # typedef void (sig_cb_openni_image_depth_image) (const boost::shared_ptr<openni_wrapper::Image>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_ir_depth_image) (const boost::shared_ptr<openni_wrapper::IRImage>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_openni_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # /** \brief For devices that are streaming, the streams are started by calling this method.
+        #   * Trigger-based devices, just trigger the device once for each call of start.
+        # void start ()
+        # 
+        # /** \brief For devices that are streaming, the streams are stopped.
+        #  *        This method has no effect for triggered devices.
+        #  */
+        # void stop ()
+        #
+        # /** \brief returns the name of the concrete subclass.
+        #  * \return the name of the concrete driver.
+        #  */
+        # string getName ()
+        #
+        # /** \brief Indicates whether the grabber is streaming or not. This value is not defined for triggered devices.
+        #  * \return true if grabber is running / streaming. False otherwise.
+        #  */
+        # bool isRunning ()
+        # 
+        # /** \brief returns the frames pre second. 0 if it is trigger based. */
+        # float getFramesPerSecond ()
+        # 
+        # protected:
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles image streams */
+        # void imageCallback (boost::shared_ptr<openni_wrapper::Image> image, void* cookie);
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles depth streams */
+        # void depthCallback (boost::shared_ptr<openni_wrapper::DepthImage> depth_image, void* cookie);
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles IR streams */
+        # void irCallback (boost::shared_ptr<openni_wrapper::IRImage> ir_image, void* cookie);
+        # /** \brief internal callback that handles synchronized image + depth streams */
+        # void imageDepthImageCallback (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                         const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image);
+        # /** \brief internal callback that handles synchronized IR + depth streams */
+        # void irDepthImageCallback (const boost::shared_ptr<openni_wrapper::IRImage> &image,
+        #                      const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image);
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZ> > convertToXYZPointCloud (const boost::shared_ptr<openni_wrapper::DepthImage> &depth) const;
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZRGB> >
+        # convertToXYZRGBPointCloud (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                           const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZRGBA> >
+        # convertToXYZRGBAPointCloud (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                            const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZI> >
+        # convertToXYZIPointCloud (const boost::shared_ptr<openni_wrapper::IRImage> &image,
+        #                         const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief synchronizer object to synchronize image and depth streams*/
+        # Synchronizer<boost::shared_ptr<openni_wrapper::Image>, boost::shared_ptr<openni_wrapper::DepthImage> > rgb_sync_;
+        # 
+        # /** \brief synchronizer object to synchronize IR and depth streams*/
+        # Synchronizer<boost::shared_ptr<openni_wrapper::IRImage>, boost::shared_ptr<openni_wrapper::DepthImage> > ir_sync_;
+        # 
+        # /** \brief the actual openni device*/
+        # boost::shared_ptr<openni_wrapper::DeviceONI> device_;
+        # std::string rgb_frame_id_;
+        # std::string depth_frame_id_;
+        # bool running_;
+        # unsigned image_width_;
+        # unsigned image_height_;
+        # unsigned depth_width_;
+        # unsigned depth_height_;
+        # openni_wrapper::OpenNIDevice::CallbackHandle depth_callback_handle;
+        # openni_wrapper::OpenNIDevice::CallbackHandle image_callback_handle;
+        # openni_wrapper::OpenNIDevice::CallbackHandle ir_callback_handle;
+        # boost::signals2::signal<sig_cb_openni_image >*            image_signal_;
+        # boost::signals2::signal<sig_cb_openni_depth_image >*      depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_image >*         ir_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_image_depth_image>* image_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_depth_image>*    ir_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud >*      point_cloud_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_i >*    point_cloud_i_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgb >*  point_cloud_rgb_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgba >*  point_cloud_rgba_signal_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+
+###
+
+# Syncronization contains mutex
+# oni_grabber.h defined Syncronization protected member
+# openni_grabber.h
+# namespace pcl
+#   struct PointXYZ;
+#   struct PointXYZRGB;
+#   struct PointXYZRGBA;
+#   struct PointXYZI;
+#   template <typename T> class PointCloud;
+###
+# openni_grabber.h
+# /** \brief Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
+#   * \author Nico Blodow <blodow@cs.tum.edu>, Suat Gedikli <gedikli@willowgarage.com>
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS OpenNIGrabber : public Grabber
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#     cdef cppclass OpenNIGrabber(Grabber):
+        # OpenNIGrabber ()
+        # OpenNIGrabber (string device_id, Mode2 depth_mode, Mode2 image_mode)
+        # OpenNIGrabber (const std::string& device_id = "",
+        #                const Mode& depth_mode = OpenNI_Default_Mode,
+        #                const Mode& image_mode = OpenNI_Default_Mode);
+        # public:
+        # //define callback signature typedefs
+        # typedef void (sig_cb_openni_image) (const boost::shared_ptr<openni_wrapper::Image>&);
+        # typedef void (sig_cb_openni_depth_image) (const boost::shared_ptr<openni_wrapper::DepthImage>&);
+        # typedef void (sig_cb_openni_ir_image) (const boost::shared_ptr<openni_wrapper::IRImage>&);
+        # typedef void (sig_cb_openni_image_depth_image) (const boost::shared_ptr<openni_wrapper::Image>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_ir_depth_image) (const boost::shared_ptr<openni_wrapper::IRImage>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_openni_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # typedef void (sig_cb_openni_point_cloud_eigen) (const boost::shared_ptr<const pcl::PointCloud<Eigen::MatrixXf> >&);
+        # public:
+        # /** \brief Start the data acquisition. */
+        # void start ()
+        # 
+        # /** \brief Stop the data acquisition. */
+        # void stop ()
+        # 
+        # /** \brief Check if the data acquisition is still running. */
+        # bool isRunning ()
+        # 
+        # string getName ()
+        # 
+        # /** \brief Obtain the number of frames per second (FPS). */
+        # float getFramesPerSecond () const
+        # 
+        # /** \brief Get a boost shared pointer to the \ref OpenNIDevice object. */
+        # inline shared_ptr[openni_wrapper::OpenNIDevice] getDevice () const;
+        # /** \brief Obtain a list of the available depth modes that this device supports. */
+        # vector[pair[int, XnMapOutputMode] ] getAvailableDepthModes ()
+        # /** \brief Obtain a list of the available image modes that this device supports. */
+        # vector[pair[int, XnMapOutputMode] ] getAvailableImageModes ()
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#   cdef boost::shared_ptr<openni_wrapper::OpenNIDevice>
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#   cdef OpenNIGrabber::getDevice () const
+###
+
+# pcd_grabber.h
+# namespace pcl
+# /** \brief Base class for PCD file grabber.
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS PCDGrabberBase : public Grabber
+cdef extern from "pcl/io/pcd_grabber.h" namespace "pcl":
+    cdef cppclass PCDGrabberBase(Grabber):
+        PCDGrabberBase ()
+        # public:
+        # /** \brief Constructor taking just one PCD file or one TAR file containing multiple PCD files.
+        #   * \param[in] pcd_file path to the PCD file
+        #   * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        #   * \param[in] repeat whether to play PCD file in an endless loop or not.
+        #   */
+        # PCDGrabberBase (const std::string& pcd_file, float frames_per_second, bool repeat);
+        # 
+        # /** \brief Constructor taking a list of paths to PCD files, that are played in the order they appear in the list.
+        #   * \param[in] pcd_files vector of paths to PCD files.
+        #   * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        #   * \param[in] repeat whether to play PCD file in an endless loop or not.
+        #   */
+        # PCDGrabberBase (const std::vector<std::string>& pcd_files, float frames_per_second, bool repeat);
+        # 
+        # /** \brief Copy constructor.
+        #   * \param[in] src the PCD Grabber base object to copy into this
+        #   */
+        # PCDGrabberBase (const PCDGrabberBase &src) : impl_ ()
+        # /** \brief Copy operator.
+        #   * \param[in] src the PCD Grabber base object to copy into this
+        #   */
+        # PCDGrabberBase& operator = (const PCDGrabberBase &src)
+        # 
+        # /** \brief Virtual destructor. */
+        # virtual ~PCDGrabberBase () throw ();
+        # 
+        # /** \brief Starts playing the list of PCD files if frames_per_second is > 0. Otherwise it works as a trigger: publishes only the next PCD file in the list. */
+        # virtual void start ();
+        # 
+        # /** \brief Stops playing the list of PCD files if frames_per_second is > 0. Otherwise the method has no effect. */
+        # virtual void stop ();
+        # 
+        # /** \brief Triggers a callback with new data */
+        # virtual void trigger ();
+        # 
+        # /** \brief whether the grabber is started (publishing) or not.
+        #   * \return true only if publishing.
+        #   */
+        # virtual bool isRunning () const;
+        # 
+        # /** \return The name of the grabber */
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Rewinds to the first PCD file in the list.*/
+        # virtual void rewind ();
+        # 
+        # /** \brief Returns the frames_per_second. 0 if grabber is trigger-based */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Returns whether the repeat flag is on */
+        # bool isRepeatOn () const;
+
+
+###
+
+# template <typename PointT> class PCDGrabber : public PCDGrabberBase
+cdef extern from "pcl/io/pcd_grabber.h" namespace "pcl":
+    cdef cppclass PCDGrabber[T](PCDGrabberBase):
+        PCDGrabber ()
+        # PCDGrabber (const std::string& pcd_path, float frames_per_second = 0, bool repeat = false);
+        # PCDGrabber (const std::vector<std::string>& pcd_files, float frames_per_second = 0, bool repeat = false);
+        # protected:
+        # virtual void publish (const sensor_msgs::PointCloud2& blob, const Eigen::Vector4f& origin, const Eigen::Quaternionf& orientation) const;
+        # boost::signals2::signal<void (const boost::shared_ptr<const pcl::PointCloud<PointT> >&)>* signal_;
+        # #ifdef HAVE_OPENNI
+        #   boost::signals2::signal<void (const boost::shared_ptr<openni_wrapper::DepthImage>&)>*     depth_image_signal_;
+        # # #endif
+
+
+###
+
+# template<typename PointT>
+# PCDGrabber<PointT>::PCDGrabber (const std::string& pcd_path, float frames_per_second, bool repeat)
+# : PCDGrabberBase (pcd_path, frames_per_second, repeat)
+###
+
+# template<typename PointT>
+# PCDGrabber<PointT>::PCDGrabber (const std::vector<std::string>& pcd_files, float frames_per_second, bool repeat)
+#   : PCDGrabberBase (pcd_files, frames_per_second, repeat), signal_ ()
+###
+
+# template<typename PointT> void 
+# PCDGrabber<PointT>::publish (const sensor_msgs::PointCloud2& blob, const Eigen::Vector4f& origin, const Eigen::Quaternionf& orientation) const
+###
+
+# file_grabber.h
+# namespace pcl
+# /** \brief FileGrabber provides a container-style interface for grabbers which operate on fixed-size input
+#   * \author Stephen Miller
+#   * \ingroup io
+#   */
+# template <typename PointT>
+# class PCL_EXPORTS FileGrabber
+# cdef extern from "pcl/io/file_grabber.h" namespace "pcl":
+#     cdef cppclass FileGrabber:
+#         FileGrabber()
+        # public:
+        # /** \brief Empty destructor */
+        # virtual ~FileGrabber () {}
+        # 
+        # /** \brief operator[] Returns the idx-th cloud in the dataset, without bounds checking.
+        #  *  Note that in the future, this could easily be modified to do caching
+        #  *  \param[in] idx The frame to load
+        # */
+        # virtual const boost::shared_ptr< const pcl::PointCloud<PointT> > operator[] (size_t idx) const = 0;
+        # 
+        # /** \brief size Returns the number of clouds currently loaded by the grabber */
+        # virtual size_t size () const = 0;
+        # 
+        # /** \brief at Returns the idx-th cloud in the dataset, with bounds checking
+        #  *  \param[in] idx The frame to load
+        # */
+        # virtual const boost::shared_ptr< const pcl::PointCloud<PointT> > at (size_t idx) const
+
+
+###
+
+# fotonic_grabber.h
+# namespace pcl
+# 
+# struct PointXYZ;
+# struct PointXYZRGB;
+# struct PointXYZRGBA;
+# struct PointXYZI;
+# template <typename T> class PointCloud;
+# 
+# fotonic_grabber.h
+# namespace pcl
+# /** \brief Grabber for Fotonic devices
+#   * \author Stefan Holzer <holzers@in.tum.de>
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS FotonicGrabber : public Grabber
+# cdef extern from "pcl/io/fotonic_grabber.h" namespace "pcl":
+#     cdef cppclass FotonicGrabber(Grabber):
+#         FotonicGrabber()
+        # public:
+        # typedef enum
+        # {
+        #   Fotonic_Default_Mode = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+        # } Mode;
+        # 
+        # //define callback signature typedefs
+        # typedef void (sig_cb_fotonic_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_fotonic_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_fotonic_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_fotonic_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # public:
+        # /** \brief Constructor
+        #   * \param[in] device_id ID of the device, which might be a serial number, bus@address or the index of the device.
+        #   * \param[in] depth_mode the mode of the depth stream
+        #   * \param[in] image_mode the mode of the image stream
+        #   */
+        # FotonicGrabber (const FZ_DEVICE_INFO& device_info,
+        #                 const Mode& depth_mode = Fotonic_Default_Mode,
+        #                 const Mode& image_mode = Fotonic_Default_Mode);
+        # 
+        # /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
+        # virtual ~FotonicGrabber () throw ();
+        # 
+        # /** \brief Initializes the Fotonic API. */
+        # static void initAPI ();
+        # 
+        # /** \brief Exits the Fotonic API. */
+        # static void exitAPI ();
+        # 
+        # /** \brief Searches for available devices. */
+        # static std::vector<FZ_DEVICE_INFO> enumDevices ();
+        # 
+        # /** \brief Start the data acquisition. */
+        # virtual void start ();
+        # 
+        # /** \brief Stop the data acquisition. */
+        # virtual void stop ();
+        # 
+        # /** \brief Check if the data acquisition is still running. */
+        # virtual bool isRunning () const;
+        # 
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Obtain the number of frames per second (FPS). */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # protected:
+        # /** \brief On initialization processing. */
+        # void onInit (const FZ_DEVICE_INFO& device_info, const Mode& depth_mode, const Mode& image_mode);
+        # /** \brief Sets up an OpenNI device. */
+        # void setupDevice (const FZ_DEVICE_INFO& device_info, const Mode& depth_mode, const Mode& image_mode);
+        # /** \brief Continously asks for data from the device and publishes it if available. */
+        # void processGrabbing ();
+        # boost::signals2::signal<sig_cb_fotonic_point_cloud>* point_cloud_signal_;
+        # //boost::signals2::signal<sig_cb_fotonic_point_cloud_i>* point_cloud_i_signal_;
+        # boost::signals2::signal<sig_cb_fotonic_point_cloud_rgb>* point_cloud_rgb_signal_;
+        # boost::signals2::signal<sig_cb_fotonic_point_cloud_rgba>* point_cloud_rgba_signal_;
+        # 
+        # protected:
+        # bool running_;
+        # FZ_Device_Handle_t * fotonic_device_handle_;
+        # boost::thread grabber_thread_;
+        # 
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+
+###
+
+# hdl_grabber.h
+# #define HDL_Grabber_toRadians(x) ((x) * M_PI / 180.0)
+# 
+# hdl_grabber.h
+# namespace pcl
+# /** \brief Grabber for the Velodyne High-Definition-Laser (HDL)
+#  * \author Keven Ring <keven@mitre.org>
+#  * \ingroup io
+#  */
+# class PCL_EXPORTS HDLGrabber : public Grabber
+# cdef extern from "pcl/io/hdl_grabber.h" namespace "pcl":
+#     cdef cppclass HDLGrabber(Grabber):
+#         HDLGrabber()
+        # public:
+        # /** \brief Signal used for a single sector
+        #  *         Represents 1 corrected packet from the HDL Velodyne
+        #  */
+        # typedef void (sig_cb_velodyne_hdl_scan_point_cloud_xyz) (
+        #     const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&,
+        #     float, float);
+        # /** \brief Signal used for a single sector
+        #  *         Represents 1 corrected packet from the HDL Velodyne.  Each laser has a different RGB
+        #  */
+        # typedef void (sig_cb_velodyne_hdl_scan_point_cloud_xyzrgb) (
+        #     const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&,
+        #     float, float);
+        # /** \brief Signal used for a single sector
+        #  *         Represents 1 corrected packet from the HDL Velodyne with the returned intensity.
+        #  */
+        # typedef void (sig_cb_velodyne_hdl_scan_point_cloud_xyzi) (
+        #     const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&,
+        #     float startAngle, float);
+        # /** \brief Signal used for a 360 degree sweep
+        #  *         Represents multiple corrected packets from the HDL Velodyne
+        #  *         This signal is sent when the Velodyne passes angle "0"
+        #  */
+        # typedef void (sig_cb_velodyne_hdl_sweep_point_cloud_xyz) (
+        #     const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # /** \brief Signal used for a 360 degree sweep
+        #  *         Represents multiple corrected packets from the HDL Velodyne with the returned intensity
+        #  *         This signal is sent when the Velodyne passes angle "0"
+        #  */
+        # typedef void (sig_cb_velodyne_hdl_sweep_point_cloud_xyzi) (
+        #     const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # /** \brief Signal used for a 360 degree sweep
+        #  *         Represents multiple corrected packets from the HDL Velodyne
+        #  *         This signal is sent when the Velodyne passes angle "0".  Each laser has a different RGB
+        #  */
+        # typedef void (sig_cb_velodyne_hdl_sweep_point_cloud_xyzrgb) (
+        #     const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # 
+        # /** \brief Constructor taking an optional path to an HDL corrections file.  The Grabber will listen on the default IP/port for data packets [192.168.3.255/2368]
+        #  * \param[in] correctionsFile Path to a file which contains the correction parameters for the HDL.  This parameter is mandatory for the HDL-64, optional for the HDL-32
+        #  * \param[in] pcapFile Path to a file which contains previously captured data packets.  This parameter is optional
+        #  */
+        # HDLGrabber (const std::string& correctionsFile = "", const std::string& pcapFile = "");
+        # 
+        # /** \brief Constructor taking a pecified IP/port and an optional path to an HDL corrections file.
+        #  * \param[in] ipAddress IP Address that should be used to listen for HDL packets
+        #  * \param[in] port UDP Port that should be used to listen for HDL packets
+        #  * \param[in] correctionsFile Path to a file which contains the correction parameters for the HDL.  This field is mandatory for the HDL-64, optional for the HDL-32
+        #  */
+        # HDLGrabber (const boost::asio::ip::address& ipAddress, const unsigned short port, const std::string& correctionsFile = "");
+        # 
+        # /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
+        # virtual ~HDLGrabber () throw ();
+        # 
+        # /** \brief Starts processing the Velodyne packets, either from the network or PCAP file. */
+        # virtual void start ();
+        # 
+        # /** \brief Stops processing the Velodyne packets, either from the network or PCAP file */
+        # virtual void stop ();
+        # 
+        # /** \brief Obtains the name of this I/O Grabber
+        #  *  \return The name of the grabber
+        #  */
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Check if the grabber is still running.
+        #  *  \return TRUE if the grabber is running, FALSE otherwise
+        #  */
+        # virtual bool isRunning () const;
+        # 
+        # /** \brief Returns the number of frames per second.
+        #  */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Allows one to filter packets based on the SOURCE IP address and PORT
+        #  *         This can be used, for instance, if multiple HDL LIDARs are on the same network
+        #  */
+        # void filterPackets (const boost::asio::ip::address& ipAddress, const unsigned short port = 443);
+        # 
+        # /** \brief Allows one to customize the colors used for each of the lasers.
+        #  */
+        # void setLaserColorRGB (const pcl::RGB& color, unsigned int laserNumber);
+        # 
+        # /** \brief Any returns from the HDL with a distance less than this are discarded.
+        #  *         This value is in meters
+        #  *         Default: 0.0
+        #  */
+        # void setMinimumDistanceThreshold(float & minThreshold);
+        # 
+        # /** \brief Any returns from the HDL with a distance greater than this are discarded.
+        #  *         This value is in meters
+        #  *         Default: 10000.0
+        #  */
+        # void setMaximumDistanceThreshold(float & maxThreshold);
+        # 
+        # /** \brief Returns the current minimum distance threshold, in meters
+        #  */
+        # float getMinimumDistanceThreshold();
+        # 
+        # /** \brief Returns the current maximum distance threshold, in meters
+        #  */
+        # float getMaximumDistanceThreshold();
+        # 
+        # protected:
+        # static const int HDL_DATA_PORT = 2368;
+        # static const int HDL_NUM_ROT_ANGLES = 36001;
+        # static const int HDL_LASER_PER_FIRING = 32;
+        # static const int HDL_MAX_NUM_LASERS = 64;
+        # static const int HDL_FIRING_PER_PKT = 12;
+        # static const boost::asio::ip::address HDL_DEFAULT_NETWORK_ADDRESS;
+        # 
+        # enum HDLBlock
+        # {
+        #   BLOCK_0_TO_31 = 0xeeff, BLOCK_32_TO_63 = 0xddff
+        # };
+        # 
+        # #pragma pack(push, 1)
+        # typedef struct HDLLaserReturn
+        # {
+        #     unsigned short distance;
+        #     unsigned char intensity;
+        # } HDLLaserReturn;
+        # #pragma pack(pop)
+        # 
+        # struct HDLFiringData
+        # {
+        #     unsigned short blockIdentifier;
+        #     unsigned short rotationalPosition;
+        #     HDLLaserReturn laserReturns[HDL_LASER_PER_FIRING];
+        # };
+        # 
+        # struct HDLDataPacket
+        # {
+        #     HDLFiringData firingData[HDL_FIRING_PER_PKT];
+        #     unsigned int gpsTimestamp;
+        #     unsigned char blank1;
+        #     unsigned char blank2;
+        # };
+        # 
+        # struct HDLLaserCorrection
+        # {
+        #     double azimuthCorrection;
+        #     double verticalCorrection;
+        #     double distanceCorrection;
+        #     double verticalOffsetCorrection;
+        #     double horizontalOffsetCorrection;
+        #     double sinVertCorrection;
+        #     double cosVertCorrection;
+        #     double sinVertOffsetCorrection;
+        #     double cosVertOffsetCorrection;
+        # };
+        # 
+
+
+###
+
+# image_grabber.h
+# namespace pcl
+# /** \brief Base class for Image file grabber.
+#  * \ingroup io
+#  */
+# class PCL_EXPORTS ImageGrabberBase : public Grabber
+# cdef extern from "pcl/io/image_grabber.h" namespace "pcl":
+#     cdef cppclass ImageGrabberBase(Grabber):
+#         ImageGrabberBase()
+        # public:
+        # /** \brief Constructor taking a folder of depth+[rgb] images.
+        # * \param[in] directory Directory which contains an ordered set of images corresponding to an [RGB]D video, stored as TIFF, PNG, JPG, or PPM files. The naming convention is: frame_[timestamp]_["depth"/"rgb"].[extension]
+        # * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        # * \param[in] repeat whether to play PCD file in an endless loop or not.
+        # * \param pclzf_mode
+        # */
+        # ImageGrabberBase (const std::string& directory, float frames_per_second, bool repeat, bool pclzf_mode);
+        # 
+        # ImageGrabberBase (const std::string& depth_directory, const std::string& rgb_directory, float frames_per_second, bool repeat);
+        # /** \brief Constructor taking a list of paths to PCD files, that are played in the order they appear in the list.
+        # * \param[in] depth_image_files Path to the depth image files files.
+        # * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        # * \param[in] repeat whether to play PCD file in an endless loop or not.
+        # */
+        # ImageGrabberBase (const std::vector<std::string>& depth_image_files, float frames_per_second, bool repeat);
+        # 
+        # /** \brief Copy constructor.
+        # * \param[in] src the Image Grabber base object to copy into this
+        # */
+        # ImageGrabberBase (const ImageGrabberBase &src) : Grabber (), impl_ ()
+        # 
+        # /** \brief Copy operator.
+        #  * \param[in] src the Image Grabber base object to copy into this
+        #  */
+        # ImageGrabberBase& operator = (const ImageGrabberBase &src)
+        # 
+        # /** \brief Virtual destructor. */
+        # virtual ~ImageGrabberBase () throw ();
+        # 
+        # /** \brief Starts playing the list of PCD files if frames_per_second is > 0. Otherwise it works as a trigger: publishes only the next PCD file in the list. */
+        # virtual void start ();
+        # 
+        # /** \brief Stops playing the list of PCD files if frames_per_second is > 0. Otherwise the method has no effect. */
+        # virtual void  stop ();
+        # 
+        # /** \brief Triggers a callback with new data */
+        # virtual void trigger ();
+        # 
+        # /** \brief whether the grabber is started (publishing) or not.
+        #  * \return true only if publishing.
+        #  */
+        # virtual bool isRunning () const;
+        # 
+        # /** \return The name of the grabber */
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Rewinds to the first PCD file in the list.*/
+        # virtual void rewind ();
+        # 
+        # /** \brief Returns the frames_per_second. 0 if grabber is trigger-based */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Returns whether the repeat flag is on */
+        # bool isRepeatOn () const;
+        # 
+        # /** \brief Returns if the last frame is reached */
+        # bool atLastFrame () const;
+        # 
+        # /** \brief Returns the filename of the current indexed file */
+        # std::string getCurrentDepthFileName () const;
+        # 
+        # /** \brief Returns the filename of the previous indexed file 
+        #  *  SDM: adding this back in, but is this useful, or confusing? */
+        # std::string getPrevDepthFileName () const;
+        # 
+        # /** \brief Get the depth filename at a particular index */
+        # std::string getDepthFileNameAtIndex (size_t idx) const;
+        # 
+        # /** \brief Query only the timestamp of an index, if it exists */
+        # bool getTimestampAtIndex (size_t idx, pcl::uint64_t &timestamp) const;
+        # 
+        # /** \brief Manually set RGB image files.
+        # * \param[in] rgb_image_files A vector of [tiff/png/jpg/ppm] files to use as input. There must be a 1-to-1 correspondence between these and the depth images you set
+        # */
+        # void setRGBImageFiles (const std::vector<std::string>& rgb_image_files);
+        # 
+        # /** \brief Define custom focal length and center pixel. This will override ANY other setting of parameters for the duration of the grabber's life, whether by factory defaults or explicitly read from a frame_[timestamp].xml file. 
+        # *  \param[in] focal_length_x Horizontal focal length (fx)
+        # *  \param[in] focal_length_y Vertical focal length (fy)
+        # *  \param[in] principal_point_x Horizontal coordinates of the principal point (cx)
+        # *  \param[in] principal_point_y Vertical coordinates of the principal point (cy)
+        # */
+        # virtual void
+        # setCameraIntrinsics (const double focal_length_x, 
+        #                    const double focal_length_y, 
+        #                    const double principal_point_x, 
+        #                    const double principal_point_y);
+        # 
+        # /** \brief Get the current focal length and center pixel. If the intrinsics have been manually set with setCameraIntrinsics, this will return those values. Else, if start () has been called and the grabber has found a frame_[timestamp].xml file, this will return the most recent values read. Else, returns factory defaults.
+        #  *  \param[out] focal_length_x Horizontal focal length (fx)
+        #  *  \param[out] focal_length_y Vertical focal length (fy)
+        #  *  \param[out] principal_point_x Horizontal coordinates of the principal point (cx)
+        #  *  \param[out] principal_point_y Vertical coordinates of the principal point (cy)
+        #  */
+        # virtual void
+        # getCameraIntrinsics (double &focal_length_x, 
+        #                    double &focal_length_y, 
+        #                    double &principal_point_x, 
+        #                    double &principal_point_y) const;
+        # 
+        # /** \brief Define the units the depth data is stored in.
+        # *  Defaults to mm (0.001), meaning a brightness of 1000 corresponds to 1 m*/
+        # void setDepthImageUnits (float units);
+        # 
+        # /** \brief Set the number of threads, if we wish to use OpenMP for quicker cloud population.
+        # *  Note that for a standard (< 4 core) machine this is unlikely to yield a drastic speedup.*/
+        # void setNumberOfThreads (unsigned int nr_threads = 0);
+        # 
+        # protected:
+        # /** \brief Convenience function to see how many frames this consists of
+        # */
+        # size_t numFrames () const;
+        # 
+        # /** \brief Gets the cloud in ROS form at location idx */
+        # bool getCloudAt (size_t idx, pcl::PCLPointCloud2 &blob, Eigen::Vector4f &origin, Eigen::Quaternionf &orientation) const;
+
+
+###
+
+# template <typename T> class PointCloud;
+# image_grabber.h
+# namespace pcl
+# template <typename PointT> class ImageGrabber : public ImageGrabberBase, public FileGrabber<PointT>
+# cdef extern from "pcl/io/image_grabber.h" namespace "pcl":
+#     cdef cppclass ImageGrabber(ImageGrabberBase, FileGrabber[T]):
+#         ImageGrabber()
+        # public:
+        # ImageGrabber (const std::string& dir, 
+        #             float frames_per_second = 0, 
+        #             bool repeat = false, 
+        #             bool pclzf_mode = false);
+        # 
+        # ImageGrabber (const std::string& depth_dir, 
+        #             const std::string& rgb_dir, 
+        #             float frames_per_second = 0, 
+        #             bool repeat = false);
+        # 
+        # ImageGrabber (const std::vector<std::string>& depth_image_files, 
+        #             float frames_per_second = 0, 
+        #             bool repeat = false);
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~ImageGrabber () throw () {}
+        # 
+        # // Inherited from FileGrabber
+        # const boost::shared_ptr< const pcl::PointCloud<PointT> > operator[] (size_t idx) const;
+        # 
+        # // Inherited from FileGrabber
+        # size_t size () const;
+        # 
+        # protected:
+        # virtual void publish (const pcl::PCLPointCloud2& blob,
+        #        const Eigen::Vector4f& origin, 
+        #        const Eigen::Quaternionf& orientation) const;
+        # boost::signals2::signal<void (const boost::shared_ptr<const pcl::PointCloud<PointT> >&)>* signal_;
+
+
+###
+
+# image_grabber.h
+# namespace pcl
+# template<typename PointT>
+# ImageGrabber<PointT>::ImageGrabber (const std::string& dir, 
+#                                     float frames_per_second, 
+#                                     bool repeat, 
+#                                     bool pclzf_mode)
+#   : ImageGrabberBase (dir, frames_per_second, repeat, pclzf_mode)
+###
+
+# image_grabber.h
+# namespace pcl
+# template<typename PointT>
+# ImageGrabber<PointT>::ImageGrabber (const std::string& depth_dir, 
+#                                     const std::string& rgb_dir, 
+#                                     float frames_per_second, 
+#                                     bool repeat)
+#   : ImageGrabberBase (depth_dir, rgb_dir, frames_per_second, repeat)
+###
+
+# image_grabber.h
+# namespace pcl
+# template<typename PointT>
+# ImageGrabber<PointT>::ImageGrabber (const std::vector<std::string>& depth_image_files, 
+#                                     float frames_per_second, 
+#                                     bool repeat)
+#   : ImageGrabberBase (depth_image_files, frames_per_second, repeat), signal_ ()
+###
+
+# image_grabber.h
+# namespace pcl
+# template<typename PointT> const boost::shared_ptr< const pcl::PointCloud<PointT> >
+# ImageGrabber<PointT>::operator[] (size_t idx) const
+#     pcl::PCLPointCloud2 blob;
+#     Eigen::Vector4f origin;
+#     Eigen::Quaternionf orientation;
+#     getCloudAt (idx, blob, origin, orientation);
+#     typename pcl::PointCloud<PointT>::Ptr cloud (new pcl::PointCloud<PointT> ());
+#     pcl::fromPCLPointCloud2 (blob, *cloud);
+#     cloud->sensor_origin_ = origin;
+#     cloud->sensor_orientation_ = orientation;
+#     return (cloud);
+###
+ 
+# image_grabber.h
+# namespace pcl
+# template <typename PointT> size_t ImageGrabber<PointT>::size () const
+###
+
+# image_grabber.h
+# namespace pcl
+# template<typename PointT> void
+# ImageGrabber<PointT>::publish (const pcl::PCLPointCloud2& blob, const Eigen::Vector4f& origin, const Eigen::Quaternionf& orientation) const
+###
+
+# openni2_grabber.h
+# namespace pcl
+# 
+# struct PointXYZ;
+# struct PointXYZRGB;
+# struct PointXYZRGBA;
+# struct PointXYZI;
+# template <typename T> class PointCloud;
+#
+# openni2_grabber.h
+# namespace pcl
+# namespace io
+# /** \brief Grabber for OpenNI 2 devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS OpenNI2Grabber : public Grabber
+# cdef extern from "pcl/io/openni2_grabber.h" namespace "pcl::io":
+#     cdef cppclass OpenNI2Grabber(Grabber):
+#         OpenNI2Grabber()
+        # public:
+        # typedef boost::shared_ptr<OpenNI2Grabber> Ptr;
+        # typedef boost::shared_ptr<const OpenNI2Grabber> ConstPtr;
+        # 
+        # // Templated images
+        # typedef pcl::io::DepthImage DepthImage;
+        # typedef pcl::io::IRImage IRImage;
+        # typedef pcl::io::Image Image;
+        # 
+        # /** \brief Basic camera parameters placeholder. */
+        # struct CameraParameters
+        #     /** fx */
+        #     double focal_length_x;
+        #     /** fy */
+        #     double focal_length_y;
+        #     /** cx */
+        #     double principal_point_x;
+        #     /** cy */
+        #     double principal_point_y;
+        #   
+        #     CameraParameters (double initValue)
+        #       : focal_length_x (initValue), focal_length_y (initValue),
+        #       principal_point_x (initValue),  principal_point_y (initValue)
+        #     {}
+        #   
+        #     CameraParameters (double fx, double fy, double cx, double cy)
+        #       : focal_length_x (fx), focal_length_y (fy), principal_point_x (cx), principal_point_y (cy)
+        #     { }
+        ###
+        # 
+        # typedef enum
+        # {
+        #     OpenNI_Default_Mode = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+        #     OpenNI_SXGA_15Hz = 1,    // Only supported by the Kinect
+        #     OpenNI_VGA_30Hz = 2,     // Supported by PSDK, Xtion and Kinect
+        #     OpenNI_VGA_25Hz = 3,     // Supportged by PSDK and Xtion
+        #     OpenNI_QVGA_25Hz = 4,    // Supported by PSDK and Xtion
+        #     OpenNI_QVGA_30Hz = 5,    // Supported by PSDK, Xtion and Kinect
+        #     OpenNI_QVGA_60Hz = 6,    // Supported by PSDK and Xtion
+        #     OpenNI_QQVGA_25Hz = 7,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+        #     OpenNI_QQVGA_30Hz = 8,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+        #     OpenNI_QQVGA_60Hz = 9    // Not supported -> using software downsampling (only for integer scale factor and only NN)
+        # } Mode;
+        # 
+        # //define callback signature typedefs
+        # typedef void (sig_cb_openni_image) (const boost::shared_ptr<Image>&);
+        # typedef void (sig_cb_openni_depth_image) (const boost::shared_ptr<DepthImage>&);
+        # typedef void (sig_cb_openni_ir_image) (const boost::shared_ptr<IRImage>&);
+        # typedef void (sig_cb_openni_image_depth_image) (const boost::shared_ptr<Image>&, const boost::shared_ptr<DepthImage>&, float reciprocalFocalLength) ;
+        # typedef void (sig_cb_openni_ir_depth_image) (const boost::shared_ptr<IRImage>&, const boost::shared_ptr<DepthImage>&, float reciprocalFocalLength) ;
+        # typedef void (sig_cb_openni_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_openni_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # public:
+        # /** \brief Constructor
+        #   * \param[in] device_id ID of the device, which might be a serial number, bus@address or the index of the device.
+        #   * \param[in] depth_mode the mode of the depth stream
+        #   * \param[in] image_mode the mode of the image stream
+        # */
+        # OpenNI2Grabber (const std::string& device_id = "",
+        #   const Mode& depth_mode = OpenNI_Default_Mode,
+        #     const Mode& image_mode = OpenNI_Default_Mode);
+        # 
+        # /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
+        # virtual ~OpenNI2Grabber () throw ();
+        # 
+        # /** \brief Start the data acquisition. */
+        # virtual void start ();
+        # 
+        # /** \brief Stop the data acquisition. */
+        # virtual void stop ();
+        # 
+        # /** \brief Check if the data acquisition is still running. */
+        # virtual bool isRunning () const;
+        # 
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Obtain the number of frames per second (FPS). */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Get a boost shared pointer to the \ref OpenNIDevice object. */
+        # inline boost::shared_ptr<pcl::io::openni2::OpenNI2Device> getDevice () const;
+        # 
+        # /** \brief Obtain a list of the available depth modes that this device supports. */
+        # std::vector<std::pair<int, pcl::io::openni2::OpenNI2VideoMode> > getAvailableDepthModes () const;
+        # 
+        # /** \brief Obtain a list of the available image modes that this device supports. */
+        # std::vector<std::pair<int, pcl::io::openni2::OpenNI2VideoMode> > getAvailableImageModes () const;
+        # 
+        # /** \brief Set the RGB camera parameters (fx, fy, cx, cy)
+        #   * \param[in] rgb_focal_length_x the RGB focal length (fx)
+        #   * \param[in] rgb_focal_length_y the RGB focal length (fy)
+        #   * \param[in] rgb_principal_point_x the RGB principal point (cx)
+        #   * \param[in] rgb_principal_point_y the RGB principal point (cy)
+        #   * Setting the parameters to non-finite values (e.g., NaN, Inf) invalidates them
+        #   * and the grabber will use the default values from the camera instead.
+        # */
+        # inline void
+        # setRGBCameraIntrinsics (const double rgb_focal_length_x,
+        #     const double rgb_focal_length_y,
+        #     const double rgb_principal_point_x,
+        #     const double rgb_principal_point_y)
+        # 
+        # /** \brief Get the RGB camera parameters (fx, fy, cx, cy)
+        #   * \param[out] rgb_focal_length_x the RGB focal length (fx)
+        #   * \param[out] rgb_focal_length_y the RGB focal length (fy)
+        #   * \param[out] rgb_principal_point_x the RGB principal point (cx)
+        #   * \param[out] rgb_principal_point_y the RGB principal point (cy)
+        #   */
+        # inline void
+        # getRGBCameraIntrinsics (double &rgb_focal_length_x,
+        #     double &rgb_focal_length_y,
+        #     double &rgb_principal_point_x,
+        #     double &rgb_principal_point_y) const
+        # 
+        # /** \brief Set the RGB image focal length (fx = fy).
+        #   * \param[in] rgb_focal_length the RGB focal length (assumes fx = fy)
+        #   * Setting the parameter to a non-finite value (e.g., NaN, Inf) invalidates it
+        #   * and the grabber will use the default values from the camera instead.
+        #   * These parameters will be used for XYZRGBA clouds.
+        #   */
+        # inline void
+        # setRGBFocalLength (const double rgb_focal_length)
+        # 
+        # /** \brief Set the RGB image focal length
+        #   * \param[in] rgb_focal_length_x the RGB focal length (fx)
+        #   * \param[in] rgb_focal_ulength_y the RGB focal length (fy)
+        #   * Setting the parameters to non-finite values (e.g., NaN, Inf) invalidates them
+        #   * and the grabber will use the default values from the camera instead.
+        #   * These parameters will be used for XYZRGBA clouds.
+        #   */
+        # inline void
+        # setRGBFocalLength (const double rgb_focal_length_x, const double rgb_focal_length_y)
+        # 
+        # /** \brief Return the RGB focal length parameters (fx, fy)
+        #   * \param[out] rgb_focal_length_x the RGB focal length (fx)
+        #   * \param[out] rgb_focal_length_y the RGB focal length (fy)
+        #   */
+        # inline void
+        # getRGBFocalLength (double &rgb_focal_length_x, double &rgb_focal_length_y) const
+        # 
+        # /** \brief Set the Depth camera parameters (fx, fy, cx, cy)
+        #   * \param[in] depth_focal_length_x the Depth focal length (fx)
+        #   * \param[in] depth_focal_length_y the Depth focal length (fy)
+        #   * \param[in] depth_principal_point_x the Depth principal point (cx)
+        #   * \param[in] depth_principal_point_y the Depth principal point (cy)
+        #   * Setting the parameters to non-finite values (e.g., NaN, Inf) invalidates them
+        #   * and the grabber will use the default values from the camera instead.
+        #   */
+        # inline void
+        # setDepthCameraIntrinsics (const double depth_focal_length_x,
+        #     const double depth_focal_length_y,
+        #     const double depth_principal_point_x,
+        #     const double depth_principal_point_y)
+        # 
+        # /** \brief Get the Depth camera parameters (fx, fy, cx, cy)
+        #   * \param[out] depth_focal_length_x the Depth focal length (fx)
+        #   * \param[out] depth_focal_length_y the Depth focal length (fy)
+        #   * \param[out] depth_principal_point_x the Depth principal point (cx)
+        #   * \param[out] depth_principal_point_y the Depth principal point (cy)
+        #   */
+        # inline void
+        # getDepthCameraIntrinsics (double &depth_focal_length_x,
+        #     double &depth_focal_length_y,
+        #     double &depth_principal_point_x,
+        #     double &depth_principal_point_y) const
+        # 
+        # /** \brief Set the Depth image focal length (fx = fy).
+        #   * \param[in] depth_focal_length the Depth focal length (assumes fx = fy)
+        #   * Setting the parameter to a non-finite value (e.g., NaN, Inf) invalidates it
+        #   * and the grabber will use the default values from the camera instead.
+        #   */
+        # inline void
+        # setDepthFocalLength (const double depth_focal_length)
+        # 
+        # /** \brief Set the Depth image focal length
+        #   * \param[in] depth_focal_length_x the Depth focal length (fx)
+        #   * \param[in] depth_focal_length_y the Depth focal length (fy)
+        #   * Setting the parameter to non-finite values (e.g., NaN, Inf) invalidates them
+        #   * and the grabber will use the default values from the camera instead.
+        #   */
+        # inline void
+        # setDepthFocalLength (const double depth_focal_length_x, const double depth_focal_length_y)
+        # 
+        # /** \brief Return the Depth focal length parameters (fx, fy)
+        #   * \param[out] depth_focal_length_x the Depth focal length (fx)
+        #   * \param[out] depth_focal_length_y the Depth focal length (fy)
+        #   */
+        # inline void
+        # getDepthFocalLength (double &depth_focal_length_x, double &depth_focal_length_y) const
+        # 
+        # protected:
+        # /** \brief Sets up an OpenNI device. */
+        # void setupDevice (const std::string& device_id, const Mode& depth_mode, const Mode& image_mode);
+        # 
+        # /** \brief Update mode maps. */
+        # void updateModeMaps ();
+        # 
+        # /** \brief Start synchronization. */
+        # void startSynchronization ();
+        # 
+        # /** \brief Stop synchronization. */
+        # void stopSynchronization ();
+        # 
+        # // TODO: rename to mapMode2OniMode
+        # /** \brief Map config modes. */
+        # bool mapMode2XnMode (int mode, pcl::io::openni2::OpenNI2VideoMode& videoMode) const;
+        # 
+        # // callback methods
+        # /** \brief RGB image callback. */
+        # virtual void imageCallback (pcl::io::openni2::Image::Ptr image, void* cookie);
+        # 
+        # /** \brief Depth image callback. */
+        # virtual void depthCallback (pcl::io::openni2::DepthImage::Ptr depth_image, void* cookie);
+        # 
+        # /** \brief IR image callback. */
+        # virtual void irCallback (pcl::io::openni2::IRImage::Ptr ir_image, void* cookie);
+        # 
+        # /** \brief RGB + Depth image callback. */
+        # virtual void imageDepthImageCallback (const pcl::io::openni2::Image::Ptr &image, const pcl::io::openni2::DepthImage::Ptr &depth_image);
+        # 
+        # /** \brief IR + Depth image callback. */
+        # virtual void irDepthImageCallback (const pcl::io::openni2::IRImage::Ptr &image, const pcl::io::openni2::DepthImage::Ptr &depth_image);
+        # 
+        # /** \brief Process changed signals. */
+        # virtual void signalsChanged ();
+        # 
+        # // helper methods
+        # /** \brief Check if the RGB and Depth images are required to be synchronized or not. */
+        # virtual void checkImageAndDepthSynchronizationRequired ();
+        # 
+        # /** \brief Check if the RGB image stream is required or not. */
+        # virtual void checkImageStreamRequired ();
+        # 
+        # /** \brief Check if the depth stream is required or not. */
+        # virtual void checkDepthStreamRequired ();
+        # 
+        # /** \brief Check if the IR image stream is required or not. */
+        # virtual void checkIRStreamRequired ();
+        # 
+        # // Point cloud conversion ///////////////////////////////////////////////
+        # 
+        # /** \brief Convert a Depth image to a pcl::PointCloud<pcl::PointXYZ>
+        #   * \param[in] depth the depth image to convert
+        #   */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZ> >
+        # convertToXYZPointCloud (const pcl::io::openni2::DepthImage::Ptr &depth);
+        # 
+        # /** \brief Convert a Depth + RGB image pair to a pcl::PointCloud<PointT>
+        #   * \param[in] image the RGB image to convert
+        #   * \param[in] depth_image the depth image to convert
+        #   */
+        # template <typename PointT> typename pcl::PointCloud<PointT>::Ptr
+        # convertToXYZRGBPointCloud (const pcl::io::openni2::Image::Ptr &image, const pcl::io::openni2::DepthImage::Ptr &depth_image);
+        # 
+        # /** \brief Convert a Depth + Intensity image pair to a pcl::PointCloud<pcl::PointXYZI>
+        #   * \param[in] image the IR image to convert
+        #   * \param[in] depth_image the depth image to convert
+        #   */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZI> >
+        # convertToXYZIPointCloud (const pcl::io::openni2::IRImage::Ptr &image, const pcl::io::openni2::DepthImage::Ptr &depth_image);
+        # 
+        # std::vector<uint8_t> color_resize_buffer_;
+        # std::vector<uint16_t> depth_resize_buffer_;
+        # std::vector<uint16_t> ir_resize_buffer_;
+        # 
+        # // Stream callbacks /////////////////////////////////////////////////////
+        # void processColorFrame (openni::VideoStream& stream);
+        # void processDepthFrame (openni::VideoStream& stream);
+        # void processIRFrame (openni::VideoStream& stream);
+        # 
+        # Synchronizer<pcl::io::openni2::Image::Ptr, pcl::io::openni2::DepthImage::Ptr > rgb_sync_;
+        # Synchronizer<pcl::io::openni2::IRImage::Ptr, pcl::io::openni2::DepthImage::Ptr > ir_sync_;
+        # 
+        # /** \brief The actual openni device. */
+        # boost::shared_ptr<pcl::io::openni2::OpenNI2Device> device_;
+        # 
+        # std::string rgb_frame_id_;
+        # std::string depth_frame_id_;
+        # unsigned image_width_;
+        # unsigned image_height_;
+        # unsigned depth_width_;
+        # unsigned depth_height_;
+        # 
+        # bool image_required_;
+        # bool depth_required_;
+        # bool ir_required_;
+        # bool sync_required_;
+        # 
+        # boost::signals2::signal<sig_cb_openni_image>* image_signal_;
+        # boost::signals2::signal<sig_cb_openni_depth_image>* depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_image>* ir_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_image_depth_image>* image_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_depth_image>* ir_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud>* point_cloud_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_i>* point_cloud_i_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgb>* point_cloud_rgb_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgba>* point_cloud_rgba_signal_;
+        # 
+        # struct modeComp
+        # {
+        #     bool operator () (const openni::VideoMode& mode1, const openni::VideoMode & mode2) const
+        # };
+        # 
+        # // Mapping from config (enum) modes to native OpenNI modes
+        # std::map<int, pcl::io::openni2::OpenNI2VideoMode> config2oni_map_;
+        # 
+        # pcl::io::openni2::OpenNI2Device::CallbackHandle depth_callback_handle_;
+        # pcl::io::openni2::OpenNI2Device::CallbackHandle image_callback_handle_;
+        # pcl::io::openni2::OpenNI2Device::CallbackHandle ir_callback_handle_;
+        # bool running_;
+        # 
+        # CameraParameters rgb_parameters_;
+        # CameraParameters depth_parameters_;
+        # 
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+ 
+# boost::shared_ptr<pcl::io::openni2::OpenNI2Device>
+# OpenNI2Grabber::getDevice () const
+
+
+###
+
+# pxc_grabber.h
+# namespace pcl
+# 
+# struct PointXYZ;
+# struct PointXYZRGB;
+# struct PointXYZRGBA;
+# struct PointXYZI;
+# template <typename T> class PointCloud;
+# 
+# pxc_grabber.h
+# namespace pcl
+# /** \brief Grabber for PXC devices
+#   * \author Stefan Holzer <holzers@in.tum.de>
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS PXCGrabber : public Grabber
+# cdef extern from "pcl/io/pxc_grabber.h" namespace "pcl":
+#     cdef cppclass PXCGrabber(Grabber):
+#         PXCGrabber()
+        # public:
+        # 
+        # /** \brief Supported modes for grabbing from a PXC device. */
+        # typedef enum
+        # {
+        #   PXC_Default_Mode = 0, 
+        # } Mode;
+        # 
+        # //define callback signature typedefs
+        # typedef void (sig_cb_pxc_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_pxc_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_pxc_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_pxc_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # public:
+        # /** \brief Constructor */
+        # PXCGrabber ();
+        # 
+        # /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
+        # virtual ~PXCGrabber () throw ();
+        # 
+        # /** \brief Start the data acquisition. */
+        # virtual void start ();
+        # 
+        # /** \brief Stop the data acquisition. */
+        # virtual void stop ();
+        # 
+        # /** \brief Check if the data acquisition is still running. */
+        # virtual bool isRunning () const;
+        # 
+        # /** \brief Returns the name of the grabber. */
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Obtain the number of frames per second (FPS). */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # protected:
+        # /** \brief Initializes the PXC grabber and the grabbing pipeline. */
+        # bool init ();
+        # 
+        # /** \brief Closes the grabbing pipeline. */
+        # void close ();
+        # 
+        # /** \brief Continously asks for data from the device and publishes it if available. */
+        # void processGrabbing ();
+        # 
+        # // signals to indicate whether new clouds are available
+        # boost::signals2::signal<sig_cb_pxc_point_cloud>* point_cloud_signal_;
+        # //boost::signals2::signal<sig_cb_fotonic_point_cloud_i>* point_cloud_i_signal_;
+        # boost::signals2::signal<sig_cb_pxc_point_cloud_rgb>* point_cloud_rgb_signal_;
+        # boost::signals2::signal<sig_cb_pxc_point_cloud_rgba>* point_cloud_rgba_signal_;
+        # 
+        # protected:
+        # // utiliy object for accessing PXC camera
+        # UtilPipeline pp_;
+        # // indicates whether grabbing is running
+        # bool running_;
+        # 
+        # // FPS computation
+        # mutable float fps_;
+        # mutable boost::mutex fps_mutex_;
+        # 
+        # // thread where the grabbing takes place
+        # boost::thread grabber_thread_;
+        # 
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+
+###
+
+
+# robot_eye_grabber.h
+# namespace pcl
+# /** \brief Grabber for the Ocular Robotics RobotEye sensor.
+#  * \ingroup io
+#  */
+# class PCL_EXPORTS RobotEyeGrabber : public Grabber
+# cdef extern from "pcl/io/robot_eye_grabber.h" namespace "pcl":
+#     cdef cppclass RobotEyeGrabber(Grabber):
+#         RobotEyeGrabber()
+        # public:
+        # 
+        # /** \brief Signal used for the point cloud callback.
+        #  * This signal is sent when the accumulated number of points reaches
+        #  * the limit specified by setSignalPointCloudSize().
+        #  */
+        # typedef void (sig_cb_robot_eye_point_cloud_xyzi) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # /** \brief RobotEyeGrabber default constructor. */
+        # RobotEyeGrabber ();
+        # 
+        # /** \brief RobotEyeGrabber constructor taking a specified IP address and data port. */
+        # RobotEyeGrabber (const boost::asio::ip::address& ipAddress, unsigned short port=443);
+        # 
+        # /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
+        # virtual ~RobotEyeGrabber () throw ();
+        # 
+        # /** \brief Starts the RobotEye grabber.
+        #  * The grabber runs on a separate thread, this call will return without blocking. */
+        # virtual void start ();
+        # 
+        # /** \brief Stops the RobotEye grabber. */
+        # virtual void stop ();
+        # 
+        # /** \brief Obtains the name of this I/O Grabber
+        #  *  \return The name of the grabber
+        #  */
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Check if the grabber is still running.
+        #  *  \return TRUE if the grabber is running, FALSE otherwise
+        #  */
+        # virtual bool isRunning () const;
+        # 
+        # /** \brief Returns the number of frames per second.
+        #  */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Set/get ip address of the sensor that sends the data.
+        #  * The default is address_v4::any ().
+        #  */
+        # void setSensorAddress (const boost::asio::ip::address& ipAddress);
+        # const boost::asio::ip::address& getSensorAddress () const;
+        # 
+        # /** \brief Set/get the port number which receives data from the sensor.
+        #  * The default is 443.
+        #  */
+        # void setDataPort (unsigned short port);
+        # unsigned short getDataPort () const;
+        # 
+        # /** \brief Set/get the number of points to accumulate before the grabber
+        #  * callback is signaled.  The default is 1000.
+        #  */
+        # void setSignalPointCloudSize (std::size_t numerOfPoints);
+        # std::size_t getSignalPointCloudSize () const;
+        # 
+        # /** \brief Returns the point cloud with point accumulated by the grabber.
+        #  * It is not safe to access this point cloud except if the grabber is
+        #  * stopped or during the grabber callback.
+        #  */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZI> > getPointCloud() const;
+
+
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#     cdef cppclass OpenNIGrabber(Grabber):
+#         # public:
+#         # typedef enum
+#         #   OpenNI_Default_Mode = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+#         #   OpenNI_SXGA_15Hz = 1,    // Only supported by the Kinect
+#         #   OpenNI_VGA_30Hz = 2,     // Supported by PSDK, Xtion and Kinect
+#         #   OpenNI_VGA_25Hz = 3,     // Supportged by PSDK and Xtion
+#         #   OpenNI_QVGA_25Hz = 4,    // Supported by PSDK and Xtion
+#         #   OpenNI_QVGA_30Hz = 5,    // Supported by PSDK, Xtion and Kinect
+#         #   OpenNI_QVGA_60Hz = 6,    // Supported by PSDK and Xtion
+#         #   OpenNI_QQVGA_25Hz = 7,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         #   OpenNI_QQVGA_30Hz = 8,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         #   OpenNI_QQVGA_60Hz = 9    // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         # } Mode;
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#     ctypedef enum Mode2 "pcl::OpenNIGrabber":
+#         Grabber_OpenNI_Default_Mode "pcl::OpenNIGrabber::OpenNI_Default_Mode"   # = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+#         Grabber_OpenNI_SXGA_15Hz "pcl::OpenNIGrabber::OpenNI_SXGA_15Hz"         # = 1, // Only supported by the Kinect
+#         Grabber_OpenNI_VGA_30Hz "pcl::OpenNIGrabber::OpenNI_VGA_30Hz"           # = 2, // Supported by PSDK, Xtion and Kinect
+#         Grabber_OpenNI_VGA_25Hz "pcl::OpenNIGrabber::OpenNI_VGA_25Hz"           # = 3, // Supportged by PSDK and Xtion
+#         Grabber_OpenNI_QVGA_25Hz "pcl::OpenNIGrabber::OpenNI_QVGA_25Hz"         # = 4, // Supported by PSDK and Xtion
+#         Grabber_OpenNI_QVGA_30Hz "pcl::OpenNIGrabber::OpenNI_QVGA_30Hz"         # = 5, // Supported by PSDK, Xtion and Kinect
+#         Grabber_OpenNI_QVGA_60Hz "pcl::OpenNIGrabber::OpenNI_QVGA_60Hz"         # = 6, // Supported by PSDK and Xtion
+#         Grabber_OpenNI_QQVGA_25Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_25Hz"       # = 7, // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         Grabber_OpenNI_QQVGA_30Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_30Hz"       # = 8, // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         Grabber_OpenNI_QQVGA_60Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_60Hz"       # = 9  // Not supported -> using software downsampling (only for integer scale factor and only NN)
+
diff --git a/pcl/pcl_grabber_defs_180.pxd b/pcl/pcl_grabber_defs_180.pxd
new file mode 100644
index 0000000..7a9283a
--- /dev/null
+++ b/pcl/pcl_grabber_defs_180.pxd
@@ -0,0 +1,781 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# main
+cimport pcl_defs as cpp
+
+from boost_shared_ptr cimport shared_ptr
+# from boost_function cimport function
+# from boost_signal2_connection cimport connection
+# bind
+from _bind_defs cimport connection
+from _bind_defs cimport arg
+from _bind_defs cimport function
+from _bind_defs cimport callback_t
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# grabber.h
+# namespace pcl
+# /** \brief Grabber interface for PCL 1.x device drivers
+#  * \author Suat Gedikli <gedikli@willowgarage.com>
+#  * \ingroup io
+#  */
+# class PCL_EXPORTS Grabber
+cdef extern from "pcl/io/grabber.h" namespace "pcl":
+    cdef cppclass Grabber:
+        Grabber ()
+        # public:
+        # /** \brief registers a callback function/method to a signal with the corresponding signature
+        #   * \param[in] callback: the callback function/method
+        #   * \return Connection object, that can be used to disconnect the callback method from the signal again.
+        # template<typename T> boost::signals2::connection registerCallback (const boost::function<T>& callback);
+        # connection registerCallback[T](function[T]& callback)
+        connection registerCallback[T](function[T] callback)
+        
+        # /** \brief indicates whether a signal with given parameter-type exists or not
+        #   * \return true if signal exists, false otherwise
+        # template<typename T> bool providesCallback () const;
+        bool providesCallback[T]()
+        
+        # 
+        # /** \brief For devices that are streaming, the streams are started by calling this method.
+        #   *        Trigger-based devices, just trigger the device once for each call of start.
+        # virtual void start () = 0;
+        # 
+        # /** \brief For devices that are streaming, the streams are stopped.
+        #   *        This method has no effect for triggered devices.
+        # virtual void stop () = 0;
+        # 
+        # /** \brief returns the name of the concrete subclass.
+        #   * \return the name of the concrete driver.
+        # virtual std::string getName () const = 0;
+        # 
+        # /** \brief Indicates whether the grabber is streaming or not. This value is not defined for triggered devices.
+        #   * \return true if grabber is running / streaming. False otherwise.
+        # virtual bool isRunning () const = 0;
+        # 
+        # /** \brief returns fps. 0 if trigger based. */
+        # virtual float getFramesPerSecond () const = 0;
+
+
+# template<typename T> boost::signals2::signal<T>* Grabber::find_signal () const
+# template<typename T> void Grabber::disconnect_all_slots ()
+# template<typename T> void Grabber::block_signal ()
+# template<typename T> void Grabber::unblock_signal ()
+# void Grabber::block_signals ()
+# void Grabber::unblock_signals ()
+# template<typename T> int Grabber::num_slots () const
+# template<typename T> boost::signals2::signal<T>* Grabber::createSignal ()
+# template<typename T> boost::signals2::connection Grabber::registerCallback (const boost::function<T> & callback)
+# template<typename T> bool Grabber::providesCallback () const
+
+
+###
+
+# pcl 1.7
+# oni_grabber.h
+# namespace pcl
+#     struct PointXYZ;
+#     struct PointXYZRGB;
+#     struct PointXYZRGBA;
+#     struct PointXYZI;
+# template <typename T> class PointCloud;
+# /** \brief A simple ONI grabber.
+#  * \author Suat Gedikli
+# class PCL_EXPORTS ONIGrabber : public Grabber
+# cdef extern from "pcl/io/oni_grabber.h" namespace "pcl":
+#     cdef cppclass ONIGrabber(Grabber):
+#         ONIGrabber (string file_name, bool repeat, bool stream)
+        # public:
+        # //define callback signature typedefs
+        # typedef void (sig_cb_openni_image) (const boost::shared_ptr<openni_wrapper::Image>&);
+        # typedef void (sig_cb_openni_depth_image) (const boost::shared_ptr<openni_wrapper::DepthImage>&);
+        # typedef void (sig_cb_openni_ir_image) (const boost::shared_ptr<openni_wrapper::IRImage>&);
+        # typedef void (sig_cb_openni_image_depth_image) (const boost::shared_ptr<openni_wrapper::Image>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_ir_depth_image) (const boost::shared_ptr<openni_wrapper::IRImage>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_openni_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # /** \brief For devices that are streaming, the streams are started by calling this method.
+        #   * Trigger-based devices, just trigger the device once for each call of start.
+        # void start ()
+        # 
+        # /** \brief For devices that are streaming, the streams are stopped.
+        #  *        This method has no effect for triggered devices.
+        #  */
+        # void stop ()
+        #
+        # /** \brief returns the name of the concrete subclass.
+        #  * \return the name of the concrete driver.
+        #  */
+        # string getName ()
+        #
+        # /** \brief Indicates whether the grabber is streaming or not. This value is not defined for triggered devices.
+        #  * \return true if grabber is running / streaming. False otherwise.
+        #  */
+        # bool isRunning ()
+        # 
+        # /** \brief returns the frames pre second. 0 if it is trigger based. */
+        # float getFramesPerSecond ()
+        # 
+        # protected:
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles image streams */
+        # void imageCallback (boost::shared_ptr<openni_wrapper::Image> image, void* cookie);
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles depth streams */
+        # void depthCallback (boost::shared_ptr<openni_wrapper::DepthImage> depth_image, void* cookie);
+        # /** \brief internal OpenNI (openni_wrapper) callback that handles IR streams */
+        # void irCallback (boost::shared_ptr<openni_wrapper::IRImage> ir_image, void* cookie);
+        # /** \brief internal callback that handles synchronized image + depth streams */
+        # void imageDepthImageCallback (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                         const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image);
+        # /** \brief internal callback that handles synchronized IR + depth streams */
+        # void irDepthImageCallback (const boost::shared_ptr<openni_wrapper::IRImage> &image,
+        #                      const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image);
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZ> > convertToXYZPointCloud (const boost::shared_ptr<openni_wrapper::DepthImage> &depth) const;
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZRGB> >
+        # convertToXYZRGBPointCloud (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                           const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZRGBA> >
+        # convertToXYZRGBAPointCloud (const boost::shared_ptr<openni_wrapper::Image> &image,
+        #                            const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief internal method to assemble a point cloud object */
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZI> >
+        # convertToXYZIPointCloud (const boost::shared_ptr<openni_wrapper::IRImage> &image,
+        #                         const boost::shared_ptr<openni_wrapper::DepthImage> &depth_image) const;
+        # 
+        # /** \brief synchronizer object to synchronize image and depth streams*/
+        # Synchronizer<boost::shared_ptr<openni_wrapper::Image>, boost::shared_ptr<openni_wrapper::DepthImage> > rgb_sync_;
+        # 
+        # /** \brief synchronizer object to synchronize IR and depth streams*/
+        # Synchronizer<boost::shared_ptr<openni_wrapper::IRImage>, boost::shared_ptr<openni_wrapper::DepthImage> > ir_sync_;
+        # 
+        # /** \brief the actual openni device*/
+        # boost::shared_ptr<openni_wrapper::DeviceONI> device_;
+        # std::string rgb_frame_id_;
+        # std::string depth_frame_id_;
+        # bool running_;
+        # unsigned image_width_;
+        # unsigned image_height_;
+        # unsigned depth_width_;
+        # unsigned depth_height_;
+        # openni_wrapper::OpenNIDevice::CallbackHandle depth_callback_handle;
+        # openni_wrapper::OpenNIDevice::CallbackHandle image_callback_handle;
+        # openni_wrapper::OpenNIDevice::CallbackHandle ir_callback_handle;
+        # boost::signals2::signal<sig_cb_openni_image >*            image_signal_;
+        # boost::signals2::signal<sig_cb_openni_depth_image >*      depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_image >*         ir_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_image_depth_image>* image_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_ir_depth_image>*    ir_depth_image_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud >*      point_cloud_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_i >*    point_cloud_i_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgb >*  point_cloud_rgb_signal_;
+        # boost::signals2::signal<sig_cb_openni_point_cloud_rgba >*  point_cloud_rgba_signal_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+
+###
+
+# pcl 1.7
+# openni_grabber.h
+# namespace pcl
+#   struct PointXYZ;
+#   struct PointXYZRGB;
+#   struct PointXYZRGBA;
+#   struct PointXYZI;
+#   template <typename T> class PointCloud;
+# 
+# /** \brief Grabber for OpenNI devices (i.e., Primesense PSDK, Microsoft Kinect, Asus XTion Pro/Live)
+#   * \author Nico Blodow <blodow@cs.tum.edu>, Suat Gedikli <gedikli@willowgarage.com>
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS OpenNIGrabber : public Grabber
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#     cdef cppclass OpenNIGrabber(Grabber):
+#         # OpenNIGrabber ()
+        # OpenNIGrabber (string device_id, Mode2 depth_mode, Mode2 image_mode)
+        # OpenNIGrabber (const std::string& device_id = "",
+        #                const Mode& depth_mode = OpenNI_Default_Mode,
+        #                const Mode& image_mode = OpenNI_Default_Mode);
+        # public:
+        # //define callback signature typedefs
+        # typedef void (sig_cb_openni_image) (const boost::shared_ptr<openni_wrapper::Image>&);
+        # typedef void (sig_cb_openni_depth_image) (const boost::shared_ptr<openni_wrapper::DepthImage>&);
+        # typedef void (sig_cb_openni_ir_image) (const boost::shared_ptr<openni_wrapper::IRImage>&);
+        # typedef void (sig_cb_openni_image_depth_image) (const boost::shared_ptr<openni_wrapper::Image>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_ir_depth_image) (const boost::shared_ptr<openni_wrapper::IRImage>&, const boost::shared_ptr<openni_wrapper::DepthImage>&, float constant) ;
+        # typedef void (sig_cb_openni_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGB> >&);
+        # typedef void (sig_cb_openni_point_cloud_rgba) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # typedef void (sig_cb_openni_point_cloud_i) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # typedef void (sig_cb_openni_point_cloud_eigen) (const boost::shared_ptr<const pcl::PointCloud<Eigen::MatrixXf> >&);
+        # public:
+        # /** \brief Start the data acquisition. */
+        # void start ()
+        # 
+        # /** \brief Stop the data acquisition. */
+        # void stop ()
+        # 
+        # /** \brief Check if the data acquisition is still running. */
+        # bool isRunning ()
+        # 
+        # string getName ()
+        # 
+        # /** \brief Obtain the number of frames per second (FPS). */
+        # float getFramesPerSecond () const
+        # 
+        # /** \brief Get a boost shared pointer to the \ref OpenNIDevice object. */
+        # inline shared_ptr[openni_wrapper::OpenNIDevice] getDevice () const;
+        # /** \brief Obtain a list of the available depth modes that this device supports. */
+        # vector[pair[int, XnMapOutputMode] ] getAvailableDepthModes ()
+        # /** \brief Obtain a list of the available image modes that this device supports. */
+        # vector[pair[int, XnMapOutputMode] ] getAvailableImageModes ()
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+# 
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#   cdef boost::shared_ptr<openni_wrapper::OpenNIDevice>
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#   cdef OpenNIGrabber::getDevice () const
+###
+
+# pcl.1.8.0
+# dinast_grabber.h
+#include <pcl/point_types.h>
+#include <pcl/point_cloud.h>
+#include <pcl/io/grabber.h>
+#include <pcl/common/time.h>
+#include <pcl/console/print.h>
+#include <libusb-1.0/libusb.h>
+#include <boost/circular_buffer.hpp>
+#
+# namespace pcl
+# /** \brief Grabber for DINAST devices (i.e., IPA-1002, IPA-1110, IPA-2001)
+#   * \author Marco A. Gutierrez <marcog@unex.es>
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS DinastGrabber: public Grabber
+        # // Define callback signature typedefs
+        # typedef void (sig_cb_dinast_point_cloud) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # 
+        # public:
+        # /** \brief Constructor that sets up the grabber constants.
+        #   * \param[in] device_position Number corresponding the device to grab
+        #   */
+        # DinastGrabber (const int device_position=1);
+        # 
+        # /** \brief Destructor. It never throws. */
+        # virtual ~DinastGrabber () throw ();
+        # 
+        # /** \brief Check if the grabber is running
+        #  * \return true if grabber is running / streaming. False otherwise.
+        #  */
+        # virtual bool isRunning () const;
+        # 
+        # /** \brief Returns the name of the concrete subclass, DinastGrabber.
+        #   * \return DinastGrabber.
+        #   */
+        # virtual std::string getName () const
+        # 
+        # /** \brief Start the data acquisition process.
+        #  */
+        # virtual void start ();
+        # 
+        # /** \brief Stop the data acquisition process.
+        #  */
+        # virtual void stop ();
+        # 
+        # /** \brief Obtain the number of frames per second (FPS). */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Get the version number of the currently opened device
+        #  */
+        # std::string getDeviceVersion ();
+        # 
+        # protected:  
+        # /** \brief On initialization processing. */
+        # void onInit (const int device_id);
+        # 
+        # /** \brief Setup a Dinast 3D camera device
+        #   * \param[in] device_position Number corresponding the device to grab
+        #   * \param[in] id_vendor The ID of the camera vendor (should be 0x18d1)
+        #   * \param[in] id_product The ID of the product (should be 0x1402)
+        #   */
+        # void
+        # setupDevice (int device_position,
+        #            const int id_vendor = 0x18d1, 
+        #            const int id_product = 0x1402);
+        # 
+        # /** \brief Send a RX data packet request
+        #   * \param[in] req_code the request to send (the request field for the setup packet)
+        #   * \param buffer
+        #   * \param[in] length the length field for the setup packet. The data buffer should be at least this #size.
+        #   */
+        # bool
+        # USBRxControlData (const unsigned char req_code,
+        #                   unsigned char *buffer,
+        #                   int length);
+        # 
+        # /** \brief Send a TX data packet request
+        #   * \param[in] req_code the request to send (the request field for the setup packet)
+        #   * \param buffer
+        #   * \param[in] length the length field for the setup packet. The data buffer should be at least this size.
+        #   */
+        # bool
+        # USBTxControlData (const unsigned char req_code,
+        #                   unsigned char *buffer,
+        #                   int length);
+        # 
+        # /** \brief Check if we have a header in the global buffer, and return the position of the next valid image.
+        #   * \note If the image in the buffer is partial, return -1, as we have to wait until we add more data to it.
+        #   * \return the position of the next valid image (i.e., right after a valid header) or -1 in case the buffer 
+        #   * either doesn't have an image or has a partial image
+        #   */
+        # int checkHeader ();
+        # 
+        # /** \brief Read image data and leaves it on image_
+        #   */
+        # void readImage ();
+        # 
+        # /** \brief Obtains XYZI Point Cloud from the image of the camera
+        #   * \return the point cloud from the image data
+        #   */
+        # pcl::PointCloud<pcl::PointXYZI>::Ptr getXYZIPointCloud ();
+        # 
+        # /** \brief The function in charge of getting the data from the camera
+        #   */
+        # void captureThreadFunction ();
+        # 
+        # /** \brief Width of image */
+        # int image_width_;
+        # 
+        # /** \brief Height of image */
+        # int image_height_;
+        # 
+        # /** \brief Total size of image */
+        # int image_size_;
+        # 
+        # /** \brief Length of a sync packet */
+        # int sync_packet_size_;
+        # 
+        # double dist_max_2d_;
+        # 
+        # /** \brief diagonal Field of View*/
+        # double fov_;
+        # 
+        # /** \brief Size of pixel */
+        # enum pixel_size { RAW8=1, RGB16=2, RGB24=3, RGB32=4 };
+        # 
+        # /** \brief The libusb context*/
+        # libusb_context *context_;
+        # 
+        # /** \brief the actual device_handle for the camera */
+        # struct libusb_device_handle *device_handle_;
+        # 
+        # /** \brief Temporary USB read buffer, since we read two RGB16 images at a time size is the double of two images
+        #   * plus a sync packet.
+        #   */
+        # unsigned char *raw_buffer_ ;
+        # 
+        # /** \brief Global circular buffer */
+        # boost::circular_buffer<unsigned char> g_buffer_;
+        # 
+        # /** \brief Bulk endpoint address value */
+        # unsigned char bulk_ep_;
+        # 
+        # /** \brief Device command values */
+        # enum { CMD_READ_START=0xC7, CMD_READ_STOP=0xC8, CMD_GET_VERSION=0xDC, CMD_SEND_DATA=0xDE };
+        # 
+        # unsigned char *image_;
+        # 
+        # /** \brief Since there is no header after the first image, we need to save the state */
+        # bool second_image_;
+        # bool running_;
+        # boost::thread capture_thread_;
+        # 
+        # mutable boost::mutex capture_mutex_;
+        # boost::signals2::signal<sig_cb_dinast_point_cloud>* point_cloud_signal_;
+
+
+###
+
+# pcd_grabber.h
+# namespace pcl
+# /** \brief Base class for PCD file grabber.
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS PCDGrabberBase : public Grabber
+cdef extern from "pcl/io/pcd_grabber.h" namespace "pcl":
+    cdef cppclass PCDGrabberBase(Grabber):
+        PCDGrabberBase ()
+        # public:
+        # /** \brief Constructor taking just one PCD file or one TAR file containing multiple PCD files.
+        #   * \param[in] pcd_file path to the PCD file
+        #   * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        #   * \param[in] repeat whether to play PCD file in an endless loop or not.
+        #   */
+        # PCDGrabberBase (const std::string& pcd_file, float frames_per_second, bool repeat);
+        # 
+        # /** \brief Constructor taking a list of paths to PCD files, that are played in the order they appear in the list.
+        #   * \param[in] pcd_files vector of paths to PCD files.
+        #   * \param[in] frames_per_second frames per second. If 0, start() functions like a trigger, publishing the next PCD in the list.
+        #   * \param[in] repeat whether to play PCD file in an endless loop or not.
+        #   */
+        # PCDGrabberBase (const std::vector<std::string>& pcd_files, float frames_per_second, bool repeat);
+        # 
+        # /** \brief Copy constructor.
+        #   * \param[in] src the PCD Grabber base object to copy into this
+        #   */
+        # PCDGrabberBase (const PCDGrabberBase &src) : impl_ ()
+        # /** \brief Copy operator.
+        #   * \param[in] src the PCD Grabber base object to copy into this
+        #   */
+        # PCDGrabberBase&
+        # operator = (const PCDGrabberBase &src)
+        # 
+        # /** \brief Virtual destructor. */
+        # virtual ~PCDGrabberBase () throw ();
+        # 
+        # /** \brief Starts playing the list of PCD files if frames_per_second is > 0. Otherwise it works as a trigger: publishes only the next PCD file in the list. */
+        # virtual void start ();
+        # 
+        # /** \brief Stops playing the list of PCD files if frames_per_second is > 0. Otherwise the method has no effect. */
+        # virtual void stop ();
+        # 
+        # /** \brief Triggers a callback with new data */
+        # virtual void trigger ();
+        # 
+        # /** \brief whether the grabber is started (publishing) or not.
+        #   * \return true only if publishing.
+        #   */
+        # virtual bool isRunning () const;
+        # 
+        # /** \return The name of the grabber */
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Rewinds to the first PCD file in the list.*/
+        # virtual void rewind ();
+        # 
+        # /** \brief Returns the frames_per_second. 0 if grabber is trigger-based */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Returns whether the repeat flag is on */
+        # bool isRepeatOn () const;
+
+
+###
+
+# template <typename PointT> class PCDGrabber : public PCDGrabberBase
+cdef extern from "pcl/io/pcd_grabber.h" namespace "pcl":
+    cdef cppclass PCDGrabber[T](PCDGrabberBase):
+        PCDGrabber ()
+        # PCDGrabber (const std::string& pcd_path, float frames_per_second = 0, bool repeat = false);
+        # PCDGrabber (const std::vector<std::string>& pcd_files, float frames_per_second = 0, bool repeat = false);
+        # protected:
+        # virtual void publish (const sensor_msgs::PointCloud2& blob, const Eigen::Vector4f& origin, const Eigen::Quaternionf& orientation) const;
+        # boost::signals2::signal<void (const boost::shared_ptr<const pcl::PointCloud<PointT> >&)>* signal_;
+        # #ifdef HAVE_OPENNI
+        #   boost::signals2::signal<void (const boost::shared_ptr<openni_wrapper::DepthImage>&)>*     depth_image_signal_;
+        # # #endif
+
+# template<typename PointT>
+# PCDGrabber<PointT>::PCDGrabber (const std::string& pcd_path, float frames_per_second, bool repeat)
+# : PCDGrabberBase (pcd_path, frames_per_second, repeat)
+###
+
+# template<typename PointT>
+# PCDGrabber<PointT>::PCDGrabber (const std::vector<std::string>& pcd_files, float frames_per_second, bool repeat)
+#   : PCDGrabberBase (pcd_files, frames_per_second, repeat), signal_ ()
+###
+
+# template<typename PointT> void 
+# PCDGrabber<PointT>::publish (const sensor_msgs::PointCloud2& blob, const Eigen::Vector4f& origin, const Eigen::Quaternionf& orientation) const
+###
+
+# pcl 1.8.0
+# file_grabber.h
+##pragma once
+##ifndef PCL_IO_FILE_GRABBER_H_
+##define PCL_IO_FILE_GRABBER_H_
+#
+##include <pcl/point_cloud.h>
+#
+# namespace pcl
+# /** \brief FileGrabber provides a container-style interface for grabbers which operate on fixed-size input
+#   * \author Stephen Miller
+#   * \ingroup io
+#   */
+# template <typename PointT>
+# class PCL_EXPORTS FileGrabber
+        # public:
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~FileGrabber () {}
+        # 
+        # /** \brief operator[] Returns the idx-th cloud in the dataset, without bounds checking.
+        #   *  Note that in the future, this could easily be modified to do caching
+        #   *  \param[in] idx The frame to load
+        #   */
+        # virtual const boost::shared_ptr< const pcl::PointCloud<PointT> > operator[] (size_t idx) const = 0;
+        # 
+        # /** \brief size Returns the number of clouds currently loaded by the grabber */
+        # virtual size_t size () const = 0;
+        # 
+        # /** \brief at Returns the idx-th cloud in the dataset, with bounds checking
+        #  *  \param[in] idx The frame to load
+        #  */
+        # virtual const boost::shared_ptr< const pcl::PointCloud<PointT> > at (size_t idx) const
+
+
+###
+
+# pcl 1.8.0
+# hdl_grabber.h
+##include "pcl/pcl_config.h"
+#
+##ifndef PCL_IO_HDL_GRABBER_H_
+##define PCL_IO_HDL_GRABBER_H_
+#
+##include <pcl/io/grabber.h>
+##include <pcl/io/impl/synchronized_queue.hpp>
+##include <pcl/point_types.h>
+##include <pcl/point_cloud.h>
+##include <boost/asio.hpp>
+##include <string>
+#
+##define HDL_Grabber_toRadians(x) ((x) * M_PI / 180.0)
+#
+# namespace pcl
+# /** \brief Grabber for the Velodyne High-Definition-Laser (HDL)
+#   * \author Keven Ring <keven@mitre.org>
+#   * \ingroup io
+#   */
+# class PCL_EXPORTS HDLGrabber : public Grabber
+        # public:
+        # /** \brief Signal used for a single sector
+        #   *         Represents 1 corrected packet from the HDL Velodyne
+        #   */
+        # typedef void
+        # (sig_cb_velodyne_hdl_scan_point_cloud_xyz) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&,
+        #                                             float,
+        #                                             float);
+        # /** \brief Signal used for a single sector
+        #   *         Represents 1 corrected packet from the HDL Velodyne.  Each laser has a different RGB
+        #   */
+        # typedef void
+        # (sig_cb_velodyne_hdl_scan_point_cloud_xyzrgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&,
+        #                                                float,
+        #                                                float);
+        # /** \brief Signal used for a single sector
+        #   *         Represents 1 corrected packet from the HDL Velodyne with the returned intensity.
+        #   */
+        # typedef void
+        # (sig_cb_velodyne_hdl_scan_point_cloud_xyzi) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&,
+        #                                              float startAngle,
+        #                                              float);
+        # /** \brief Signal used for a 360 degree sweep
+        #   *         Represents multiple corrected packets from the HDL Velodyne
+        #   *         This signal is sent when the Velodyne passes angle "0"
+        #   */
+        # typedef void
+        # (sig_cb_velodyne_hdl_sweep_point_cloud_xyz) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZ> >&);
+        # /** \brief Signal used for a 360 degree sweep
+        #   *         Represents multiple corrected packets from the HDL Velodyne with the returned intensity
+        #   *         This signal is sent when the Velodyne passes angle "0"
+        #   */
+        # typedef void
+        # (sig_cb_velodyne_hdl_sweep_point_cloud_xyzi) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZI> >&);
+        # /** \brief Signal used for a 360 degree sweep
+        #   *         Represents multiple corrected packets from the HDL Velodyne
+        #   *         This signal is sent when the Velodyne passes angle "0".  Each laser has a different RGB
+        #   */
+        # typedef void
+        # (sig_cb_velodyne_hdl_sweep_point_cloud_xyzrgb) (const boost::shared_ptr<const pcl::PointCloud<pcl::PointXYZRGBA> >&);
+        # 
+        # /** \brief Constructor taking an optional path to an HDL corrections file.  The Grabber will listen on the default IP/port for data packets [192.168.3.255/2368]
+        #   * \param[in] correctionsFile Path to a file which contains the correction parameters for the HDL.  This parameter is mandatory for the HDL-64, optional for the HDL-32
+        #   * \param[in] pcapFile Path to a file which contains previously captured data packets.  This parameter is optional
+        #   */
+        # HDLGrabber (const std::string& correctionsFile = "", const std::string& pcapFile = "");
+        # 
+        # /** \brief Constructor taking a pecified IP/port and an optional path to an HDL corrections file.
+        #   * \param[in] ipAddress IP Address that should be used to listen for HDL packets
+        #   * \param[in] port UDP Port that should be used to listen for HDL packets
+        #   * \param[in] correctionsFile Path to a file which contains the correction parameters for the HDL.  This field is mandatory for the HDL-64, optional for the HDL-32
+        #   */
+        # HDLGrabber (const boost::asio::ip::address& ipAddress, const unsigned short port, const std::string& correctionsFile = "?");
+        # 
+        # /** \brief virtual Destructor inherited from the Grabber interface. It never throws. */
+        # virtual ~HDLGrabber () throw ();
+        # 
+        # /** \brief Starts processing the Velodyne packets, either from the network or PCAP file. */
+        # virtual void start ();
+        # 
+        # /** \brief Stops processing the Velodyne packets, either from the network or PCAP file */
+        # virtual void stop ();
+        # 
+        # /** \brief Obtains the name of this I/O Grabber
+        #  *  \return The name of the grabber
+        #  */
+        # virtual std::string getName () const;
+        # 
+        # /** \brief Check if the grabber is still running.
+        #  *  \return TRUE if the grabber is running, FALSE otherwise
+        #  */
+        # virtual bool isRunning () const;
+        # 
+        # /** \brief Returns the number of frames per second.
+        # */
+        # virtual float getFramesPerSecond () const;
+        # 
+        # /** \brief Allows one to filter packets based on the SOURCE IP address and PORT
+        # *         This can be used, for instance, if multiple HDL LIDARs are on the same network
+        # */
+        # void
+        # filterPackets (const boost::asio::ip::address& ipAddress, const unsigned short port = 443);
+        # 
+        # /** \brief Allows one to customize the colors used for each of the lasers.
+        # */
+        # void
+        # setLaserColorRGB (const pcl::RGB& color, unsigned int laserNumber);
+        # 
+        # /** \brief Any returns from the HDL with a distance less than this are discarded.
+        #   *         This value is in meters
+        #   *         Default: 0.0
+        #   */
+        # void setMinimumDistanceThreshold (float & minThreshold);
+        # 
+        # /** \brief Any returns from the HDL with a distance greater than this are discarded.
+        #   *         This value is in meters
+        #   *         Default: 10000.0
+        #   */
+        # void setMaximumDistanceThreshold (float & maxThreshold);
+        # 
+        # /** \brief Returns the current minimum distance threshold, in meters
+        #   */
+        # float getMinimumDistanceThreshold ();
+        # 
+        # /** \brief Returns the current maximum distance threshold, in meters
+        #   */
+        # float getMaximumDistanceThreshold ();
+        # 
+        # protected:
+        # static const int HDL_DATA_PORT = 2368;
+        # static const int HDL_NUM_ROT_ANGLES = 36001;
+        # static const int HDL_LASER_PER_FIRING = 32;
+        # static const int HDL_MAX_NUM_LASERS = 64;
+        # static const int HDL_FIRING_PER_PKT = 12;
+        # 
+        # enum HDLBlock
+        # {
+        #   BLOCK_0_TO_31 = 0xeeff, BLOCK_32_TO_63 = 0xddff
+        # };
+        # 
+        # #pragma pack(push, 1)
+        # typedef struct HDLLaserReturn
+        # {
+        #    unsigned short distance;
+        #    unsigned char intensity;
+        # } HDLLaserReturn;
+        # #pragma pack(pop)
+        # 
+        # struct HDLFiringData
+        # {
+        #   unsigned short blockIdentifier;
+        #   unsigned short rotationalPosition;
+        #   HDLLaserReturn laserReturns[HDL_LASER_PER_FIRING];
+        # };
+        # 
+        # struct HDLDataPacket
+        # {
+        #   HDLFiringData firingData[HDL_FIRING_PER_PKT];
+        #   unsigned int gpsTimestamp;
+        #   unsigned char mode;
+        #   unsigned char sensorType;
+        # };
+        # 
+        # struct HDLLaserCorrection
+        # {
+        #     double azimuthCorrection;
+        #     double verticalCorrection;
+        #     double distanceCorrection;
+        #     double verticalOffsetCorrection;
+        #     double horizontalOffsetCorrection;
+        #     double sinVertCorrection;
+        #     double cosVertCorrection;
+        #     double sinVertOffsetCorrection;
+        #     double cosVertOffsetCorrection;
+        # };
+        # 
+        # HDLLaserCorrection laser_corrections_[HDL_MAX_NUM_LASERS];
+        # unsigned int last_azimuth_;
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZ> > current_scan_xyz_, current_sweep_xyz_;
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZI> > current_scan_xyzi_, current_sweep_xyzi_;
+        # boost::shared_ptr<pcl::PointCloud<pcl::PointXYZRGBA> > current_scan_xyzrgb_, current_sweep_xyzrgb_;
+        # boost::signals2::signal<sig_cb_velodyne_hdl_sweep_point_cloud_xyz>* sweep_xyz_signal_;
+        # boost::signals2::signal<sig_cb_velodyne_hdl_sweep_point_cloud_xyzrgb>* sweep_xyzrgb_signal_;
+        # boost::signals2::signal<sig_cb_velodyne_hdl_sweep_point_cloud_xyzi>* sweep_xyzi_signal_;
+        # boost::signals2::signal<sig_cb_velodyne_hdl_scan_point_cloud_xyz>* scan_xyz_signal_;
+        # boost::signals2::signal<sig_cb_velodyne_hdl_scan_point_cloud_xyzrgb>* scan_xyzrgb_signal_;
+        # boost::signals2::signal<sig_cb_velodyne_hdl_scan_point_cloud_xyzi>* scan_xyzi_signal_;
+        # 
+        # void fireCurrentSweep ();
+        # 
+        # void fireCurrentScan (const unsigned short startAngle, const unsigned short endAngle);
+        # void computeXYZI (pcl::PointXYZI& pointXYZI,
+        #                   int azimuth,
+        #                   HDLLaserReturn laserReturn,
+        #                   HDLLaserCorrection correction);
+
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#     cdef cppclass OpenNIGrabber(Grabber):
+#         # public:
+#         # typedef enum
+#         #   OpenNI_Default_Mode = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+#         #   OpenNI_SXGA_15Hz = 1,    // Only supported by the Kinect
+#         #   OpenNI_VGA_30Hz = 2,     // Supported by PSDK, Xtion and Kinect
+#         #   OpenNI_VGA_25Hz = 3,     // Supportged by PSDK and Xtion
+#         #   OpenNI_QVGA_25Hz = 4,    // Supported by PSDK and Xtion
+#         #   OpenNI_QVGA_30Hz = 5,    // Supported by PSDK, Xtion and Kinect
+#         #   OpenNI_QVGA_60Hz = 6,    // Supported by PSDK and Xtion
+#         #   OpenNI_QQVGA_25Hz = 7,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         #   OpenNI_QQVGA_30Hz = 8,   // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         #   OpenNI_QQVGA_60Hz = 9    // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         # } Mode;
+# cdef extern from "pcl/io/openni_grabber.h" namespace "pcl":
+#     ctypedef enum Mode2 "pcl::OpenNIGrabber":
+#         Grabber_OpenNI_Default_Mode "pcl::OpenNIGrabber::OpenNI_Default_Mode"   # = 0, // This can depend on the device. For now all devices (PSDK, Xtion, Kinect) its VGA@30Hz
+#         Grabber_OpenNI_SXGA_15Hz "pcl::OpenNIGrabber::OpenNI_SXGA_15Hz"         # = 1, // Only supported by the Kinect
+#         Grabber_OpenNI_VGA_30Hz "pcl::OpenNIGrabber::OpenNI_VGA_30Hz"           # = 2, // Supported by PSDK, Xtion and Kinect
+#         Grabber_OpenNI_VGA_25Hz "pcl::OpenNIGrabber::OpenNI_VGA_25Hz"           # = 3, // Supportged by PSDK and Xtion
+#         Grabber_OpenNI_QVGA_25Hz "pcl::OpenNIGrabber::OpenNI_QVGA_25Hz"         # = 4, // Supported by PSDK and Xtion
+#         Grabber_OpenNI_QVGA_30Hz "pcl::OpenNIGrabber::OpenNI_QVGA_30Hz"         # = 5, // Supported by PSDK, Xtion and Kinect
+#         Grabber_OpenNI_QVGA_60Hz "pcl::OpenNIGrabber::OpenNI_QVGA_60Hz"         # = 6, // Supported by PSDK and Xtion
+#         Grabber_OpenNI_QQVGA_25Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_25Hz"       # = 7, // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         Grabber_OpenNI_QQVGA_30Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_30Hz"       # = 8, // Not supported -> using software downsampling (only for integer scale factor and only NN)
+#         Grabber_OpenNI_QQVGA_60Hz "pcl::OpenNIGrabber::OpenNI_QQVGA_60Hz"       # = 9  // Not supported -> using software downsampling (only for integer scale factor and only NN)
+###
+
diff --git a/pcl/pcl_io.pxd b/pcl/pcl_io.pxd
new file mode 100644
index 0000000..6266fe8
--- /dev/null
+++ b/pcl/pcl_io.pxd
@@ -0,0 +1,2008 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+
+# from boost_shared_ptr cimport shared_ptr
+
+cdef extern from "pcl/io/pcd_io.h" namespace "pcl::io":
+    # XYZ
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud,
+                    bool binary_mode) nogil except +
+    int savePCDFileASCII (string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFileBinary (string &file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFile (string &file_name, 
+                     cpp.PointCloud[cpp.PointXYZ] &cloud,
+                     vector[int] &indices, 
+                     bool binary_mode) nogil except +
+
+
+    # XYZI
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGB
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGBA
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud,
+                    bool binary_mode) nogil except +
+
+	# PointWithViewpoint
+    int load(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud,
+                    bool binary_mode) nogil except +
+
+cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+    # XYZ
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZI
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGB
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGBA
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud,
+                    bool binary_mode) nogil except +
+
+    # PointWithViewpoint
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud,
+                    bool binary_mode) nogil except +
+
+#http://dev.pointclouds.org/issues/624
+#cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+#    int loadPLYFile (string file_name, PointCloud[cpp.PointXYZ] cloud)
+#    int savePLYFile (string file_name, PointCloud[cpp.PointXYZ] cloud, bool binary_mode)
+
+# cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+
+###
+# file_io.h
+# namespace pcl
+# class PCL_EXPORTS FileReader
+#     public:
+#       /** \brief empty constructor */ 
+#       FileReader() {}
+#       /** \brief empty destructor */ 
+#       virtual ~FileReader() {}
+#       /** \brief Read a point cloud data header from a FILE file. 
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given FILE file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         * Returns:
+#         *  * < 0 (-1) on error
+#         *  * > 0 on success
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[out] origin the sensor acquisition origin (only for > FILE_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > FILE_V7 - identity if not present)
+#         * \param[out] file_version the FILE version of the file (either FILE_V6 or FILE_V7)
+#         * \param[out] data_type the type of data (binary data=1, ascii=0, etc)
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       virtual int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, 
+#                   int &file_version, int &data_type, unsigned int &data_idx, const int offset = 0) = 0;
+# 
+#       /** \brief Read a point cloud data from a FILE file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[out] origin the sensor acquisition origin (only for > FILE_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > FILE_V7 - identity if not present)
+#         * \param[out] file_version the FILE version of the file (either FILE_V6 or FILE_V7)
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       virtual int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &file_version, 
+#             const int offset = 0) = 0;
+# 
+#       /** \brief Read a point cloud data from a FILE file (FILE_V6 only!) and store it into a sensor_msgs/PointCloud2.
+#         * 
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read FILE_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file 
+#         * > FILE_V6 will generate a warning. 
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         *
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0)
+#       {
+#         Eigen::Vector4f origin;
+#         Eigen::Quaternionf orientation;
+#         int file_version;
+#         return (read (file_name, cloud, origin, orientation, file_version, offset));
+#       }
+# 
+#       /** \brief Read a point cloud data from any FILE file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       template<typename PointT> inline int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset  =0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int file_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_, 
+#                         file_version, offset);
+# 
+#         // Exit in case of error
+#         if (res < 0)
+#           return res;
+#         pcl::fromROSMsg (blob, cloud);
+#         return (0);
+#       }
+#   };
+# 
+#   /** \brief Point Cloud Data (FILE) file format writer.
+#     * Any (FILE) format file reader should implement its virtual methodes
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS FileWriter
+#   {
+#     public:
+#       /** \brief Empty constructor */ 
+#       FileWriter () {}
+# 
+#       /** \brief Empty destructor */ 
+#       virtual ~FileWriter () {}
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         */
+#       virtual int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false) = 0;
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         return (write (file_name, *cloud, origin, orientation, binary));
+#       }
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const bool binary = false)
+#       {
+#         Eigen::Vector4f origin = cloud.sensor_origin_;
+#         Eigen::Quaternionf orientation = cloud.sensor_orientation_;
+# 
+#         sensor_msgs::PointCloud2 blob;
+#         pcl::toROSMsg (cloud, blob);
+# 
+#         // Save the data
+#         return (write (file_name, blob, origin, orientation, binary));
+#       }
+#   };
+# 
+#   /** \brief insers a value of type Type (uchar, char, uint, int, float, double, ...) into a stringstream.
+#     *
+#     * If the value is NaN, it inserst "nan".
+#     *
+#     * \param[in] cloud the cloud to copy from
+#     * \param[in] point_index the index of the point
+#     * \param[in] point_size the size of the point in the cloud
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     * \param[out] stream the ostringstream to copy into
+#     */
+#   template <typename Type> inline void
+#   copyValueString (const sensor_msgs::PointCloud2 &cloud, 
+#                    const unsigned int point_index, 
+#                    const int point_size, 
+#                    const unsigned int field_idx, 
+#                    const unsigned int fields_count, 
+#                    std::ostream &stream)
+#   {
+#     Type value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       stream << boost::numeric_cast<Type>(value);
+#   }
+#   template <> inline void
+#   copyValueString<int8_t> (const sensor_msgs::PointCloud2 &cloud, 
+#                            const unsigned int point_index, 
+#                            const int point_size, 
+#                            const unsigned int field_idx, 
+#                            const unsigned int fields_count, 
+#                            std::ostream &stream)
+#   {
+#     int8_t value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (int8_t)], sizeof (int8_t));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       // Numeric cast doesn't give us what we want for int8_t
+#       stream << boost::numeric_cast<int>(value);
+#   }
+#   template <> inline void
+#   copyValueString<uint8_t> (const sensor_msgs::PointCloud2 &cloud, 
+#                             const unsigned int point_index, 
+#                             const int point_size, 
+#                             const unsigned int field_idx, 
+#                             const unsigned int fields_count, 
+#                             std::ostream &stream)
+#   {
+#     uint8_t value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (uint8_t)], sizeof (uint8_t));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       // Numeric cast doesn't give us what we want for uint8_t
+#       stream << boost::numeric_cast<int>(value);
+#   }
+# 
+#   /** \brief Check whether a given value of type Type (uchar, char, uint, int, float, double, ...) is finite or not
+#     *
+#     * \param[in] cloud the cloud that contains the data
+#     * \param[in] point_index the index of the point
+#     * \param[in] point_size the size of the point in the cloud
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     *
+#     * \return true if the value is finite, false otherwise
+#     */
+#   template <typename Type> inline bool
+#   isValueFinite (const sensor_msgs::PointCloud2 &cloud, 
+#                  const unsigned int point_index, 
+#                  const int point_size, 
+#                  const unsigned int field_idx, 
+#                  const unsigned int fields_count)
+#   {
+#     Type value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
+#     if (!pcl_isfinite (value))
+#       return (false);
+#     return (true);
+#   }
+# 
+#   /** \brief Copy one single value of type T (uchar, char, uint, int, float, double, ...) from a string
+#     * 
+#     * Uses aoti/atof to do the conversion.
+#     * Checks if the st is "nan" and converts it accordingly.
+#     *
+#     * \param[in] st the string containing the value to convert and copy
+#     * \param[out] cloud the cloud to copy it to
+#     * \param[in] point_index the index of the point
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     */
+#   template <typename Type> inline void
+#   copyStringValue (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                    unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     Type value;
+#     if (st == "nan")
+#     {
+#       value = std::numeric_limits<Type>::quiet_NaN ();
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> value;
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (Type)], reinterpret_cast<char*> (&value), sizeof (Type));
+#   }
+# 
+#   template <> inline void
+#   copyStringValue<int8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                            unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     int8_t value;
+#     if (st == "nan")
+#     {
+#       value = static_cast<int8_t> (std::numeric_limits<int>::quiet_NaN ());
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       int val;
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> val;
+#       value = static_cast<int8_t> (val);
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (int8_t)], reinterpret_cast<char*> (&value), sizeof (int8_t));
+#   }
+# 
+#   template <> inline void
+#   copyStringValue<uint8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                            unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     uint8_t value;
+#     if (st == "nan")
+#     {
+#       value = static_cast<uint8_t> (std::numeric_limits<int>::quiet_NaN ());
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       int val;
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> val;
+#       value = static_cast<uint8_t> (val);
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (uint8_t)], reinterpret_cast<char*> (&value), sizeof (uint8_t));
+###
+
+# io.h
+# #include <pcl/common/io.h>
+###
+
+# lzf.h
+# namespace pcl
+#   PCL_EXPORTS unsigned int 
+#   lzfCompress (const void *const in_data,  unsigned int in_len,
+#                void             *out_data, unsigned int out_len);
+#   PCL_EXPORTS unsigned int 
+#   lzfDecompress (const void *const in_data,  unsigned int in_len,
+#                  void             *out_data, unsigned int out_len);
+###
+
+# obj_io.h
+# namespace pcl
+#   namespace io
+#     PCL_EXPORTS int
+#     saveOBJFile (const std::string &file_name, 
+#                  const pcl::TextureMesh &tex_mesh, 
+#                  unsigned precision = 5);
+# 
+#     PCL_EXPORTS int
+#     saveOBJFile (const std::string &file_name, 
+#                  const pcl::PolygonMesh &mesh, 
+#                  unsigned precision = 5);
+# 
+###
+
+# pcd_io.h
+# namespace pcl
+# {
+#   /** \brief Point Cloud Data (PCD) file format reader.
+#     * \author Radu Bogdan Rusu
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PCDReader : public FileReader
+#   {
+#     public:
+#       /** Empty constructor */      
+#       PCDReader () : FileReader () {}
+#       /** Empty destructor */      
+#       ~PCDReader () {}
+#       /** \brief Various PCD file versions.
+#         *
+#         * PCD_V6 represents PCD files with version 0.6, which contain the following fields:
+#         *   - lines beginning with # are treated as comments
+#         *   - FIELDS ...
+#         *   - SIZE ...
+#         *   - TYPE ...
+#         *   - COUNT ...
+#         *   - WIDTH ...
+#         *   - HEIGHT ...
+#         *   - POINTS ...
+#         *   - DATA ascii/binary
+#         * 
+#         * Everything that follows \b DATA is intepreted as data points and
+#         * will be read accordingly.
+#         *
+#         * PCD_V7 represents PCD files with version 0.7 and has an important
+#         * addon: it adds sensor origin/orientation (aka viewpoint) information
+#         * to a dataset through the use of a new header field:
+#         *   - VIEWPOINT tx ty tz qw qx qy qz
+#         */
+#       enum
+#       {
+#         PCD_V6 = 0,
+#         PCD_V7 = 1
+#       };
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > PCD_V7 - identity if not present)
+#         * \param[out] pcd_version the PCD version of the file (i.e., PCD_V6, PCD_V7)
+#         * \param[out] data_type the type of data (0 = ASCII, 1 = Binary, 2 = Binary compressed) 
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version,
+#                   int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the properties will be filled)
+#         * \param[out] pcd_version the PCD version of the file (either PCD_V6 or PCD_V7)
+#         * \param[out] data_type the type of data (0 = ASCII, 1 = Binary, 2 = Binary compressed) 
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         *
+#         */
+#       int 
+#       readHeaderEigen (const std::string &file_name, pcl::PointCloud<Eigen::MatrixXf> &cloud,
+#                        int &pcd_version, int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PCD file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > PCD_V7 - identity if not present)
+#         * \param[out] pcd_version the PCD version of the file (either PCD_V6 or PCD_V7)
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PCD (PCD_V6) and store it into a sensor_msgs/PointCloud2.
+#         * 
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read PCD_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file 
+#         * > PCD_V6 will generate a warning. 
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from any PCD file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       template<typename PointT> int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset = 0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int pcd_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_, 
+#                         pcd_version, offset);
+# 
+#         // If no error, convert the data
+#         if (res == 0)
+#           pcl::fromROSMsg (blob, cloud);
+#         return (res);
+#       }
+# 
+#       /** \brief Read a point cloud data from any PCD file, and convert it to a pcl::PointCloud<Eigen::MatrixXf> format.
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int
+#       readEigen (const std::string &file_name, pcl::PointCloud<Eigen::MatrixXf> &cloud, const int offset = 0);
+#   };
+# 
+#   /** \brief Point Cloud Data (PCD) file format writer.
+#     * \author Radu Bogdan Rusu
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PCDWriter : public FileWriter
+#   {
+#     public:
+#       PCDWriter() : FileWriter(), map_synchronization_(false) {}
+#       ~PCDWriter() {}
+# 
+#       /** \brief Set whether mmap() synchornization via msync() is desired before munmap() calls. 
+#         * Setting this to true could prevent NFS data loss (see
+#         * http://www.pcl-developers.org/PCD-IO-consistency-on-NFS-msync-needed-td4885942.html).
+#         * Default: false
+#         * \note This option should be used by advanced users only!
+#         * \note Please note that using msync() on certain systems can reduce the I/O performance by up to 80%!
+#         * \param[in] sync set to true if msync() should be called before munmap()
+#         */
+#       void
+#       setMapSynchronization (bool sync)
+#       {
+#         map_synchronization_ = sync;
+#       }
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderBinary (const sensor_msgs::PointCloud2 &cloud, 
+#                             const Eigen::Vector4f &origin, 
+#                             const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a BINARY_COMPRESSED PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderBinaryCompressed (const sensor_msgs::PointCloud2 &cloud, 
+#                                       const Eigen::Vector4f &origin, 
+#                                       const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderASCII (const sensor_msgs::PointCloud2 &cloud, 
+#                            const Eigen::Vector4f &origin, 
+#                            const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] nr_points if given, use this to fill in WIDTH, HEIGHT (=1), and POINTS in the header
+#         * By default, nr_points is set to INTMAX, and the data in the header is used instead.
+#         */
+#       template <typename PointT> static std::string
+#       generateHeader (const pcl::PointCloud<PointT> &cloud, 
+#                       const int nr_points = std::numeric_limits<int>::max ());
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] nr_points if given, use this to fill in WIDTH, HEIGHT (=1), and POINTS in the header
+#         * By default, nr_points is set to INTMAX, and the data in the header is used instead.
+#         */
+#       std::string
+#       generateHeaderEigen (const pcl::PointCloud<Eigen::MatrixXf> &cloud, 
+#                            const int nr_points = std::numeric_limits<int>::max ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         *
+#         * As an intermediary solution, precision 8 is used, which guarantees lossless storage for RGB.
+#         */
+#       int 
+#       writeASCII (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                   const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                   const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       int 
+#       writeBinary (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                    const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                    const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY_COMPRESSED format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       int 
+#       writeBinaryCompressed (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         *
+#         * As an intermediary solution, precision 8 is used, which guarantees lossless storage for RGB.
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary (file_name, cloud, origin, orientation));
+#         else
+#           return (writeASCII (file_name, cloud, origin, orientation, 8));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] binary set to true if the file is to be written in a binary PCD format, 
+#         * false (default) for ASCII
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         return (write (file_name, *cloud, origin, orientation, binary));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       template <typename PointT> int 
+#       writeBinary (const std::string &file_name, 
+#                    const pcl::PointCloud<PointT> &cloud);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data
+#         */
+#       int 
+#       writeBinaryEigen (const std::string &file_name, 
+#                         const pcl::PointCloud<Eigen::MatrixXf> &cloud);
+# 
+#       /** \brief Save point cloud data to a binary comprssed PCD file
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       template <typename PointT> int 
+#       writeBinaryCompressed (const std::string &file_name, 
+#                              const pcl::PointCloud<PointT> &cloud);
+# 
+#       /** \brief Save point cloud data to a binary comprssed PCD file.
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       int 
+#       writeBinaryCompressedEigen (const std::string &file_name, 
+#                                   const pcl::PointCloud<Eigen::MatrixXf> &cloud);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] indices the set of point indices that we want written to disk
+#         */
+#       template <typename PointT> int 
+#       writeBinary (const std::string &file_name, 
+#                    const pcl::PointCloud<PointT> &cloud, 
+#                    const std::vector<int> &indices);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       template <typename PointT> int 
+#       writeASCII (const std::string &file_name, 
+#                   const pcl::PointCloud<PointT> &cloud,
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       int 
+#       writeASCIIEigen (const std::string &file_name, 
+#                        const pcl::PointCloud<Eigen::MatrixXf> &cloud,
+#                        const int precision = 8);
+# 
+#        /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] indices the set of point indices that we want written to disk
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       template <typename PointT> int 
+#       writeASCII (const std::string &file_name, 
+#                   const pcl::PointCloud<PointT> &cloud,
+#                   const std::vector<int> &indices,
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary<PointT> (file_name, cloud));
+#         else
+#           return (writeASCII<PointT> (file_name, cloud));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] indices the set of point indices that we want written to disk
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const std::vector<int> &indices,
+#              bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary<PointT> (file_name, cloud, indices));
+#         else
+#           return (writeASCII<PointT> (file_name, cloud, indices));
+#       }
+# 
+#     private:
+#       /** \brief Set to true if msync() should be called before munmap(). Prevents data loss on NFS systems. */
+#       bool map_synchronization_;
+# 
+#       typedef std::pair<std::string, pcl::ChannelProperties> pair_channel_properties;
+#       /** \brief Internal structure used to sort the ChannelProperties in the
+#         * cloud.channels map based on their offset. 
+#         */
+#       struct ChannelPropertiesComparator
+#       {
+#         bool 
+#         operator()(const pair_channel_properties &lhs, const pair_channel_properties &rhs) 
+#         {
+#           return (lhs.second.offset < rhs.second.offset);
+#         }
+#       };
+#   };
+# 
+#   namespace io
+#   {
+#     /** \brief Load a PCD v.6 file into a templated PointCloud type.
+#       * 
+#       * Any PCD files > v.6 will generate a warning as a
+#       * sensor_msgs/PointCloud2 message cannot hold the sensor origin.
+#       *
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     inline int 
+#     loadPCDFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud)
+#     {
+#       pcl::PCDReader p;
+#       return (p.read (file_name, cloud));
+#     }
+# 
+#     /** \brief Load any PCD file into a templated PointCloud type.
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#       * \param[out] orientation the sensor acquisition orientation (only for >
+#       * PCD_V7 - identity if not present)
+#       * \ingroup io
+#       */
+#     inline int 
+#     loadPCDFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation)
+#     {
+#       pcl::PCDReader p;
+#       int pcd_version;
+#       return (p.read (file_name, cloud, origin, orientation, pcd_version));
+#     }
+# 
+#     /** \brief Load any PCD file into a templated PointCloud type
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     loadPCDFile (const std::string &file_name, pcl::PointCloud<PointT> &cloud)
+#     {
+#       pcl::PCDReader p;
+#       return (p.read (file_name, cloud));
+#     }
+# 
+#     /** \brief Save point cloud data to a PCD file containing n-D points
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] origin the sensor acquisition origin
+#       * \param[in] orientation the sensor acquisition orientation
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     inline int 
+#     savePCDFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                  const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                  const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                  const bool binary_mode = false)
+#     {
+#       PCDWriter w;
+#       return (w.write (file_name, cloud, origin, orientation, binary_mode));
+#     }
+# 
+#     /** \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud, bool binary_mode = false)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, binary_mode));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format.
+#       *
+#       *      This version is to retain backwards compatibility.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFileASCII (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, false));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format.
+#       *
+#       *      This version is to retain backwards compatibility.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFileBinary (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, true));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format
+#       *
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] indices the set of indices to save
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> int
+#     savePCDFile (const std::string &file_name, 
+#                  const pcl::PointCloud<PointT> &cloud,
+#                  const std::vector<int> &indices, 
+#                  const bool binary_mode = false)
+#     {
+#       // Save the data
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, indices, binary_mode));
+#     }
+#  }
+###
+
+# pcl_io_exception.h
+# namespace pcl
+# {
+#   /** \brief Base exception class for I/O operations
+#     * \ingroup io
+#     */
+#   class PCLIOException : public PCLException
+#   {
+#     public:
+#       /** \brief Constructor
+#         * \param[in] error_description a string describing the error
+#         * \param[in] file_name the name of the file where the exception was caused
+#         * \param[in] function_name the name of the method where the exception was caused
+#         * \param[in] line_number the number of the line where the exception was caused
+#         */
+#       PCLIOException (const std::string& error_description,
+#                       const std::string& file_name = "",
+#                       const std::string& function_name = "",
+#                       unsigned line_number = 0)
+#       : PCLException (error_description, file_name, function_name, line_number)
+#       {
+#       }
+#   };
+# 
+#   /** \brief
+#     * \param[in] function_name the name of the method where the exception was caused
+#     * \param[in] file_name the name of the file where the exception was caused
+#     * \param[in] line_number the number of the line where the exception was caused
+#     * \param[in] format printf format
+#     * \ingroup io
+#     */
+#   inline void 
+#   throwPCLIOException (const char* function_name, const char* file_name, unsigned line_number, 
+#                        const char* format, ...)
+#   {
+#     char msg[1024];
+#     va_list args;
+#     va_start (args, format);
+#     vsprintf (msg, format, args);
+# 
+#     throw PCLIOException (msg, file_name, function_name, line_number);
+#   }
+# 
+###
+
+# ply_io.h
+# namespace pcl
+# {
+#   /** \brief Point Cloud Data (PLY) file format reader.
+#     *
+#     * The PLY data format is organized in the following way:
+#     * lines beginning with "comment" are treated as comments
+#     *   - ply
+#     *   - format [ascii|binary_little_endian|binary_big_endian] 1.0
+#     *   - element vertex COUNT
+#     *   - property float x 
+#     *   - property float y 
+#     *   - [property float z] 
+#     *   - [property float normal_x] 
+#     *   - [property float normal_y] 
+#     *   - [property float normal_z] 
+#     *   - [property uchar red] 
+#     *   - [property uchar green] 
+#     *   - [property uchar blue] ...
+#     *   - ascii/binary point coordinates
+#     *   - [element camera 1]
+#     *   - [property float view_px] ...
+#     *   - [element range_grid COUNT]
+#     *   - [property list uchar int vertex_indices]
+#     *   - end header
+#     *
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PLYReader : public FileReader
+#   {
+#     public:
+#       enum
+#       {
+#         PLY_V0 = 0,
+#         PLY_V1 = 1
+#       };
+#       
+#       PLYReader ()
+#         : FileReader ()
+#         , parser_ ()
+#         , origin_ (Eigen::Vector4f::Zero ())
+#         , orientation_ (Eigen::Matrix3f::Zero ())
+#         , cloud_ ()
+#         , vertex_count_ (0)
+#         , vertex_properties_counter_ (0)
+#         , vertex_offset_before_ (0)
+#         , range_grid_ (0)
+#         , range_count_ (0)
+#         , range_grid_vertex_indices_element_index_ (0)
+#         , rgb_offset_before_ (0)
+#       {}
+# 
+#       PLYReader (const PLYReader &p)
+#         : parser_ ()
+#         , origin_ (Eigen::Vector4f::Zero ())
+#         , orientation_ (Eigen::Matrix3f::Zero ())
+#         , cloud_ ()
+#         , vertex_count_ (0)
+#         , vertex_properties_counter_ (0)
+#         , vertex_offset_before_ (0)
+#         , range_grid_ (0)
+#         , range_count_ (0)
+#         , range_grid_vertex_indices_element_index_ (0)
+#         , rgb_offset_before_ (0)
+#       {
+#         *this = p;
+#       }
+# 
+#       PLYReader& operator = (const PLYReader &p)
+# 
+#       ~PLYReader () { delete range_grid_; }
+#       /** \brief Read a point cloud data header from a PLY file.
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PLY file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         * Returns:
+#         *  * < 0 (-1) on error
+#         *  * > 0 on success
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[out] ply_version the PLY version read from the file
+#         * \param[out] data_type the type of PLY data stored in the file
+#         * \param[out] data_idx the data index
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation,
+#                   int &ply_version, int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PLY file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[out] ply_version the PLY version read from the file
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int& ply_version, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PLY file (PLY_V6 only!) and store it into a sensor_msgs/PointCloud2.
+#         *
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read PLY_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file
+#         * > PLY_V6 will generate a warning.
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       inline int read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0)
+# 
+#       /** \brief Read a point cloud data from any PLY file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       template<typename PointT> inline int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset = 0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int ply_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_,
+#                         ply_version, offset);
+# 
+#         // Exit in case of error
+#         if (res < 0)
+#           return (res);
+#         pcl::fromROSMsg (blob, cloud);
+#         return (0);
+#       }
+#       
+#     private:
+#       ::pcl::io::ply::ply_parser parser_;
+# 
+#       bool
+#       parse (const std::string& istream_filename);
+# 
+#       /** \brief Info callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message information message
+#         */
+#       void 
+#       infoCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief Warning callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message warning message
+#         */
+#       void 
+#       warningCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief Error callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message error message
+#         */
+#       void 
+#       errorCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief function called when the keyword element is parsed
+#         * \param[in] element_name element name
+#         * \param[in] count number of instances
+#         */
+#       boost::tuple<boost::function<void ()>, boost::function<void ()> > 
+#       elementDefinitionCallback (const std::string& element_name, std::size_t count);
+#       
+#       bool
+#       endHeaderCallback ();
+# 
+#       /** \brief function called when a scalar property is parsed
+#         * \param[in] element_name element name to which the property belongs
+#         * \param[in] property_name property name
+#         */
+#       template <typename ScalarType> boost::function<void (ScalarType)> 
+#       scalarPropertyDefinitionCallback (const std::string& element_name, const std::string& property_name);
+# 
+#       /** \brief function called when a list property is parsed
+#         * \param[in] element_name element name to which the property belongs
+#         * \param[in] property_name list property name
+#         */
+#       template <typename SizeType, typename ScalarType> 
+#       boost::tuple<boost::function<void (SizeType)>, boost::function<void (ScalarType)>, boost::function<void ()> > 
+#       listPropertyDefinitionCallback (const std::string& element_name, const std::string& property_name);
+#       
+#       /** Callback function for an anonymous vertex float property.
+#         * Writes down a float value in cloud data.
+#         * param[in] value float value parsed
+#         */      
+#       inline void
+#       vertexFloatPropertyCallback (pcl::io::ply::float32 value);
+# 
+#       /** Callback function for vertex RGB color.
+#         * This callback is in charge of packing red green and blue in a single int
+#         * before writing it down in cloud data.
+#         * param[in] color_name color name in {red, green, blue}
+#         * param[in] color value of {red, green, blue} property
+#         */      
+#       inline void
+#       vertexColorCallback (const std::string& color_name, pcl::io::ply::uint8 color);
+# 
+#       /** Callback function for vertex intensity.
+#         * converts intensity from int to float before writing it down in cloud data.
+#         * param[in] intensity
+#         */
+#       inline void vertexIntensityCallback (pcl::io::ply::uint8 intensity);
+#       
+#       /** Callback function for origin x component.
+#         * param[in] value origin x value
+#         */
+#       inline void originXCallback (const float& value)
+#       
+#       /** Callback function for origin y component.
+#         * param[in] value origin y value
+#         */
+#       inline void originYCallback (const float& value)
+# 
+#       /** Callback function for origin z component.
+#         * param[in] value origin z value
+#         */      
+#       inline void originZCallback (const float& value)
+#     
+#       /** Callback function for orientation x axis x component.
+#         * param[in] value orientation x axis x value
+#         */
+#       inline void orientationXaxisXCallback (const float& value)
+#       
+#       /** Callback function for orientation x axis y component.
+#         * param[in] value orientation x axis y value
+#         */
+#       inline void orientationXaxisYCallback (const float& value)
+#       
+#       /** Callback function for orientation x axis z component.
+#         * param[in] value orientation x axis z value
+#         */
+#       inline void orientationXaxisZCallback (const float& value)
+#       
+#       /** Callback function for orientation y axis x component.
+#         * param[in] value orientation y axis x value
+#         */
+#       inline void orientationYaxisXCallback (const float& value)
+#       
+#       /** Callback function for orientation y axis y component.
+#         * param[in] value orientation y axis y value
+#         */
+#       inline void orientationYaxisYCallback (const float& value)
+# 
+#       /** Callback function for orientation y axis z component.
+#         * param[in] value orientation y axis z value
+#         */
+#       inline void orientationYaxisZCallback (const float& value)
+#       
+#       /** Callback function for orientation z axis x component.
+#         * param[in] value orientation z axis x value
+#         */
+#       inline void orientationZaxisXCallback (const float& value)
+#     
+#       /** Callback function for orientation z axis y component.
+#         * param[in] value orientation z axis y value
+#         */
+#       inline void orientationZaxisYCallback (const float& value)
+#       
+#       /** Callback function for orientation z axis z component.
+#         * param[in] value orientation z axis z value
+#         */
+#       inline void orientationZaxisZCallback (const float& value)
+#       
+#       /** Callback function to set the cloud height
+#         * param[in] height cloud height
+#         */
+#       inline void cloudHeightCallback (const int &height)
+# 
+#       /** Callback function to set the cloud width
+#         * param[in] width cloud width
+#         */
+#       inline void cloudWidthCallback (const int &width)
+#         
+#       /** Append a float property to the cloud fields.
+#         * param[in] name property name
+#         * param[in] count property count: 1 for scalar properties and higher for a 
+#         * list property.
+#       void appendFloatProperty (const std::string& name, const size_t& count = 1);
+# 
+#       /** Callback function for the begin of vertex line */
+#       void vertexBeginCallback ();
+# 
+#       /** Callback function for the end of vertex line */
+#       void vertexEndCallback ();
+# 
+#       /** Callback function for the begin of range_grid line */
+#       void rangeGridBeginCallback ();
+# 
+#       /** Callback function for the begin of range_grid vertex_indices property 
+#         * param[in] size vertex_indices list size  
+#         */
+#       void rangeGridVertexIndicesBeginCallback (pcl::io::ply::uint8 size);
+# 
+#       /** Callback function for each range_grid vertex_indices element
+#         * param[in] vertex_index index of the vertex in vertex_indices
+#         */      
+#       void rangeGridVertexIndicesElementCallback (pcl::io::ply::int32 vertex_index);
+# 
+#       /** Callback function for the end of a range_grid vertex_indices property */
+#       void rangeGridVertexIndicesEndCallback ();
+# 
+#       /** Callback function for the end of a range_grid element end */
+#       void rangeGridEndCallback ();
+# 
+#       /** Callback function for obj_info */
+#       void objInfoCallback (const std::string& line);
+# 
+#       /// origin
+#       Eigen::Vector4f origin_;
+#       /// orientation
+#       Eigen::Matrix3f orientation_;
+#       //vertex element artifacts
+#       sensor_msgs::PointCloud2 *cloud_;
+#       size_t vertex_count_, vertex_properties_counter_;
+#       int vertex_offset_before_;
+#       //range element artifacts
+#       std::vector<std::vector <int> > *range_grid_;
+#       size_t range_count_, range_grid_vertex_indices_element_index_;
+#       size_t rgb_offset_before_;
+#     	public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+#   /** \brief Point Cloud Data (PLY) file format writer.
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PLYWriter : public FileWriter
+#   {
+#     public:
+#       ///Constructor
+#       PLYWriter () : FileWriter () {};
+# 
+#       ///Destructor
+#       ~PLYWriter () {};
+# 
+#       /** \brief Generate the header of a PLY v.7 file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] valid_points number of valid points (finite ones for range_grid and
+#         * all of them for camer)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       inline std::string
+#       generateHeaderBinary (const sensor_msgs::PointCloud2 &cloud, 
+#                             const Eigen::Vector4f &origin, 
+#                             const Eigen::Quaternionf &orientation,
+#                             int valid_points,
+#                             bool use_camera = true)
+#       
+#       /** \brief Generate the header of a PLY v.7 file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] valid_points number of valid points (finite ones for range_grid and
+#         * all of them for camer)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       inline std::string
+#       generateHeaderASCII (const sensor_msgs::PointCloud2 &cloud, 
+#                            const Eigen::Vector4f &origin, 
+#                            const Eigen::Quaternionf &orientation,
+#                            int valid_points,
+#                            bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       int 
+#       writeASCII (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                   const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                   const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                   int precision = 8,
+#                   bool use_camera = true);
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         */
+#       int 
+#       writeBinary (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                    const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                    const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              bool binary = false,
+#              bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              bool binary = false,
+#              bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              bool binary = false,
+#              bool use_camera = true)
+#   };
+# 
+#   namespace io
+#   {
+#     /** \brief Load a PLY v.6 file into a templated PointCloud type.
+#       *
+#       * Any PLY files containg sensor data will generate a warning as a
+#       * sensor_msgs/PointCloud2 message cannot hold the sensor origin.
+#       *
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     inline int
+#     loadPLYFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud)
+# 
+#     /** \brief Load any PLY file into a templated PointCloud type.
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \param[in] origin the sensor acquisition origin (only for > PLY_V7 - null if not present)
+#       * \param[in] orientation the sensor acquisition orientation if availble, 
+#       * identity if not present
+#       * \ingroup io
+#       */
+#     inline int
+#     loadPLYFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation)
+# 
+#     /** \brief Load any PLY file into a templated PointCloud type
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     loadPLYFile (const std::string &file_name, pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Save point cloud data to a PLY file containing n-D points
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] origin the sensor data acquisition origin (translation)
+#       * \param[in] orientation the sensor data acquisition origin (rotation)
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     inline int 
+#     savePLYFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                  const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                  const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                  bool binary_mode = false, bool use_camera = true)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file
+#       * containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud, bool binary_mode = false)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file
+#       * containing a specific given cloud format.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFileASCII (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file containing a specific given cloud format.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFileBinary (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] indices the set of indices to save
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     template<typename PointT> int
+#     savePLYFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud,
+#                  const std::vector<int> &indices, bool binary_mode = false)
+#
+#     /** \brief Saves a PolygonMesh in ascii PLY format.
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] mesh the polygonal mesh to save
+#       * \param[in] precision the output ASCII precision default 5
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePLYFile (const std::string &file_name, const pcl::PolygonMesh &mesh, unsigned precision = 5);
+#   }
+###
+
+# tar.h
+# namespace pcl
+# {
+#   namespace io
+#   {
+#     /** \brief A TAR file's header, as described on 
+#       * http://en.wikipedia.org/wiki/Tar_%28file_format%29. 
+#       */
+#     struct TARHeader
+#     {
+#       char file_name[100];
+#       char file_mode[8];
+#       char uid[8];
+#       char gid[8];
+#       char file_size[12];
+#       char mtime[12];
+#       char chksum[8];
+#       char file_type[1];
+#       char link_file_name[100];
+#       char ustar[6];
+#       char ustar_version[2];
+#       char uname[32];
+#       char gname[32];
+#       char dev_major[8];
+#       char dev_minor[8];
+#       char file_name_prefix[155];
+#       char _padding[12];
+# 
+#       unsigned int 
+#       getFileSize ()
+#       {
+#         unsigned int output = 0;
+#         char *str = file_size;
+#         for (int i = 0; i < 11; i++)
+#         {
+#           output = output * 8 + *str - '0';
+#           str++;
+#         }
+#         return (output);
+#       }
+#     };
+#   }
+# }
+###
+
+# vtk_io.h
+# namespace pcl
+# namespace io
+#     /** \brief Saves a PolygonMesh in ascii VTK format. 
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] triangles the polygonal mesh to save
+#       * \param[in] precision the output ASCII precision
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int 
+#     saveVTKFile (const std::string &file_name, const pcl::PolygonMesh &triangles, unsigned precision = 5);
+# 
+#     /** \brief Saves a PointCloud in ascii VTK format. 
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] cloud the point cloud to save
+#       * \param[in] precision the output ASCII precision
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int 
+#     saveVTKFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, unsigned precision = 5);    
+# 
+###
+
+# vtk_lib_io.h
+# namespace pcl
+#   namespace io
+#     /** \brief Convert vtkPolyData object to a PCL PolygonMesh
+#       * \param[in] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#       * \param[out] mesh PCL Polygon Mesh to fill
+#       * \return Number of points in the point cloud of mesh.
+#       */
+#     PCL_EXPORTS int
+#     vtk2mesh (const vtkSmartPointer<vtkPolyData>& poly_data, 
+#               pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Convert a PCL PolygonMesh to a vtkPolyData object
+#       * \param[in] mesh Reference to PCL Polygon Mesh
+#       * \param[out] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#       * \return Number of points in the point cloud of mesh.
+#       */
+#     PCL_EXPORTS int
+#     mesh2vtk (const pcl::PolygonMesh& mesh, 
+#               vtkSmartPointer<vtkPolyData>& poly_data);
+# 
+#     /** \brief Load a \ref PolygonMesh object given an input file name, based on the file extension
+#       * \param[in] file_name the name of the file containing the polygon data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */ 
+#     PCL_EXPORTS int
+#     loadPolygonFile (const std::string &file_name, 
+#                      pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object given an input file name, based on the file extension
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFile (const std::string &file_name, 
+#                      const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load a VTK file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileVTK (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load a PLY file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFilePLY (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load an OBJ file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileOBJ (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load an STL file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileSTL (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into a VTK file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFileVTK (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into a PLY file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFilePLY (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into an STL file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFileSTL (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Write a \ref RangeImagePlanar object to a PNG file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] range_image the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS void
+#     saveRangeImagePlanarFilePNG (const std::string &file_name,
+#                                  const pcl::RangeImagePlanar& range_image);
+# 
+#     /** \brief Convert a pcl::PointCloud object to a VTK PolyData one.
+#       * \param[in] cloud the input pcl::PointCloud object
+#       * \param[out] polydata the resultant VTK PolyData object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     pointCloudTovtkPolyData (const pcl::PointCloud<PointT>& cloud, 
+#                              vtkPolyData* const polydata);
+# 
+#     /** \brief Convert a pcl::PointCloud object to a VTK StructuredGrid one.
+#       * \param[in] cloud the input pcl::PointCloud object
+#       * \param[out] structured_grid the resultant VTK StructuredGrid object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     pointCloudTovtkStructuredGrid (const pcl::PointCloud<PointT>& cloud, 
+#                                    vtkStructuredGrid* const structured_grid);
+# 
+#     /** \brief Convert a VTK PolyData object to a pcl::PointCloud one.
+#       * \param[in] polydata the input VTK PolyData object
+#       * \param[out] cloud the resultant pcl::PointCloud object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     vtkPolyDataToPointCloud (vtkPolyData* const polydata, 
+#                              pcl::PointCloud<PointT>& cloud);
+# 
+#     /** \brief Convert a VTK StructuredGrid object to a pcl::PointCloud one.
+#       * \param[in] structured_grid the input VTK StructuredGrid object
+#       * \param[out] cloud the resultant pcl::PointCloud object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     vtkStructuredGridToPointCloud (vtkStructuredGrid* const structured_grid, 
+#                                    pcl::PointCloud<PointT>& cloud);
+# 
+# 
+###
+
diff --git a/pcl/pcl_io_172.pxd b/pcl/pcl_io_172.pxd
new file mode 100644
index 0000000..6266fe8
--- /dev/null
+++ b/pcl/pcl_io_172.pxd
@@ -0,0 +1,2008 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+
+# from boost_shared_ptr cimport shared_ptr
+
+cdef extern from "pcl/io/pcd_io.h" namespace "pcl::io":
+    # XYZ
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud,
+                    bool binary_mode) nogil except +
+    int savePCDFileASCII (string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFileBinary (string &file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFile (string &file_name, 
+                     cpp.PointCloud[cpp.PointXYZ] &cloud,
+                     vector[int] &indices, 
+                     bool binary_mode) nogil except +
+
+
+    # XYZI
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGB
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGBA
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud,
+                    bool binary_mode) nogil except +
+
+	# PointWithViewpoint
+    int load(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud,
+                    bool binary_mode) nogil except +
+
+cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+    # XYZ
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZI
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGB
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGBA
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud,
+                    bool binary_mode) nogil except +
+
+    # PointWithViewpoint
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud,
+                    bool binary_mode) nogil except +
+
+#http://dev.pointclouds.org/issues/624
+#cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+#    int loadPLYFile (string file_name, PointCloud[cpp.PointXYZ] cloud)
+#    int savePLYFile (string file_name, PointCloud[cpp.PointXYZ] cloud, bool binary_mode)
+
+# cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+
+###
+# file_io.h
+# namespace pcl
+# class PCL_EXPORTS FileReader
+#     public:
+#       /** \brief empty constructor */ 
+#       FileReader() {}
+#       /** \brief empty destructor */ 
+#       virtual ~FileReader() {}
+#       /** \brief Read a point cloud data header from a FILE file. 
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given FILE file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         * Returns:
+#         *  * < 0 (-1) on error
+#         *  * > 0 on success
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[out] origin the sensor acquisition origin (only for > FILE_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > FILE_V7 - identity if not present)
+#         * \param[out] file_version the FILE version of the file (either FILE_V6 or FILE_V7)
+#         * \param[out] data_type the type of data (binary data=1, ascii=0, etc)
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       virtual int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, 
+#                   int &file_version, int &data_type, unsigned int &data_idx, const int offset = 0) = 0;
+# 
+#       /** \brief Read a point cloud data from a FILE file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[out] origin the sensor acquisition origin (only for > FILE_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > FILE_V7 - identity if not present)
+#         * \param[out] file_version the FILE version of the file (either FILE_V6 or FILE_V7)
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       virtual int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &file_version, 
+#             const int offset = 0) = 0;
+# 
+#       /** \brief Read a point cloud data from a FILE file (FILE_V6 only!) and store it into a sensor_msgs/PointCloud2.
+#         * 
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read FILE_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file 
+#         * > FILE_V6 will generate a warning. 
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         *
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0)
+#       {
+#         Eigen::Vector4f origin;
+#         Eigen::Quaternionf orientation;
+#         int file_version;
+#         return (read (file_name, cloud, origin, orientation, file_version, offset));
+#       }
+# 
+#       /** \brief Read a point cloud data from any FILE file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       template<typename PointT> inline int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset  =0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int file_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_, 
+#                         file_version, offset);
+# 
+#         // Exit in case of error
+#         if (res < 0)
+#           return res;
+#         pcl::fromROSMsg (blob, cloud);
+#         return (0);
+#       }
+#   };
+# 
+#   /** \brief Point Cloud Data (FILE) file format writer.
+#     * Any (FILE) format file reader should implement its virtual methodes
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS FileWriter
+#   {
+#     public:
+#       /** \brief Empty constructor */ 
+#       FileWriter () {}
+# 
+#       /** \brief Empty destructor */ 
+#       virtual ~FileWriter () {}
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         */
+#       virtual int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false) = 0;
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         return (write (file_name, *cloud, origin, orientation, binary));
+#       }
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const bool binary = false)
+#       {
+#         Eigen::Vector4f origin = cloud.sensor_origin_;
+#         Eigen::Quaternionf orientation = cloud.sensor_orientation_;
+# 
+#         sensor_msgs::PointCloud2 blob;
+#         pcl::toROSMsg (cloud, blob);
+# 
+#         // Save the data
+#         return (write (file_name, blob, origin, orientation, binary));
+#       }
+#   };
+# 
+#   /** \brief insers a value of type Type (uchar, char, uint, int, float, double, ...) into a stringstream.
+#     *
+#     * If the value is NaN, it inserst "nan".
+#     *
+#     * \param[in] cloud the cloud to copy from
+#     * \param[in] point_index the index of the point
+#     * \param[in] point_size the size of the point in the cloud
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     * \param[out] stream the ostringstream to copy into
+#     */
+#   template <typename Type> inline void
+#   copyValueString (const sensor_msgs::PointCloud2 &cloud, 
+#                    const unsigned int point_index, 
+#                    const int point_size, 
+#                    const unsigned int field_idx, 
+#                    const unsigned int fields_count, 
+#                    std::ostream &stream)
+#   {
+#     Type value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       stream << boost::numeric_cast<Type>(value);
+#   }
+#   template <> inline void
+#   copyValueString<int8_t> (const sensor_msgs::PointCloud2 &cloud, 
+#                            const unsigned int point_index, 
+#                            const int point_size, 
+#                            const unsigned int field_idx, 
+#                            const unsigned int fields_count, 
+#                            std::ostream &stream)
+#   {
+#     int8_t value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (int8_t)], sizeof (int8_t));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       // Numeric cast doesn't give us what we want for int8_t
+#       stream << boost::numeric_cast<int>(value);
+#   }
+#   template <> inline void
+#   copyValueString<uint8_t> (const sensor_msgs::PointCloud2 &cloud, 
+#                             const unsigned int point_index, 
+#                             const int point_size, 
+#                             const unsigned int field_idx, 
+#                             const unsigned int fields_count, 
+#                             std::ostream &stream)
+#   {
+#     uint8_t value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (uint8_t)], sizeof (uint8_t));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       // Numeric cast doesn't give us what we want for uint8_t
+#       stream << boost::numeric_cast<int>(value);
+#   }
+# 
+#   /** \brief Check whether a given value of type Type (uchar, char, uint, int, float, double, ...) is finite or not
+#     *
+#     * \param[in] cloud the cloud that contains the data
+#     * \param[in] point_index the index of the point
+#     * \param[in] point_size the size of the point in the cloud
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     *
+#     * \return true if the value is finite, false otherwise
+#     */
+#   template <typename Type> inline bool
+#   isValueFinite (const sensor_msgs::PointCloud2 &cloud, 
+#                  const unsigned int point_index, 
+#                  const int point_size, 
+#                  const unsigned int field_idx, 
+#                  const unsigned int fields_count)
+#   {
+#     Type value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
+#     if (!pcl_isfinite (value))
+#       return (false);
+#     return (true);
+#   }
+# 
+#   /** \brief Copy one single value of type T (uchar, char, uint, int, float, double, ...) from a string
+#     * 
+#     * Uses aoti/atof to do the conversion.
+#     * Checks if the st is "nan" and converts it accordingly.
+#     *
+#     * \param[in] st the string containing the value to convert and copy
+#     * \param[out] cloud the cloud to copy it to
+#     * \param[in] point_index the index of the point
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     */
+#   template <typename Type> inline void
+#   copyStringValue (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                    unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     Type value;
+#     if (st == "nan")
+#     {
+#       value = std::numeric_limits<Type>::quiet_NaN ();
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> value;
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (Type)], reinterpret_cast<char*> (&value), sizeof (Type));
+#   }
+# 
+#   template <> inline void
+#   copyStringValue<int8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                            unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     int8_t value;
+#     if (st == "nan")
+#     {
+#       value = static_cast<int8_t> (std::numeric_limits<int>::quiet_NaN ());
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       int val;
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> val;
+#       value = static_cast<int8_t> (val);
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (int8_t)], reinterpret_cast<char*> (&value), sizeof (int8_t));
+#   }
+# 
+#   template <> inline void
+#   copyStringValue<uint8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                            unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     uint8_t value;
+#     if (st == "nan")
+#     {
+#       value = static_cast<uint8_t> (std::numeric_limits<int>::quiet_NaN ());
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       int val;
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> val;
+#       value = static_cast<uint8_t> (val);
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (uint8_t)], reinterpret_cast<char*> (&value), sizeof (uint8_t));
+###
+
+# io.h
+# #include <pcl/common/io.h>
+###
+
+# lzf.h
+# namespace pcl
+#   PCL_EXPORTS unsigned int 
+#   lzfCompress (const void *const in_data,  unsigned int in_len,
+#                void             *out_data, unsigned int out_len);
+#   PCL_EXPORTS unsigned int 
+#   lzfDecompress (const void *const in_data,  unsigned int in_len,
+#                  void             *out_data, unsigned int out_len);
+###
+
+# obj_io.h
+# namespace pcl
+#   namespace io
+#     PCL_EXPORTS int
+#     saveOBJFile (const std::string &file_name, 
+#                  const pcl::TextureMesh &tex_mesh, 
+#                  unsigned precision = 5);
+# 
+#     PCL_EXPORTS int
+#     saveOBJFile (const std::string &file_name, 
+#                  const pcl::PolygonMesh &mesh, 
+#                  unsigned precision = 5);
+# 
+###
+
+# pcd_io.h
+# namespace pcl
+# {
+#   /** \brief Point Cloud Data (PCD) file format reader.
+#     * \author Radu Bogdan Rusu
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PCDReader : public FileReader
+#   {
+#     public:
+#       /** Empty constructor */      
+#       PCDReader () : FileReader () {}
+#       /** Empty destructor */      
+#       ~PCDReader () {}
+#       /** \brief Various PCD file versions.
+#         *
+#         * PCD_V6 represents PCD files with version 0.6, which contain the following fields:
+#         *   - lines beginning with # are treated as comments
+#         *   - FIELDS ...
+#         *   - SIZE ...
+#         *   - TYPE ...
+#         *   - COUNT ...
+#         *   - WIDTH ...
+#         *   - HEIGHT ...
+#         *   - POINTS ...
+#         *   - DATA ascii/binary
+#         * 
+#         * Everything that follows \b DATA is intepreted as data points and
+#         * will be read accordingly.
+#         *
+#         * PCD_V7 represents PCD files with version 0.7 and has an important
+#         * addon: it adds sensor origin/orientation (aka viewpoint) information
+#         * to a dataset through the use of a new header field:
+#         *   - VIEWPOINT tx ty tz qw qx qy qz
+#         */
+#       enum
+#       {
+#         PCD_V6 = 0,
+#         PCD_V7 = 1
+#       };
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > PCD_V7 - identity if not present)
+#         * \param[out] pcd_version the PCD version of the file (i.e., PCD_V6, PCD_V7)
+#         * \param[out] data_type the type of data (0 = ASCII, 1 = Binary, 2 = Binary compressed) 
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version,
+#                   int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the properties will be filled)
+#         * \param[out] pcd_version the PCD version of the file (either PCD_V6 or PCD_V7)
+#         * \param[out] data_type the type of data (0 = ASCII, 1 = Binary, 2 = Binary compressed) 
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         *
+#         */
+#       int 
+#       readHeaderEigen (const std::string &file_name, pcl::PointCloud<Eigen::MatrixXf> &cloud,
+#                        int &pcd_version, int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PCD file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > PCD_V7 - identity if not present)
+#         * \param[out] pcd_version the PCD version of the file (either PCD_V6 or PCD_V7)
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PCD (PCD_V6) and store it into a sensor_msgs/PointCloud2.
+#         * 
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read PCD_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file 
+#         * > PCD_V6 will generate a warning. 
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from any PCD file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       template<typename PointT> int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset = 0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int pcd_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_, 
+#                         pcd_version, offset);
+# 
+#         // If no error, convert the data
+#         if (res == 0)
+#           pcl::fromROSMsg (blob, cloud);
+#         return (res);
+#       }
+# 
+#       /** \brief Read a point cloud data from any PCD file, and convert it to a pcl::PointCloud<Eigen::MatrixXf> format.
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int
+#       readEigen (const std::string &file_name, pcl::PointCloud<Eigen::MatrixXf> &cloud, const int offset = 0);
+#   };
+# 
+#   /** \brief Point Cloud Data (PCD) file format writer.
+#     * \author Radu Bogdan Rusu
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PCDWriter : public FileWriter
+#   {
+#     public:
+#       PCDWriter() : FileWriter(), map_synchronization_(false) {}
+#       ~PCDWriter() {}
+# 
+#       /** \brief Set whether mmap() synchornization via msync() is desired before munmap() calls. 
+#         * Setting this to true could prevent NFS data loss (see
+#         * http://www.pcl-developers.org/PCD-IO-consistency-on-NFS-msync-needed-td4885942.html).
+#         * Default: false
+#         * \note This option should be used by advanced users only!
+#         * \note Please note that using msync() on certain systems can reduce the I/O performance by up to 80%!
+#         * \param[in] sync set to true if msync() should be called before munmap()
+#         */
+#       void
+#       setMapSynchronization (bool sync)
+#       {
+#         map_synchronization_ = sync;
+#       }
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderBinary (const sensor_msgs::PointCloud2 &cloud, 
+#                             const Eigen::Vector4f &origin, 
+#                             const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a BINARY_COMPRESSED PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderBinaryCompressed (const sensor_msgs::PointCloud2 &cloud, 
+#                                       const Eigen::Vector4f &origin, 
+#                                       const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderASCII (const sensor_msgs::PointCloud2 &cloud, 
+#                            const Eigen::Vector4f &origin, 
+#                            const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] nr_points if given, use this to fill in WIDTH, HEIGHT (=1), and POINTS in the header
+#         * By default, nr_points is set to INTMAX, and the data in the header is used instead.
+#         */
+#       template <typename PointT> static std::string
+#       generateHeader (const pcl::PointCloud<PointT> &cloud, 
+#                       const int nr_points = std::numeric_limits<int>::max ());
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] nr_points if given, use this to fill in WIDTH, HEIGHT (=1), and POINTS in the header
+#         * By default, nr_points is set to INTMAX, and the data in the header is used instead.
+#         */
+#       std::string
+#       generateHeaderEigen (const pcl::PointCloud<Eigen::MatrixXf> &cloud, 
+#                            const int nr_points = std::numeric_limits<int>::max ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         *
+#         * As an intermediary solution, precision 8 is used, which guarantees lossless storage for RGB.
+#         */
+#       int 
+#       writeASCII (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                   const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                   const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       int 
+#       writeBinary (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                    const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                    const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY_COMPRESSED format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       int 
+#       writeBinaryCompressed (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         *
+#         * As an intermediary solution, precision 8 is used, which guarantees lossless storage for RGB.
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary (file_name, cloud, origin, orientation));
+#         else
+#           return (writeASCII (file_name, cloud, origin, orientation, 8));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] binary set to true if the file is to be written in a binary PCD format, 
+#         * false (default) for ASCII
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         return (write (file_name, *cloud, origin, orientation, binary));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       template <typename PointT> int 
+#       writeBinary (const std::string &file_name, 
+#                    const pcl::PointCloud<PointT> &cloud);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data
+#         */
+#       int 
+#       writeBinaryEigen (const std::string &file_name, 
+#                         const pcl::PointCloud<Eigen::MatrixXf> &cloud);
+# 
+#       /** \brief Save point cloud data to a binary comprssed PCD file
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       template <typename PointT> int 
+#       writeBinaryCompressed (const std::string &file_name, 
+#                              const pcl::PointCloud<PointT> &cloud);
+# 
+#       /** \brief Save point cloud data to a binary comprssed PCD file.
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       int 
+#       writeBinaryCompressedEigen (const std::string &file_name, 
+#                                   const pcl::PointCloud<Eigen::MatrixXf> &cloud);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] indices the set of point indices that we want written to disk
+#         */
+#       template <typename PointT> int 
+#       writeBinary (const std::string &file_name, 
+#                    const pcl::PointCloud<PointT> &cloud, 
+#                    const std::vector<int> &indices);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       template <typename PointT> int 
+#       writeASCII (const std::string &file_name, 
+#                   const pcl::PointCloud<PointT> &cloud,
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       int 
+#       writeASCIIEigen (const std::string &file_name, 
+#                        const pcl::PointCloud<Eigen::MatrixXf> &cloud,
+#                        const int precision = 8);
+# 
+#        /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] indices the set of point indices that we want written to disk
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       template <typename PointT> int 
+#       writeASCII (const std::string &file_name, 
+#                   const pcl::PointCloud<PointT> &cloud,
+#                   const std::vector<int> &indices,
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary<PointT> (file_name, cloud));
+#         else
+#           return (writeASCII<PointT> (file_name, cloud));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] indices the set of point indices that we want written to disk
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const std::vector<int> &indices,
+#              bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary<PointT> (file_name, cloud, indices));
+#         else
+#           return (writeASCII<PointT> (file_name, cloud, indices));
+#       }
+# 
+#     private:
+#       /** \brief Set to true if msync() should be called before munmap(). Prevents data loss on NFS systems. */
+#       bool map_synchronization_;
+# 
+#       typedef std::pair<std::string, pcl::ChannelProperties> pair_channel_properties;
+#       /** \brief Internal structure used to sort the ChannelProperties in the
+#         * cloud.channels map based on their offset. 
+#         */
+#       struct ChannelPropertiesComparator
+#       {
+#         bool 
+#         operator()(const pair_channel_properties &lhs, const pair_channel_properties &rhs) 
+#         {
+#           return (lhs.second.offset < rhs.second.offset);
+#         }
+#       };
+#   };
+# 
+#   namespace io
+#   {
+#     /** \brief Load a PCD v.6 file into a templated PointCloud type.
+#       * 
+#       * Any PCD files > v.6 will generate a warning as a
+#       * sensor_msgs/PointCloud2 message cannot hold the sensor origin.
+#       *
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     inline int 
+#     loadPCDFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud)
+#     {
+#       pcl::PCDReader p;
+#       return (p.read (file_name, cloud));
+#     }
+# 
+#     /** \brief Load any PCD file into a templated PointCloud type.
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#       * \param[out] orientation the sensor acquisition orientation (only for >
+#       * PCD_V7 - identity if not present)
+#       * \ingroup io
+#       */
+#     inline int 
+#     loadPCDFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation)
+#     {
+#       pcl::PCDReader p;
+#       int pcd_version;
+#       return (p.read (file_name, cloud, origin, orientation, pcd_version));
+#     }
+# 
+#     /** \brief Load any PCD file into a templated PointCloud type
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     loadPCDFile (const std::string &file_name, pcl::PointCloud<PointT> &cloud)
+#     {
+#       pcl::PCDReader p;
+#       return (p.read (file_name, cloud));
+#     }
+# 
+#     /** \brief Save point cloud data to a PCD file containing n-D points
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] origin the sensor acquisition origin
+#       * \param[in] orientation the sensor acquisition orientation
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     inline int 
+#     savePCDFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                  const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                  const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                  const bool binary_mode = false)
+#     {
+#       PCDWriter w;
+#       return (w.write (file_name, cloud, origin, orientation, binary_mode));
+#     }
+# 
+#     /** \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud, bool binary_mode = false)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, binary_mode));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format.
+#       *
+#       *      This version is to retain backwards compatibility.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFileASCII (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, false));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format.
+#       *
+#       *      This version is to retain backwards compatibility.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFileBinary (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, true));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format
+#       *
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] indices the set of indices to save
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> int
+#     savePCDFile (const std::string &file_name, 
+#                  const pcl::PointCloud<PointT> &cloud,
+#                  const std::vector<int> &indices, 
+#                  const bool binary_mode = false)
+#     {
+#       // Save the data
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, indices, binary_mode));
+#     }
+#  }
+###
+
+# pcl_io_exception.h
+# namespace pcl
+# {
+#   /** \brief Base exception class for I/O operations
+#     * \ingroup io
+#     */
+#   class PCLIOException : public PCLException
+#   {
+#     public:
+#       /** \brief Constructor
+#         * \param[in] error_description a string describing the error
+#         * \param[in] file_name the name of the file where the exception was caused
+#         * \param[in] function_name the name of the method where the exception was caused
+#         * \param[in] line_number the number of the line where the exception was caused
+#         */
+#       PCLIOException (const std::string& error_description,
+#                       const std::string& file_name = "",
+#                       const std::string& function_name = "",
+#                       unsigned line_number = 0)
+#       : PCLException (error_description, file_name, function_name, line_number)
+#       {
+#       }
+#   };
+# 
+#   /** \brief
+#     * \param[in] function_name the name of the method where the exception was caused
+#     * \param[in] file_name the name of the file where the exception was caused
+#     * \param[in] line_number the number of the line where the exception was caused
+#     * \param[in] format printf format
+#     * \ingroup io
+#     */
+#   inline void 
+#   throwPCLIOException (const char* function_name, const char* file_name, unsigned line_number, 
+#                        const char* format, ...)
+#   {
+#     char msg[1024];
+#     va_list args;
+#     va_start (args, format);
+#     vsprintf (msg, format, args);
+# 
+#     throw PCLIOException (msg, file_name, function_name, line_number);
+#   }
+# 
+###
+
+# ply_io.h
+# namespace pcl
+# {
+#   /** \brief Point Cloud Data (PLY) file format reader.
+#     *
+#     * The PLY data format is organized in the following way:
+#     * lines beginning with "comment" are treated as comments
+#     *   - ply
+#     *   - format [ascii|binary_little_endian|binary_big_endian] 1.0
+#     *   - element vertex COUNT
+#     *   - property float x 
+#     *   - property float y 
+#     *   - [property float z] 
+#     *   - [property float normal_x] 
+#     *   - [property float normal_y] 
+#     *   - [property float normal_z] 
+#     *   - [property uchar red] 
+#     *   - [property uchar green] 
+#     *   - [property uchar blue] ...
+#     *   - ascii/binary point coordinates
+#     *   - [element camera 1]
+#     *   - [property float view_px] ...
+#     *   - [element range_grid COUNT]
+#     *   - [property list uchar int vertex_indices]
+#     *   - end header
+#     *
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PLYReader : public FileReader
+#   {
+#     public:
+#       enum
+#       {
+#         PLY_V0 = 0,
+#         PLY_V1 = 1
+#       };
+#       
+#       PLYReader ()
+#         : FileReader ()
+#         , parser_ ()
+#         , origin_ (Eigen::Vector4f::Zero ())
+#         , orientation_ (Eigen::Matrix3f::Zero ())
+#         , cloud_ ()
+#         , vertex_count_ (0)
+#         , vertex_properties_counter_ (0)
+#         , vertex_offset_before_ (0)
+#         , range_grid_ (0)
+#         , range_count_ (0)
+#         , range_grid_vertex_indices_element_index_ (0)
+#         , rgb_offset_before_ (0)
+#       {}
+# 
+#       PLYReader (const PLYReader &p)
+#         : parser_ ()
+#         , origin_ (Eigen::Vector4f::Zero ())
+#         , orientation_ (Eigen::Matrix3f::Zero ())
+#         , cloud_ ()
+#         , vertex_count_ (0)
+#         , vertex_properties_counter_ (0)
+#         , vertex_offset_before_ (0)
+#         , range_grid_ (0)
+#         , range_count_ (0)
+#         , range_grid_vertex_indices_element_index_ (0)
+#         , rgb_offset_before_ (0)
+#       {
+#         *this = p;
+#       }
+# 
+#       PLYReader& operator = (const PLYReader &p)
+# 
+#       ~PLYReader () { delete range_grid_; }
+#       /** \brief Read a point cloud data header from a PLY file.
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PLY file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         * Returns:
+#         *  * < 0 (-1) on error
+#         *  * > 0 on success
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[out] ply_version the PLY version read from the file
+#         * \param[out] data_type the type of PLY data stored in the file
+#         * \param[out] data_idx the data index
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation,
+#                   int &ply_version, int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PLY file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[out] ply_version the PLY version read from the file
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int& ply_version, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PLY file (PLY_V6 only!) and store it into a sensor_msgs/PointCloud2.
+#         *
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read PLY_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file
+#         * > PLY_V6 will generate a warning.
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       inline int read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0)
+# 
+#       /** \brief Read a point cloud data from any PLY file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       template<typename PointT> inline int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset = 0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int ply_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_,
+#                         ply_version, offset);
+# 
+#         // Exit in case of error
+#         if (res < 0)
+#           return (res);
+#         pcl::fromROSMsg (blob, cloud);
+#         return (0);
+#       }
+#       
+#     private:
+#       ::pcl::io::ply::ply_parser parser_;
+# 
+#       bool
+#       parse (const std::string& istream_filename);
+# 
+#       /** \brief Info callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message information message
+#         */
+#       void 
+#       infoCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief Warning callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message warning message
+#         */
+#       void 
+#       warningCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief Error callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message error message
+#         */
+#       void 
+#       errorCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief function called when the keyword element is parsed
+#         * \param[in] element_name element name
+#         * \param[in] count number of instances
+#         */
+#       boost::tuple<boost::function<void ()>, boost::function<void ()> > 
+#       elementDefinitionCallback (const std::string& element_name, std::size_t count);
+#       
+#       bool
+#       endHeaderCallback ();
+# 
+#       /** \brief function called when a scalar property is parsed
+#         * \param[in] element_name element name to which the property belongs
+#         * \param[in] property_name property name
+#         */
+#       template <typename ScalarType> boost::function<void (ScalarType)> 
+#       scalarPropertyDefinitionCallback (const std::string& element_name, const std::string& property_name);
+# 
+#       /** \brief function called when a list property is parsed
+#         * \param[in] element_name element name to which the property belongs
+#         * \param[in] property_name list property name
+#         */
+#       template <typename SizeType, typename ScalarType> 
+#       boost::tuple<boost::function<void (SizeType)>, boost::function<void (ScalarType)>, boost::function<void ()> > 
+#       listPropertyDefinitionCallback (const std::string& element_name, const std::string& property_name);
+#       
+#       /** Callback function for an anonymous vertex float property.
+#         * Writes down a float value in cloud data.
+#         * param[in] value float value parsed
+#         */      
+#       inline void
+#       vertexFloatPropertyCallback (pcl::io::ply::float32 value);
+# 
+#       /** Callback function for vertex RGB color.
+#         * This callback is in charge of packing red green and blue in a single int
+#         * before writing it down in cloud data.
+#         * param[in] color_name color name in {red, green, blue}
+#         * param[in] color value of {red, green, blue} property
+#         */      
+#       inline void
+#       vertexColorCallback (const std::string& color_name, pcl::io::ply::uint8 color);
+# 
+#       /** Callback function for vertex intensity.
+#         * converts intensity from int to float before writing it down in cloud data.
+#         * param[in] intensity
+#         */
+#       inline void vertexIntensityCallback (pcl::io::ply::uint8 intensity);
+#       
+#       /** Callback function for origin x component.
+#         * param[in] value origin x value
+#         */
+#       inline void originXCallback (const float& value)
+#       
+#       /** Callback function for origin y component.
+#         * param[in] value origin y value
+#         */
+#       inline void originYCallback (const float& value)
+# 
+#       /** Callback function for origin z component.
+#         * param[in] value origin z value
+#         */      
+#       inline void originZCallback (const float& value)
+#     
+#       /** Callback function for orientation x axis x component.
+#         * param[in] value orientation x axis x value
+#         */
+#       inline void orientationXaxisXCallback (const float& value)
+#       
+#       /** Callback function for orientation x axis y component.
+#         * param[in] value orientation x axis y value
+#         */
+#       inline void orientationXaxisYCallback (const float& value)
+#       
+#       /** Callback function for orientation x axis z component.
+#         * param[in] value orientation x axis z value
+#         */
+#       inline void orientationXaxisZCallback (const float& value)
+#       
+#       /** Callback function for orientation y axis x component.
+#         * param[in] value orientation y axis x value
+#         */
+#       inline void orientationYaxisXCallback (const float& value)
+#       
+#       /** Callback function for orientation y axis y component.
+#         * param[in] value orientation y axis y value
+#         */
+#       inline void orientationYaxisYCallback (const float& value)
+# 
+#       /** Callback function for orientation y axis z component.
+#         * param[in] value orientation y axis z value
+#         */
+#       inline void orientationYaxisZCallback (const float& value)
+#       
+#       /** Callback function for orientation z axis x component.
+#         * param[in] value orientation z axis x value
+#         */
+#       inline void orientationZaxisXCallback (const float& value)
+#     
+#       /** Callback function for orientation z axis y component.
+#         * param[in] value orientation z axis y value
+#         */
+#       inline void orientationZaxisYCallback (const float& value)
+#       
+#       /** Callback function for orientation z axis z component.
+#         * param[in] value orientation z axis z value
+#         */
+#       inline void orientationZaxisZCallback (const float& value)
+#       
+#       /** Callback function to set the cloud height
+#         * param[in] height cloud height
+#         */
+#       inline void cloudHeightCallback (const int &height)
+# 
+#       /** Callback function to set the cloud width
+#         * param[in] width cloud width
+#         */
+#       inline void cloudWidthCallback (const int &width)
+#         
+#       /** Append a float property to the cloud fields.
+#         * param[in] name property name
+#         * param[in] count property count: 1 for scalar properties and higher for a 
+#         * list property.
+#       void appendFloatProperty (const std::string& name, const size_t& count = 1);
+# 
+#       /** Callback function for the begin of vertex line */
+#       void vertexBeginCallback ();
+# 
+#       /** Callback function for the end of vertex line */
+#       void vertexEndCallback ();
+# 
+#       /** Callback function for the begin of range_grid line */
+#       void rangeGridBeginCallback ();
+# 
+#       /** Callback function for the begin of range_grid vertex_indices property 
+#         * param[in] size vertex_indices list size  
+#         */
+#       void rangeGridVertexIndicesBeginCallback (pcl::io::ply::uint8 size);
+# 
+#       /** Callback function for each range_grid vertex_indices element
+#         * param[in] vertex_index index of the vertex in vertex_indices
+#         */      
+#       void rangeGridVertexIndicesElementCallback (pcl::io::ply::int32 vertex_index);
+# 
+#       /** Callback function for the end of a range_grid vertex_indices property */
+#       void rangeGridVertexIndicesEndCallback ();
+# 
+#       /** Callback function for the end of a range_grid element end */
+#       void rangeGridEndCallback ();
+# 
+#       /** Callback function for obj_info */
+#       void objInfoCallback (const std::string& line);
+# 
+#       /// origin
+#       Eigen::Vector4f origin_;
+#       /// orientation
+#       Eigen::Matrix3f orientation_;
+#       //vertex element artifacts
+#       sensor_msgs::PointCloud2 *cloud_;
+#       size_t vertex_count_, vertex_properties_counter_;
+#       int vertex_offset_before_;
+#       //range element artifacts
+#       std::vector<std::vector <int> > *range_grid_;
+#       size_t range_count_, range_grid_vertex_indices_element_index_;
+#       size_t rgb_offset_before_;
+#     	public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+#   /** \brief Point Cloud Data (PLY) file format writer.
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PLYWriter : public FileWriter
+#   {
+#     public:
+#       ///Constructor
+#       PLYWriter () : FileWriter () {};
+# 
+#       ///Destructor
+#       ~PLYWriter () {};
+# 
+#       /** \brief Generate the header of a PLY v.7 file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] valid_points number of valid points (finite ones for range_grid and
+#         * all of them for camer)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       inline std::string
+#       generateHeaderBinary (const sensor_msgs::PointCloud2 &cloud, 
+#                             const Eigen::Vector4f &origin, 
+#                             const Eigen::Quaternionf &orientation,
+#                             int valid_points,
+#                             bool use_camera = true)
+#       
+#       /** \brief Generate the header of a PLY v.7 file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] valid_points number of valid points (finite ones for range_grid and
+#         * all of them for camer)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       inline std::string
+#       generateHeaderASCII (const sensor_msgs::PointCloud2 &cloud, 
+#                            const Eigen::Vector4f &origin, 
+#                            const Eigen::Quaternionf &orientation,
+#                            int valid_points,
+#                            bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       int 
+#       writeASCII (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                   const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                   const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                   int precision = 8,
+#                   bool use_camera = true);
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         */
+#       int 
+#       writeBinary (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                    const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                    const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              bool binary = false,
+#              bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              bool binary = false,
+#              bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              bool binary = false,
+#              bool use_camera = true)
+#   };
+# 
+#   namespace io
+#   {
+#     /** \brief Load a PLY v.6 file into a templated PointCloud type.
+#       *
+#       * Any PLY files containg sensor data will generate a warning as a
+#       * sensor_msgs/PointCloud2 message cannot hold the sensor origin.
+#       *
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     inline int
+#     loadPLYFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud)
+# 
+#     /** \brief Load any PLY file into a templated PointCloud type.
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \param[in] origin the sensor acquisition origin (only for > PLY_V7 - null if not present)
+#       * \param[in] orientation the sensor acquisition orientation if availble, 
+#       * identity if not present
+#       * \ingroup io
+#       */
+#     inline int
+#     loadPLYFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation)
+# 
+#     /** \brief Load any PLY file into a templated PointCloud type
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     loadPLYFile (const std::string &file_name, pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Save point cloud data to a PLY file containing n-D points
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] origin the sensor data acquisition origin (translation)
+#       * \param[in] orientation the sensor data acquisition origin (rotation)
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     inline int 
+#     savePLYFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                  const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                  const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                  bool binary_mode = false, bool use_camera = true)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file
+#       * containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud, bool binary_mode = false)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file
+#       * containing a specific given cloud format.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFileASCII (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file containing a specific given cloud format.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFileBinary (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] indices the set of indices to save
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     template<typename PointT> int
+#     savePLYFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud,
+#                  const std::vector<int> &indices, bool binary_mode = false)
+#
+#     /** \brief Saves a PolygonMesh in ascii PLY format.
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] mesh the polygonal mesh to save
+#       * \param[in] precision the output ASCII precision default 5
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePLYFile (const std::string &file_name, const pcl::PolygonMesh &mesh, unsigned precision = 5);
+#   }
+###
+
+# tar.h
+# namespace pcl
+# {
+#   namespace io
+#   {
+#     /** \brief A TAR file's header, as described on 
+#       * http://en.wikipedia.org/wiki/Tar_%28file_format%29. 
+#       */
+#     struct TARHeader
+#     {
+#       char file_name[100];
+#       char file_mode[8];
+#       char uid[8];
+#       char gid[8];
+#       char file_size[12];
+#       char mtime[12];
+#       char chksum[8];
+#       char file_type[1];
+#       char link_file_name[100];
+#       char ustar[6];
+#       char ustar_version[2];
+#       char uname[32];
+#       char gname[32];
+#       char dev_major[8];
+#       char dev_minor[8];
+#       char file_name_prefix[155];
+#       char _padding[12];
+# 
+#       unsigned int 
+#       getFileSize ()
+#       {
+#         unsigned int output = 0;
+#         char *str = file_size;
+#         for (int i = 0; i < 11; i++)
+#         {
+#           output = output * 8 + *str - '0';
+#           str++;
+#         }
+#         return (output);
+#       }
+#     };
+#   }
+# }
+###
+
+# vtk_io.h
+# namespace pcl
+# namespace io
+#     /** \brief Saves a PolygonMesh in ascii VTK format. 
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] triangles the polygonal mesh to save
+#       * \param[in] precision the output ASCII precision
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int 
+#     saveVTKFile (const std::string &file_name, const pcl::PolygonMesh &triangles, unsigned precision = 5);
+# 
+#     /** \brief Saves a PointCloud in ascii VTK format. 
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] cloud the point cloud to save
+#       * \param[in] precision the output ASCII precision
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int 
+#     saveVTKFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, unsigned precision = 5);    
+# 
+###
+
+# vtk_lib_io.h
+# namespace pcl
+#   namespace io
+#     /** \brief Convert vtkPolyData object to a PCL PolygonMesh
+#       * \param[in] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#       * \param[out] mesh PCL Polygon Mesh to fill
+#       * \return Number of points in the point cloud of mesh.
+#       */
+#     PCL_EXPORTS int
+#     vtk2mesh (const vtkSmartPointer<vtkPolyData>& poly_data, 
+#               pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Convert a PCL PolygonMesh to a vtkPolyData object
+#       * \param[in] mesh Reference to PCL Polygon Mesh
+#       * \param[out] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#       * \return Number of points in the point cloud of mesh.
+#       */
+#     PCL_EXPORTS int
+#     mesh2vtk (const pcl::PolygonMesh& mesh, 
+#               vtkSmartPointer<vtkPolyData>& poly_data);
+# 
+#     /** \brief Load a \ref PolygonMesh object given an input file name, based on the file extension
+#       * \param[in] file_name the name of the file containing the polygon data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */ 
+#     PCL_EXPORTS int
+#     loadPolygonFile (const std::string &file_name, 
+#                      pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object given an input file name, based on the file extension
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFile (const std::string &file_name, 
+#                      const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load a VTK file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileVTK (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load a PLY file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFilePLY (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load an OBJ file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileOBJ (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load an STL file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileSTL (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into a VTK file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFileVTK (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into a PLY file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFilePLY (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into an STL file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFileSTL (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Write a \ref RangeImagePlanar object to a PNG file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] range_image the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS void
+#     saveRangeImagePlanarFilePNG (const std::string &file_name,
+#                                  const pcl::RangeImagePlanar& range_image);
+# 
+#     /** \brief Convert a pcl::PointCloud object to a VTK PolyData one.
+#       * \param[in] cloud the input pcl::PointCloud object
+#       * \param[out] polydata the resultant VTK PolyData object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     pointCloudTovtkPolyData (const pcl::PointCloud<PointT>& cloud, 
+#                              vtkPolyData* const polydata);
+# 
+#     /** \brief Convert a pcl::PointCloud object to a VTK StructuredGrid one.
+#       * \param[in] cloud the input pcl::PointCloud object
+#       * \param[out] structured_grid the resultant VTK StructuredGrid object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     pointCloudTovtkStructuredGrid (const pcl::PointCloud<PointT>& cloud, 
+#                                    vtkStructuredGrid* const structured_grid);
+# 
+#     /** \brief Convert a VTK PolyData object to a pcl::PointCloud one.
+#       * \param[in] polydata the input VTK PolyData object
+#       * \param[out] cloud the resultant pcl::PointCloud object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     vtkPolyDataToPointCloud (vtkPolyData* const polydata, 
+#                              pcl::PointCloud<PointT>& cloud);
+# 
+#     /** \brief Convert a VTK StructuredGrid object to a pcl::PointCloud one.
+#       * \param[in] structured_grid the input VTK StructuredGrid object
+#       * \param[out] cloud the resultant pcl::PointCloud object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     vtkStructuredGridToPointCloud (vtkStructuredGrid* const structured_grid, 
+#                                    pcl::PointCloud<PointT>& cloud);
+# 
+# 
+###
+
diff --git a/pcl/pcl_io_180.pxd b/pcl/pcl_io_180.pxd
new file mode 100644
index 0000000..6266fe8
--- /dev/null
+++ b/pcl/pcl_io_180.pxd
@@ -0,0 +1,2008 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+
+# from boost_shared_ptr cimport shared_ptr
+
+cdef extern from "pcl/io/pcd_io.h" namespace "pcl::io":
+    # XYZ
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud,
+                    bool binary_mode) nogil except +
+    int savePCDFileASCII (string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFileBinary (string &file_name, cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePCDFile (string &file_name, 
+                     cpp.PointCloud[cpp.PointXYZ] &cloud,
+                     vector[int] &indices, 
+                     bool binary_mode) nogil except +
+
+
+    # XYZI
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGB
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGBA
+    int load(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud,
+                    bool binary_mode) nogil except +
+
+	# PointWithViewpoint
+    int load(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int loadPCDFile(string file_name,
+                    cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int savePCDFile(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud,
+                    bool binary_mode) nogil except +
+
+cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+    # XYZ
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZ] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZ] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZI
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZI] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZI] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGB
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGB] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZRGB] &cloud,
+                    bool binary_mode) nogil except +
+
+    # XYZRGBA
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointXYZRGBA] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointXYZRGBA] &cloud,
+                    bool binary_mode) nogil except +
+
+    # PointWithViewpoint
+    int loadPLYFile(string file_name,
+                    cpp.PointCloud[cpp.PointWithViewpoint] &cloud) nogil except +
+    int savePLYFile(string file_name, cpp.PointCloud[cpp.PointWithViewpoint] &cloud,
+                    bool binary_mode) nogil except +
+
+#http://dev.pointclouds.org/issues/624
+#cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+#    int loadPLYFile (string file_name, PointCloud[cpp.PointXYZ] cloud)
+#    int savePLYFile (string file_name, PointCloud[cpp.PointXYZ] cloud, bool binary_mode)
+
+# cdef extern from "pcl/io/ply_io.h" namespace "pcl::io":
+
+###
+# file_io.h
+# namespace pcl
+# class PCL_EXPORTS FileReader
+#     public:
+#       /** \brief empty constructor */ 
+#       FileReader() {}
+#       /** \brief empty destructor */ 
+#       virtual ~FileReader() {}
+#       /** \brief Read a point cloud data header from a FILE file. 
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given FILE file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         * Returns:
+#         *  * < 0 (-1) on error
+#         *  * > 0 on success
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[out] origin the sensor acquisition origin (only for > FILE_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > FILE_V7 - identity if not present)
+#         * \param[out] file_version the FILE version of the file (either FILE_V6 or FILE_V7)
+#         * \param[out] data_type the type of data (binary data=1, ascii=0, etc)
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       virtual int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, 
+#                   int &file_version, int &data_type, unsigned int &data_idx, const int offset = 0) = 0;
+# 
+#       /** \brief Read a point cloud data from a FILE file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[out] origin the sensor acquisition origin (only for > FILE_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > FILE_V7 - identity if not present)
+#         * \param[out] file_version the FILE version of the file (either FILE_V6 or FILE_V7)
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       virtual int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &file_version, 
+#             const int offset = 0) = 0;
+# 
+#       /** \brief Read a point cloud data from a FILE file (FILE_V6 only!) and store it into a sensor_msgs/PointCloud2.
+#         * 
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read FILE_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file 
+#         * > FILE_V6 will generate a warning. 
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         *
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0)
+#       {
+#         Eigen::Vector4f origin;
+#         Eigen::Quaternionf orientation;
+#         int file_version;
+#         return (read (file_name, cloud, origin, orientation, file_version, offset));
+#       }
+# 
+#       /** \brief Read a point cloud data from any FILE file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       template<typename PointT> inline int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset  =0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int file_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_, 
+#                         file_version, offset);
+# 
+#         // Exit in case of error
+#         if (res < 0)
+#           return res;
+#         pcl::fromROSMsg (blob, cloud);
+#         return (0);
+#       }
+#   };
+# 
+#   /** \brief Point Cloud Data (FILE) file format writer.
+#     * Any (FILE) format file reader should implement its virtual methodes
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS FileWriter
+#   {
+#     public:
+#       /** \brief Empty constructor */ 
+#       FileWriter () {}
+# 
+#       /** \brief Empty destructor */ 
+#       virtual ~FileWriter () {}
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         */
+#       virtual int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false) = 0;
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         return (write (file_name, *cloud, origin, orientation, binary));
+#       }
+# 
+#       /** \brief Save point cloud data to a FILE file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * FILE format, false (default) for ASCII
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const bool binary = false)
+#       {
+#         Eigen::Vector4f origin = cloud.sensor_origin_;
+#         Eigen::Quaternionf orientation = cloud.sensor_orientation_;
+# 
+#         sensor_msgs::PointCloud2 blob;
+#         pcl::toROSMsg (cloud, blob);
+# 
+#         // Save the data
+#         return (write (file_name, blob, origin, orientation, binary));
+#       }
+#   };
+# 
+#   /** \brief insers a value of type Type (uchar, char, uint, int, float, double, ...) into a stringstream.
+#     *
+#     * If the value is NaN, it inserst "nan".
+#     *
+#     * \param[in] cloud the cloud to copy from
+#     * \param[in] point_index the index of the point
+#     * \param[in] point_size the size of the point in the cloud
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     * \param[out] stream the ostringstream to copy into
+#     */
+#   template <typename Type> inline void
+#   copyValueString (const sensor_msgs::PointCloud2 &cloud, 
+#                    const unsigned int point_index, 
+#                    const int point_size, 
+#                    const unsigned int field_idx, 
+#                    const unsigned int fields_count, 
+#                    std::ostream &stream)
+#   {
+#     Type value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       stream << boost::numeric_cast<Type>(value);
+#   }
+#   template <> inline void
+#   copyValueString<int8_t> (const sensor_msgs::PointCloud2 &cloud, 
+#                            const unsigned int point_index, 
+#                            const int point_size, 
+#                            const unsigned int field_idx, 
+#                            const unsigned int fields_count, 
+#                            std::ostream &stream)
+#   {
+#     int8_t value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (int8_t)], sizeof (int8_t));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       // Numeric cast doesn't give us what we want for int8_t
+#       stream << boost::numeric_cast<int>(value);
+#   }
+#   template <> inline void
+#   copyValueString<uint8_t> (const sensor_msgs::PointCloud2 &cloud, 
+#                             const unsigned int point_index, 
+#                             const int point_size, 
+#                             const unsigned int field_idx, 
+#                             const unsigned int fields_count, 
+#                             std::ostream &stream)
+#   {
+#     uint8_t value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (uint8_t)], sizeof (uint8_t));
+#     if (pcl_isnan (value))
+#       stream << "nan";
+#     else
+#       // Numeric cast doesn't give us what we want for uint8_t
+#       stream << boost::numeric_cast<int>(value);
+#   }
+# 
+#   /** \brief Check whether a given value of type Type (uchar, char, uint, int, float, double, ...) is finite or not
+#     *
+#     * \param[in] cloud the cloud that contains the data
+#     * \param[in] point_index the index of the point
+#     * \param[in] point_size the size of the point in the cloud
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     *
+#     * \return true if the value is finite, false otherwise
+#     */
+#   template <typename Type> inline bool
+#   isValueFinite (const sensor_msgs::PointCloud2 &cloud, 
+#                  const unsigned int point_index, 
+#                  const int point_size, 
+#                  const unsigned int field_idx, 
+#                  const unsigned int fields_count)
+#   {
+#     Type value;
+#     memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
+#     if (!pcl_isfinite (value))
+#       return (false);
+#     return (true);
+#   }
+# 
+#   /** \brief Copy one single value of type T (uchar, char, uint, int, float, double, ...) from a string
+#     * 
+#     * Uses aoti/atof to do the conversion.
+#     * Checks if the st is "nan" and converts it accordingly.
+#     *
+#     * \param[in] st the string containing the value to convert and copy
+#     * \param[out] cloud the cloud to copy it to
+#     * \param[in] point_index the index of the point
+#     * \param[in] field_idx the index of the dimension/field
+#     * \param[in] fields_count the current fields count
+#     */
+#   template <typename Type> inline void
+#   copyStringValue (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                    unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     Type value;
+#     if (st == "nan")
+#     {
+#       value = std::numeric_limits<Type>::quiet_NaN ();
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> value;
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (Type)], reinterpret_cast<char*> (&value), sizeof (Type));
+#   }
+# 
+#   template <> inline void
+#   copyStringValue<int8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                            unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     int8_t value;
+#     if (st == "nan")
+#     {
+#       value = static_cast<int8_t> (std::numeric_limits<int>::quiet_NaN ());
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       int val;
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> val;
+#       value = static_cast<int8_t> (val);
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (int8_t)], reinterpret_cast<char*> (&value), sizeof (int8_t));
+#   }
+# 
+#   template <> inline void
+#   copyStringValue<uint8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
+#                            unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
+#   {
+#     uint8_t value;
+#     if (st == "nan")
+#     {
+#       value = static_cast<uint8_t> (std::numeric_limits<int>::quiet_NaN ());
+#       cloud.is_dense = false;
+#     }
+#     else
+#     {
+#       int val;
+#       std::istringstream is (st);
+#       is.imbue (std::locale::classic ());
+#       is >> val;
+#       value = static_cast<uint8_t> (val);
+#     }
+# 
+#     memcpy (&cloud.data[point_index * cloud.point_step + 
+#                         cloud.fields[field_idx].offset + 
+#                         fields_count * sizeof (uint8_t)], reinterpret_cast<char*> (&value), sizeof (uint8_t));
+###
+
+# io.h
+# #include <pcl/common/io.h>
+###
+
+# lzf.h
+# namespace pcl
+#   PCL_EXPORTS unsigned int 
+#   lzfCompress (const void *const in_data,  unsigned int in_len,
+#                void             *out_data, unsigned int out_len);
+#   PCL_EXPORTS unsigned int 
+#   lzfDecompress (const void *const in_data,  unsigned int in_len,
+#                  void             *out_data, unsigned int out_len);
+###
+
+# obj_io.h
+# namespace pcl
+#   namespace io
+#     PCL_EXPORTS int
+#     saveOBJFile (const std::string &file_name, 
+#                  const pcl::TextureMesh &tex_mesh, 
+#                  unsigned precision = 5);
+# 
+#     PCL_EXPORTS int
+#     saveOBJFile (const std::string &file_name, 
+#                  const pcl::PolygonMesh &mesh, 
+#                  unsigned precision = 5);
+# 
+###
+
+# pcd_io.h
+# namespace pcl
+# {
+#   /** \brief Point Cloud Data (PCD) file format reader.
+#     * \author Radu Bogdan Rusu
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PCDReader : public FileReader
+#   {
+#     public:
+#       /** Empty constructor */      
+#       PCDReader () : FileReader () {}
+#       /** Empty destructor */      
+#       ~PCDReader () {}
+#       /** \brief Various PCD file versions.
+#         *
+#         * PCD_V6 represents PCD files with version 0.6, which contain the following fields:
+#         *   - lines beginning with # are treated as comments
+#         *   - FIELDS ...
+#         *   - SIZE ...
+#         *   - TYPE ...
+#         *   - COUNT ...
+#         *   - WIDTH ...
+#         *   - HEIGHT ...
+#         *   - POINTS ...
+#         *   - DATA ascii/binary
+#         * 
+#         * Everything that follows \b DATA is intepreted as data points and
+#         * will be read accordingly.
+#         *
+#         * PCD_V7 represents PCD files with version 0.7 and has an important
+#         * addon: it adds sensor origin/orientation (aka viewpoint) information
+#         * to a dataset through the use of a new header field:
+#         *   - VIEWPOINT tx ty tz qw qx qy qz
+#         */
+#       enum
+#       {
+#         PCD_V6 = 0,
+#         PCD_V7 = 1
+#       };
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > PCD_V7 - identity if not present)
+#         * \param[out] pcd_version the PCD version of the file (i.e., PCD_V6, PCD_V7)
+#         * \param[out] data_type the type of data (0 = ASCII, 1 = Binary, 2 = Binary compressed) 
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version,
+#                   int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data header from a PCD file. 
+#         *
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PCD file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         *
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the properties will be filled)
+#         * \param[out] pcd_version the PCD version of the file (either PCD_V6 or PCD_V7)
+#         * \param[out] data_type the type of data (0 = ASCII, 1 = Binary, 2 = Binary compressed) 
+#         * \param[out] data_idx the offset of cloud data within the file
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         *
+#         */
+#       int 
+#       readHeaderEigen (const std::string &file_name, pcl::PointCloud<Eigen::MatrixXf> &cloud,
+#                        int &pcd_version, int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PCD file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#         * \param[out] orientation the sensor acquisition orientation (only for > PCD_V7 - identity if not present)
+#         * \param[out] pcd_version the PCD version of the file (either PCD_V6 or PCD_V7)
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PCD (PCD_V6) and store it into a sensor_msgs/PointCloud2.
+#         * 
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read PCD_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file 
+#         * > PCD_V6 will generate a warning. 
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int 
+#       read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from any PCD file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       template<typename PointT> int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset = 0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int pcd_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_, 
+#                         pcd_version, offset);
+# 
+#         // If no error, convert the data
+#         if (res == 0)
+#           pcl::fromROSMsg (blob, cloud);
+#         return (res);
+#       }
+# 
+#       /** \brief Read a point cloud data from any PCD file, and convert it to a pcl::PointCloud<Eigen::MatrixXf> format.
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset of where to expect the PCD Header in the
+#         * file (optional parameter). One usage example for setting the offset
+#         * parameter is for reading data from a TAR "archive containing multiple
+#         * PCD files: TAR files always add a 512 byte header in front of the
+#         * actual file, so set the offset to the next byte after the header
+#         * (e.g., 513).
+#         *
+#         * \return
+#         *  * < 0 (-1) on error
+#         *  * == 0 on success
+#         */
+#       int
+#       readEigen (const std::string &file_name, pcl::PointCloud<Eigen::MatrixXf> &cloud, const int offset = 0);
+#   };
+# 
+#   /** \brief Point Cloud Data (PCD) file format writer.
+#     * \author Radu Bogdan Rusu
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PCDWriter : public FileWriter
+#   {
+#     public:
+#       PCDWriter() : FileWriter(), map_synchronization_(false) {}
+#       ~PCDWriter() {}
+# 
+#       /** \brief Set whether mmap() synchornization via msync() is desired before munmap() calls. 
+#         * Setting this to true could prevent NFS data loss (see
+#         * http://www.pcl-developers.org/PCD-IO-consistency-on-NFS-msync-needed-td4885942.html).
+#         * Default: false
+#         * \note This option should be used by advanced users only!
+#         * \note Please note that using msync() on certain systems can reduce the I/O performance by up to 80%!
+#         * \param[in] sync set to true if msync() should be called before munmap()
+#         */
+#       void
+#       setMapSynchronization (bool sync)
+#       {
+#         map_synchronization_ = sync;
+#       }
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderBinary (const sensor_msgs::PointCloud2 &cloud, 
+#                             const Eigen::Vector4f &origin, 
+#                             const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a BINARY_COMPRESSED PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderBinaryCompressed (const sensor_msgs::PointCloud2 &cloud, 
+#                                       const Eigen::Vector4f &origin, 
+#                                       const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       std::string
+#       generateHeaderASCII (const sensor_msgs::PointCloud2 &cloud, 
+#                            const Eigen::Vector4f &origin, 
+#                            const Eigen::Quaternionf &orientation);
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] nr_points if given, use this to fill in WIDTH, HEIGHT (=1), and POINTS in the header
+#         * By default, nr_points is set to INTMAX, and the data in the header is used instead.
+#         */
+#       template <typename PointT> static std::string
+#       generateHeader (const pcl::PointCloud<PointT> &cloud, 
+#                       const int nr_points = std::numeric_limits<int>::max ());
+# 
+#       /** \brief Generate the header of a PCD file format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] nr_points if given, use this to fill in WIDTH, HEIGHT (=1), and POINTS in the header
+#         * By default, nr_points is set to INTMAX, and the data in the header is used instead.
+#         */
+#       std::string
+#       generateHeaderEigen (const pcl::PointCloud<Eigen::MatrixXf> &cloud, 
+#                            const int nr_points = std::numeric_limits<int>::max ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         *
+#         * As an intermediary solution, precision 8 is used, which guarantees lossless storage for RGB.
+#         */
+#       int 
+#       writeASCII (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                   const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                   const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       int 
+#       writeBinary (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                    const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                    const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY_COMPRESSED format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         */
+#       int 
+#       writeBinaryCompressed (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         *
+#         * As an intermediary solution, precision 8 is used, which guarantees lossless storage for RGB.
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary (file_name, cloud, origin, orientation));
+#         else
+#           return (writeASCII (file_name, cloud, origin, orientation, 8));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] binary set to true if the file is to be written in a binary PCD format, 
+#         * false (default) for ASCII
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+#       {
+#         return (write (file_name, *cloud, origin, orientation, binary));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       template <typename PointT> int 
+#       writeBinary (const std::string &file_name, 
+#                    const pcl::PointCloud<PointT> &cloud);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data
+#         */
+#       int 
+#       writeBinaryEigen (const std::string &file_name, 
+#                         const pcl::PointCloud<Eigen::MatrixXf> &cloud);
+# 
+#       /** \brief Save point cloud data to a binary comprssed PCD file
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       template <typename PointT> int 
+#       writeBinaryCompressed (const std::string &file_name, 
+#                              const pcl::PointCloud<PointT> &cloud);
+# 
+#       /** \brief Save point cloud data to a binary comprssed PCD file.
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         */
+#       int 
+#       writeBinaryCompressedEigen (const std::string &file_name, 
+#                                   const pcl::PointCloud<Eigen::MatrixXf> &cloud);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] indices the set of point indices that we want written to disk
+#         */
+#       template <typename PointT> int 
+#       writeBinary (const std::string &file_name, 
+#                    const pcl::PointCloud<PointT> &cloud, 
+#                    const std::vector<int> &indices);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       template <typename PointT> int 
+#       writeASCII (const std::string &file_name, 
+#                   const pcl::PointCloud<PointT> &cloud,
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \note This version is specialized for PointCloud<Eigen::MatrixXf> data types. 
+#         * \attention The PCD data is \b always stored in ROW major format! The
+#         * read/write PCD methods will detect column major input and automatically convert it.
+#         *
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       int 
+#       writeASCIIEigen (const std::string &file_name, 
+#                        const pcl::PointCloud<Eigen::MatrixXf> &cloud,
+#                        const int precision = 8);
+# 
+#        /** \brief Save point cloud data to a PCD file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] indices the set of point indices that we want written to disk
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         */
+#       template <typename PointT> int 
+#       writeASCII (const std::string &file_name, 
+#                   const pcl::PointCloud<PointT> &cloud,
+#                   const std::vector<int> &indices,
+#                   const int precision = 8);
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary<PointT> (file_name, cloud));
+#         else
+#           return (writeASCII<PointT> (file_name, cloud));
+#       }
+# 
+#       /** \brief Save point cloud data to a PCD file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] indices the set of point indices that we want written to disk
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PCD format, false (default) for ASCII
+#         *
+#         * Caution: PointCloud structures containing an RGB field have
+#         * traditionally used packed float values to store RGB data. Storing a
+#         * float as ASCII can introduce variations to the smallest bits, and
+#         * thus significantly alter the data. This is a known issue, and the fix
+#         * involves switching RGB data to be stored as a packed integer in
+#         * future versions of PCL.
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              const std::vector<int> &indices,
+#              bool binary = false)
+#       {
+#         if (binary)
+#           return (writeBinary<PointT> (file_name, cloud, indices));
+#         else
+#           return (writeASCII<PointT> (file_name, cloud, indices));
+#       }
+# 
+#     private:
+#       /** \brief Set to true if msync() should be called before munmap(). Prevents data loss on NFS systems. */
+#       bool map_synchronization_;
+# 
+#       typedef std::pair<std::string, pcl::ChannelProperties> pair_channel_properties;
+#       /** \brief Internal structure used to sort the ChannelProperties in the
+#         * cloud.channels map based on their offset. 
+#         */
+#       struct ChannelPropertiesComparator
+#       {
+#         bool 
+#         operator()(const pair_channel_properties &lhs, const pair_channel_properties &rhs) 
+#         {
+#           return (lhs.second.offset < rhs.second.offset);
+#         }
+#       };
+#   };
+# 
+#   namespace io
+#   {
+#     /** \brief Load a PCD v.6 file into a templated PointCloud type.
+#       * 
+#       * Any PCD files > v.6 will generate a warning as a
+#       * sensor_msgs/PointCloud2 message cannot hold the sensor origin.
+#       *
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     inline int 
+#     loadPCDFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud)
+#     {
+#       pcl::PCDReader p;
+#       return (p.read (file_name, cloud));
+#     }
+# 
+#     /** \brief Load any PCD file into a templated PointCloud type.
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \param[out] origin the sensor acquisition origin (only for > PCD_V7 - null if not present)
+#       * \param[out] orientation the sensor acquisition orientation (only for >
+#       * PCD_V7 - identity if not present)
+#       * \ingroup io
+#       */
+#     inline int 
+#     loadPCDFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation)
+#     {
+#       pcl::PCDReader p;
+#       int pcd_version;
+#       return (p.read (file_name, cloud, origin, orientation, pcd_version));
+#     }
+# 
+#     /** \brief Load any PCD file into a templated PointCloud type
+#       * \param[in] file_name the name of the file to load
+#       * \param[out] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     loadPCDFile (const std::string &file_name, pcl::PointCloud<PointT> &cloud)
+#     {
+#       pcl::PCDReader p;
+#       return (p.read (file_name, cloud));
+#     }
+# 
+#     /** \brief Save point cloud data to a PCD file containing n-D points
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] origin the sensor acquisition origin
+#       * \param[in] orientation the sensor acquisition orientation
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     inline int 
+#     savePCDFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                  const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                  const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                  const bool binary_mode = false)
+#     {
+#       PCDWriter w;
+#       return (w.write (file_name, cloud, origin, orientation, binary_mode));
+#     }
+# 
+#     /** \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud, bool binary_mode = false)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, binary_mode));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format.
+#       *
+#       *      This version is to retain backwards compatibility.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFileASCII (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, false));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format.
+#       *
+#       *      This version is to retain backwards compatibility.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePCDFileBinary (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+#     {
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, true));
+#     }
+# 
+#     /** 
+#       * \brief Templated version for saving point cloud data to a PCD file
+#       * containing a specific given cloud format
+#       *
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] indices the set of indices to save
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       *
+#       * Caution: PointCloud structures containing an RGB field have
+#       * traditionally used packed float values to store RGB data. Storing a
+#       * float as ASCII can introduce variations to the smallest bits, and
+#       * thus significantly alter the data. This is a known issue, and the fix
+#       * involves switching RGB data to be stored as a packed integer in
+#       * future versions of PCL.
+#       * \ingroup io
+#       */
+#     template<typename PointT> int
+#     savePCDFile (const std::string &file_name, 
+#                  const pcl::PointCloud<PointT> &cloud,
+#                  const std::vector<int> &indices, 
+#                  const bool binary_mode = false)
+#     {
+#       // Save the data
+#       PCDWriter w;
+#       return (w.write<PointT> (file_name, cloud, indices, binary_mode));
+#     }
+#  }
+###
+
+# pcl_io_exception.h
+# namespace pcl
+# {
+#   /** \brief Base exception class for I/O operations
+#     * \ingroup io
+#     */
+#   class PCLIOException : public PCLException
+#   {
+#     public:
+#       /** \brief Constructor
+#         * \param[in] error_description a string describing the error
+#         * \param[in] file_name the name of the file where the exception was caused
+#         * \param[in] function_name the name of the method where the exception was caused
+#         * \param[in] line_number the number of the line where the exception was caused
+#         */
+#       PCLIOException (const std::string& error_description,
+#                       const std::string& file_name = "",
+#                       const std::string& function_name = "",
+#                       unsigned line_number = 0)
+#       : PCLException (error_description, file_name, function_name, line_number)
+#       {
+#       }
+#   };
+# 
+#   /** \brief
+#     * \param[in] function_name the name of the method where the exception was caused
+#     * \param[in] file_name the name of the file where the exception was caused
+#     * \param[in] line_number the number of the line where the exception was caused
+#     * \param[in] format printf format
+#     * \ingroup io
+#     */
+#   inline void 
+#   throwPCLIOException (const char* function_name, const char* file_name, unsigned line_number, 
+#                        const char* format, ...)
+#   {
+#     char msg[1024];
+#     va_list args;
+#     va_start (args, format);
+#     vsprintf (msg, format, args);
+# 
+#     throw PCLIOException (msg, file_name, function_name, line_number);
+#   }
+# 
+###
+
+# ply_io.h
+# namespace pcl
+# {
+#   /** \brief Point Cloud Data (PLY) file format reader.
+#     *
+#     * The PLY data format is organized in the following way:
+#     * lines beginning with "comment" are treated as comments
+#     *   - ply
+#     *   - format [ascii|binary_little_endian|binary_big_endian] 1.0
+#     *   - element vertex COUNT
+#     *   - property float x 
+#     *   - property float y 
+#     *   - [property float z] 
+#     *   - [property float normal_x] 
+#     *   - [property float normal_y] 
+#     *   - [property float normal_z] 
+#     *   - [property uchar red] 
+#     *   - [property uchar green] 
+#     *   - [property uchar blue] ...
+#     *   - ascii/binary point coordinates
+#     *   - [element camera 1]
+#     *   - [property float view_px] ...
+#     *   - [element range_grid COUNT]
+#     *   - [property list uchar int vertex_indices]
+#     *   - end header
+#     *
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PLYReader : public FileReader
+#   {
+#     public:
+#       enum
+#       {
+#         PLY_V0 = 0,
+#         PLY_V1 = 1
+#       };
+#       
+#       PLYReader ()
+#         : FileReader ()
+#         , parser_ ()
+#         , origin_ (Eigen::Vector4f::Zero ())
+#         , orientation_ (Eigen::Matrix3f::Zero ())
+#         , cloud_ ()
+#         , vertex_count_ (0)
+#         , vertex_properties_counter_ (0)
+#         , vertex_offset_before_ (0)
+#         , range_grid_ (0)
+#         , range_count_ (0)
+#         , range_grid_vertex_indices_element_index_ (0)
+#         , rgb_offset_before_ (0)
+#       {}
+# 
+#       PLYReader (const PLYReader &p)
+#         : parser_ ()
+#         , origin_ (Eigen::Vector4f::Zero ())
+#         , orientation_ (Eigen::Matrix3f::Zero ())
+#         , cloud_ ()
+#         , vertex_count_ (0)
+#         , vertex_properties_counter_ (0)
+#         , vertex_offset_before_ (0)
+#         , range_grid_ (0)
+#         , range_count_ (0)
+#         , range_grid_vertex_indices_element_index_ (0)
+#         , rgb_offset_before_ (0)
+#       {
+#         *this = p;
+#       }
+# 
+#       PLYReader& operator = (const PLYReader &p)
+# 
+#       ~PLYReader () { delete range_grid_; }
+#       /** \brief Read a point cloud data header from a PLY file.
+#         * Load only the meta information (number of points, their types, etc),
+#         * and not the points themselves, from a given PLY file. Useful for fast
+#         * evaluation of the underlying data structure.
+#         * Returns:
+#         *  * < 0 (-1) on error
+#         *  * > 0 on success
+#         * \param[in] file_name the name of the file to load
+#         * \param[out] cloud the resultant point cloud dataset (only the header will be filled)
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[out] ply_version the PLY version read from the file
+#         * \param[out] data_type the type of PLY data stored in the file
+#         * \param[out] data_idx the data index
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                   Eigen::Vector4f &origin, Eigen::Quaternionf &orientation,
+#                   int &ply_version, int &data_type, unsigned int &data_idx, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PLY file and store it into a sensor_msgs/PointCloud2.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[out] ply_version the PLY version read from the file
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       int read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#             Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int& ply_version, const int offset = 0);
+# 
+#       /** \brief Read a point cloud data from a PLY file (PLY_V6 only!) and store it into a sensor_msgs/PointCloud2.
+#         *
+#         * \note This function is provided for backwards compatibility only and
+#         * it can only read PLY_V6 files correctly, as sensor_msgs::PointCloud2
+#         * does not contain a sensor origin/orientation. Reading any file
+#         * > PLY_V6 will generate a warning.
+#         *
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       inline int read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0)
+# 
+#       /** \brief Read a point cloud data from any PLY file, and convert it to the given template format.
+#         * \param[in] file_name the name of the file containing the actual PointCloud data
+#         * \param[out] cloud the resultant PointCloud message read from disk
+#         * \param[in] offset the offset in the file where to expect the true header to begin.
+#         * One usage example for setting the offset parameter is for reading
+#         * data from a TAR "archive containing multiple files: TAR files always
+#         * add a 512 byte header in front of the actual file, so set the offset
+#         * to the next byte after the header (e.g., 513).
+#         */
+#       template<typename PointT> inline int
+#       read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset = 0)
+#       {
+#         sensor_msgs::PointCloud2 blob;
+#         int ply_version;
+#         int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_,
+#                         ply_version, offset);
+# 
+#         // Exit in case of error
+#         if (res < 0)
+#           return (res);
+#         pcl::fromROSMsg (blob, cloud);
+#         return (0);
+#       }
+#       
+#     private:
+#       ::pcl::io::ply::ply_parser parser_;
+# 
+#       bool
+#       parse (const std::string& istream_filename);
+# 
+#       /** \brief Info callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message information message
+#         */
+#       void 
+#       infoCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief Warning callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message warning message
+#         */
+#       void 
+#       warningCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief Error callback function
+#         * \param[in] filename PLY file read
+#         * \param[in] line_number line triggering the callback
+#         * \param[in] message error message
+#         */
+#       void 
+#       errorCallback (const std::string& filename, std::size_t line_number, const std::string& message)
+#       
+#       /** \brief function called when the keyword element is parsed
+#         * \param[in] element_name element name
+#         * \param[in] count number of instances
+#         */
+#       boost::tuple<boost::function<void ()>, boost::function<void ()> > 
+#       elementDefinitionCallback (const std::string& element_name, std::size_t count);
+#       
+#       bool
+#       endHeaderCallback ();
+# 
+#       /** \brief function called when a scalar property is parsed
+#         * \param[in] element_name element name to which the property belongs
+#         * \param[in] property_name property name
+#         */
+#       template <typename ScalarType> boost::function<void (ScalarType)> 
+#       scalarPropertyDefinitionCallback (const std::string& element_name, const std::string& property_name);
+# 
+#       /** \brief function called when a list property is parsed
+#         * \param[in] element_name element name to which the property belongs
+#         * \param[in] property_name list property name
+#         */
+#       template <typename SizeType, typename ScalarType> 
+#       boost::tuple<boost::function<void (SizeType)>, boost::function<void (ScalarType)>, boost::function<void ()> > 
+#       listPropertyDefinitionCallback (const std::string& element_name, const std::string& property_name);
+#       
+#       /** Callback function for an anonymous vertex float property.
+#         * Writes down a float value in cloud data.
+#         * param[in] value float value parsed
+#         */      
+#       inline void
+#       vertexFloatPropertyCallback (pcl::io::ply::float32 value);
+# 
+#       /** Callback function for vertex RGB color.
+#         * This callback is in charge of packing red green and blue in a single int
+#         * before writing it down in cloud data.
+#         * param[in] color_name color name in {red, green, blue}
+#         * param[in] color value of {red, green, blue} property
+#         */      
+#       inline void
+#       vertexColorCallback (const std::string& color_name, pcl::io::ply::uint8 color);
+# 
+#       /** Callback function for vertex intensity.
+#         * converts intensity from int to float before writing it down in cloud data.
+#         * param[in] intensity
+#         */
+#       inline void vertexIntensityCallback (pcl::io::ply::uint8 intensity);
+#       
+#       /** Callback function for origin x component.
+#         * param[in] value origin x value
+#         */
+#       inline void originXCallback (const float& value)
+#       
+#       /** Callback function for origin y component.
+#         * param[in] value origin y value
+#         */
+#       inline void originYCallback (const float& value)
+# 
+#       /** Callback function for origin z component.
+#         * param[in] value origin z value
+#         */      
+#       inline void originZCallback (const float& value)
+#     
+#       /** Callback function for orientation x axis x component.
+#         * param[in] value orientation x axis x value
+#         */
+#       inline void orientationXaxisXCallback (const float& value)
+#       
+#       /** Callback function for orientation x axis y component.
+#         * param[in] value orientation x axis y value
+#         */
+#       inline void orientationXaxisYCallback (const float& value)
+#       
+#       /** Callback function for orientation x axis z component.
+#         * param[in] value orientation x axis z value
+#         */
+#       inline void orientationXaxisZCallback (const float& value)
+#       
+#       /** Callback function for orientation y axis x component.
+#         * param[in] value orientation y axis x value
+#         */
+#       inline void orientationYaxisXCallback (const float& value)
+#       
+#       /** Callback function for orientation y axis y component.
+#         * param[in] value orientation y axis y value
+#         */
+#       inline void orientationYaxisYCallback (const float& value)
+# 
+#       /** Callback function for orientation y axis z component.
+#         * param[in] value orientation y axis z value
+#         */
+#       inline void orientationYaxisZCallback (const float& value)
+#       
+#       /** Callback function for orientation z axis x component.
+#         * param[in] value orientation z axis x value
+#         */
+#       inline void orientationZaxisXCallback (const float& value)
+#     
+#       /** Callback function for orientation z axis y component.
+#         * param[in] value orientation z axis y value
+#         */
+#       inline void orientationZaxisYCallback (const float& value)
+#       
+#       /** Callback function for orientation z axis z component.
+#         * param[in] value orientation z axis z value
+#         */
+#       inline void orientationZaxisZCallback (const float& value)
+#       
+#       /** Callback function to set the cloud height
+#         * param[in] height cloud height
+#         */
+#       inline void cloudHeightCallback (const int &height)
+# 
+#       /** Callback function to set the cloud width
+#         * param[in] width cloud width
+#         */
+#       inline void cloudWidthCallback (const int &width)
+#         
+#       /** Append a float property to the cloud fields.
+#         * param[in] name property name
+#         * param[in] count property count: 1 for scalar properties and higher for a 
+#         * list property.
+#       void appendFloatProperty (const std::string& name, const size_t& count = 1);
+# 
+#       /** Callback function for the begin of vertex line */
+#       void vertexBeginCallback ();
+# 
+#       /** Callback function for the end of vertex line */
+#       void vertexEndCallback ();
+# 
+#       /** Callback function for the begin of range_grid line */
+#       void rangeGridBeginCallback ();
+# 
+#       /** Callback function for the begin of range_grid vertex_indices property 
+#         * param[in] size vertex_indices list size  
+#         */
+#       void rangeGridVertexIndicesBeginCallback (pcl::io::ply::uint8 size);
+# 
+#       /** Callback function for each range_grid vertex_indices element
+#         * param[in] vertex_index index of the vertex in vertex_indices
+#         */      
+#       void rangeGridVertexIndicesElementCallback (pcl::io::ply::int32 vertex_index);
+# 
+#       /** Callback function for the end of a range_grid vertex_indices property */
+#       void rangeGridVertexIndicesEndCallback ();
+# 
+#       /** Callback function for the end of a range_grid element end */
+#       void rangeGridEndCallback ();
+# 
+#       /** Callback function for obj_info */
+#       void objInfoCallback (const std::string& line);
+# 
+#       /// origin
+#       Eigen::Vector4f origin_;
+#       /// orientation
+#       Eigen::Matrix3f orientation_;
+#       //vertex element artifacts
+#       sensor_msgs::PointCloud2 *cloud_;
+#       size_t vertex_count_, vertex_properties_counter_;
+#       int vertex_offset_before_;
+#       //range element artifacts
+#       std::vector<std::vector <int> > *range_grid_;
+#       size_t range_count_, range_grid_vertex_indices_element_index_;
+#       size_t rgb_offset_before_;
+#     	public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+#   /** \brief Point Cloud Data (PLY) file format writer.
+#     * \author Nizar Sallem
+#     * \ingroup io
+#     */
+#   class PCL_EXPORTS PLYWriter : public FileWriter
+#   {
+#     public:
+#       ///Constructor
+#       PLYWriter () : FileWriter () {};
+# 
+#       ///Destructor
+#       ~PLYWriter () {};
+# 
+#       /** \brief Generate the header of a PLY v.7 file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] valid_points number of valid points (finite ones for range_grid and
+#         * all of them for camer)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       inline std::string
+#       generateHeaderBinary (const sensor_msgs::PointCloud2 &cloud, 
+#                             const Eigen::Vector4f &origin, 
+#                             const Eigen::Quaternionf &orientation,
+#                             int valid_points,
+#                             bool use_camera = true)
+#       
+#       /** \brief Generate the header of a PLY v.7 file format
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] valid_points number of valid points (finite ones for range_grid and
+#         * all of them for camer)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       inline std::string
+#       generateHeaderASCII (const sensor_msgs::PointCloud2 &cloud, 
+#                            const Eigen::Vector4f &origin, 
+#                            const Eigen::Quaternionf &orientation,
+#                            int valid_points,
+#                            bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points, in ASCII format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         * \param[in] precision the specified output numeric stream precision (default: 8)
+#         * \param[in] use_camera if set to true then PLY file will use element camera else
+#         * element range_grid will be used.
+#         */
+#       int 
+#       writeASCII (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                   const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                   const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                   int precision = 8,
+#                   bool use_camera = true);
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points, in BINARY format
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor data acquisition origin (translation)
+#         * \param[in] orientation the sensor data acquisition origin (rotation)
+#         */
+#       int 
+#       writeBinary (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud,
+#                    const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                    const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity ());
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              const bool binary = false)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              bool binary = false,
+#              bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the point cloud data message (boost shared pointer)
+#         * \param[in] origin the sensor acquisition origin
+#         * \param[in] orientation the sensor acquisition orientation
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       inline int
+#       write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
+#              const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#              const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#              bool binary = false,
+#              bool use_camera = true)
+# 
+#       /** \brief Save point cloud data to a PLY file containing n-D points
+#         * \param[in] file_name the output file name
+#         * \param[in] cloud the pcl::PointCloud data
+#         * \param[in] binary set to true if the file is to be written in a binary
+#         * PLY format, false (default) for ASCII
+#         * \param[in] use_camera set to true to used camera element and false to
+#         * use range_grid element
+#         */
+#       template<typename PointT> inline int
+#       write (const std::string &file_name, 
+#              const pcl::PointCloud<PointT> &cloud, 
+#              bool binary = false,
+#              bool use_camera = true)
+#   };
+# 
+#   namespace io
+#   {
+#     /** \brief Load a PLY v.6 file into a templated PointCloud type.
+#       *
+#       * Any PLY files containg sensor data will generate a warning as a
+#       * sensor_msgs/PointCloud2 message cannot hold the sensor origin.
+#       *
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     inline int
+#     loadPLYFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud)
+# 
+#     /** \brief Load any PLY file into a templated PointCloud type.
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \param[in] origin the sensor acquisition origin (only for > PLY_V7 - null if not present)
+#       * \param[in] orientation the sensor acquisition orientation if availble, 
+#       * identity if not present
+#       * \ingroup io
+#       */
+#     inline int
+#     loadPLYFile (const std::string &file_name, sensor_msgs::PointCloud2 &cloud,
+#                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation)
+# 
+#     /** \brief Load any PLY file into a templated PointCloud type
+#       * \param[in] file_name the name of the file to load
+#       * \param[in] cloud the resultant templated point cloud
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     loadPLYFile (const std::string &file_name, pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Save point cloud data to a PLY file containing n-D points
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] origin the sensor data acquisition origin (translation)
+#       * \param[in] orientation the sensor data acquisition origin (rotation)
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     inline int 
+#     savePLYFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
+#                  const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
+#                  const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
+#                  bool binary_mode = false, bool use_camera = true)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file
+#       * containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud, bool binary_mode = false)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file
+#       * containing a specific given cloud format.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFileASCII (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file containing a specific given cloud format.
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \ingroup io
+#       */
+#     template<typename PointT> inline int
+#     savePLYFileBinary (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
+# 
+#     /** \brief Templated version for saving point cloud data to a PLY file containing a specific given cloud format
+#       * \param[in] file_name the output file name
+#       * \param[in] cloud the point cloud data message
+#       * \param[in] indices the set of indices to save
+#       * \param[in] binary_mode true for binary mode, false (default) for ASCII
+#       * \ingroup io
+#       */
+#     template<typename PointT> int
+#     savePLYFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud,
+#                  const std::vector<int> &indices, bool binary_mode = false)
+#
+#     /** \brief Saves a PolygonMesh in ascii PLY format.
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] mesh the polygonal mesh to save
+#       * \param[in] precision the output ASCII precision default 5
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePLYFile (const std::string &file_name, const pcl::PolygonMesh &mesh, unsigned precision = 5);
+#   }
+###
+
+# tar.h
+# namespace pcl
+# {
+#   namespace io
+#   {
+#     /** \brief A TAR file's header, as described on 
+#       * http://en.wikipedia.org/wiki/Tar_%28file_format%29. 
+#       */
+#     struct TARHeader
+#     {
+#       char file_name[100];
+#       char file_mode[8];
+#       char uid[8];
+#       char gid[8];
+#       char file_size[12];
+#       char mtime[12];
+#       char chksum[8];
+#       char file_type[1];
+#       char link_file_name[100];
+#       char ustar[6];
+#       char ustar_version[2];
+#       char uname[32];
+#       char gname[32];
+#       char dev_major[8];
+#       char dev_minor[8];
+#       char file_name_prefix[155];
+#       char _padding[12];
+# 
+#       unsigned int 
+#       getFileSize ()
+#       {
+#         unsigned int output = 0;
+#         char *str = file_size;
+#         for (int i = 0; i < 11; i++)
+#         {
+#           output = output * 8 + *str - '0';
+#           str++;
+#         }
+#         return (output);
+#       }
+#     };
+#   }
+# }
+###
+
+# vtk_io.h
+# namespace pcl
+# namespace io
+#     /** \brief Saves a PolygonMesh in ascii VTK format. 
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] triangles the polygonal mesh to save
+#       * \param[in] precision the output ASCII precision
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int 
+#     saveVTKFile (const std::string &file_name, const pcl::PolygonMesh &triangles, unsigned precision = 5);
+# 
+#     /** \brief Saves a PointCloud in ascii VTK format. 
+#       * \param[in] file_name the name of the file to write to disk
+#       * \param[in] cloud the point cloud to save
+#       * \param[in] precision the output ASCII precision
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int 
+#     saveVTKFile (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, unsigned precision = 5);    
+# 
+###
+
+# vtk_lib_io.h
+# namespace pcl
+#   namespace io
+#     /** \brief Convert vtkPolyData object to a PCL PolygonMesh
+#       * \param[in] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#       * \param[out] mesh PCL Polygon Mesh to fill
+#       * \return Number of points in the point cloud of mesh.
+#       */
+#     PCL_EXPORTS int
+#     vtk2mesh (const vtkSmartPointer<vtkPolyData>& poly_data, 
+#               pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Convert a PCL PolygonMesh to a vtkPolyData object
+#       * \param[in] mesh Reference to PCL Polygon Mesh
+#       * \param[out] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#       * \return Number of points in the point cloud of mesh.
+#       */
+#     PCL_EXPORTS int
+#     mesh2vtk (const pcl::PolygonMesh& mesh, 
+#               vtkSmartPointer<vtkPolyData>& poly_data);
+# 
+#     /** \brief Load a \ref PolygonMesh object given an input file name, based on the file extension
+#       * \param[in] file_name the name of the file containing the polygon data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */ 
+#     PCL_EXPORTS int
+#     loadPolygonFile (const std::string &file_name, 
+#                      pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object given an input file name, based on the file extension
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFile (const std::string &file_name, 
+#                      const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load a VTK file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileVTK (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load a PLY file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFilePLY (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load an OBJ file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileOBJ (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Load an STL file into a \ref PolygonMesh object
+#       * \param[in] file_name the name of the file that contains the data
+#       * \param[out] mesh the object that we want to load the data in 
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     loadPolygonFileSTL (const std::string &file_name, 
+#                         pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into a VTK file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFileVTK (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into a PLY file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFilePLY (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Save a \ref PolygonMesh object into an STL file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] mesh the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS int
+#     savePolygonFileSTL (const std::string &file_name, 
+#                         const pcl::PolygonMesh& mesh);
+# 
+#     /** \brief Write a \ref RangeImagePlanar object to a PNG file
+#       * \param[in] file_name the name of the file to save the data to
+#       * \param[in] range_image the object that contains the data
+#       * \ingroup io
+#       */
+#     PCL_EXPORTS void
+#     saveRangeImagePlanarFilePNG (const std::string &file_name,
+#                                  const pcl::RangeImagePlanar& range_image);
+# 
+#     /** \brief Convert a pcl::PointCloud object to a VTK PolyData one.
+#       * \param[in] cloud the input pcl::PointCloud object
+#       * \param[out] polydata the resultant VTK PolyData object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     pointCloudTovtkPolyData (const pcl::PointCloud<PointT>& cloud, 
+#                              vtkPolyData* const polydata);
+# 
+#     /** \brief Convert a pcl::PointCloud object to a VTK StructuredGrid one.
+#       * \param[in] cloud the input pcl::PointCloud object
+#       * \param[out] structured_grid the resultant VTK StructuredGrid object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     pointCloudTovtkStructuredGrid (const pcl::PointCloud<PointT>& cloud, 
+#                                    vtkStructuredGrid* const structured_grid);
+# 
+#     /** \brief Convert a VTK PolyData object to a pcl::PointCloud one.
+#       * \param[in] polydata the input VTK PolyData object
+#       * \param[out] cloud the resultant pcl::PointCloud object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     vtkPolyDataToPointCloud (vtkPolyData* const polydata, 
+#                              pcl::PointCloud<PointT>& cloud);
+# 
+#     /** \brief Convert a VTK StructuredGrid object to a pcl::PointCloud one.
+#       * \param[in] structured_grid the input VTK StructuredGrid object
+#       * \param[out] cloud the resultant pcl::PointCloud object
+#       * \ingroup io
+#       */
+#     template <typename PointT> void
+#     vtkStructuredGridToPointCloud (vtkStructuredGrid* const structured_grid, 
+#                                    pcl::PointCloud<PointT>& cloud);
+# 
+# 
+###
+
diff --git a/pcl/pcl_kdtree.pxd b/pcl/pcl_kdtree.pxd
new file mode 100644
index 0000000..21bf1f8
--- /dev/null
+++ b/pcl/pcl_kdtree.pxd
@@ -0,0 +1,327 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+
+from boost_shared_ptr cimport shared_ptr
+
+# flann.h
+###
+
+# io.h
+# namespace pcl
+# {
+#   /** \brief Get a set of approximate indices for a given point cloud into a reference point cloud. 
+#     * The coordinates of the two point clouds can differ. The method uses an internal KdTree for 
+#     * finding the closest neighbors from \a cloud_in in \a cloud_ref. 
+#     *
+#     * \param[in] cloud_in the input point cloud dataset
+#     * \param[in] cloud_ref the reference point cloud dataset
+#     * \param[out] indices the resultant set of nearest neighbor indices of \a cloud_in in \a cloud_ref
+#     * \ingroup kdtree
+#     */
+#   template <typename PointT> void 
+#   getApproximateIndices (const typename pcl::PointCloud<PointT>::Ptr &cloud_in, 
+#                          const typename pcl::PointCloud<PointT>::Ptr &cloud_ref,
+#                          std::vector<int> &indices);
+# 
+#   /** \brief Get a set of approximate indices for a given point cloud into a reference point cloud. 
+#     * The coordinates of the two point clouds can differ. The method uses an internal KdTree for 
+#     * finding the closest neighbors from \a cloud_in in \a cloud_ref. 
+#     *
+#     * \param[in] cloud_in the input point cloud dataset
+#     * \param[in] cloud_ref the reference point cloud dataset
+#     * \param[out] indices the resultant set of nearest neighbor indices of \a cloud_in in \a cloud_ref
+#     * \ingroup kdtree
+#     */
+#   template <typename Point1T, typename Point2T> void 
+#   getApproximateIndices (const typename pcl::PointCloud<Point1T>::Ptr &cloud_in, 
+#                          const typename pcl::PointCloud<Point2T>::Ptr &cloud_ref,
+#                          std::vector<int> &indices);
+# }
+###
+
+# kdtree.h
+# namespace pcl
+# template <typename PointT>
+# class KdTree
+cdef extern from "pcl/kdtree/kdtree.h" namespace "pcl::search":
+    cdef cppclass KdTree[T]:
+        KdTree()
+        # KdTree (bool sorted)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # public:
+        # typedef boost::shared_ptr <std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr <const std::vector<int> > IndicesConstPtr;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # typedef pcl::PointRepresentation<PointT> PointRepresentation;
+        # //typedef boost::shared_ptr<PointRepresentation> PointRepresentationPtr;
+        # typedef boost::shared_ptr<const PointRepresentation> PointRepresentationConstPtr;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<KdTree<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTree<PointT> > ConstPtr;
+        # /** \brief Empty constructor for KdTree. Sets some internal values to their defaults. 
+        # * \param[in] sorted set to true if the application that the tree will be used for requires sorted nearest neighbor indices (default). False otherwise. 
+        # */
+        # KdTree (bool sorted = true)
+        # /** \brief Provide a pointer to the input dataset.
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # * \param[in] indices the point indices subset that is to be used from \a cloud - if NULL the whole cloud is used
+        # virtual void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        # /** \brief Get a pointer to the vector of indices used. */
+        # inline IndicesConstPtr getIndices () const
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # inline PointCloudConstPtr getInputCloud () const
+        # /** \brief Provide a pointer to the point representation to use to convert points into k-D vectors. 
+        # * \param[in] point_representation the const boost shared pointer to a PointRepresentation
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # /** \brief Get a pointer to the point representation used when converting points into k-D vectors. */
+        # inline PointRepresentationConstPtr getPointRepresentation () const
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        # * \param[in] p_q the given query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # virtual int nearestKSearch (const PointT &p_q, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const = 0;
+        # * \brief Search for k-nearest neighbors for the given query point.
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] cloud the point cloud data
+        # * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for k-nearest neighbors for the given query point. 
+        # * This method accepts a different template parameter for the point type.
+        # * \param[in] point the given query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # template <typename PointTDiff> inline int nearestKSearchT (const PointTDiff &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for k-nearest neighbors for the given query point (zero-copy).
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] index a \a valid index representing a \a valid query point in the dataset given 
+        # * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in 
+        # * the indices vector.
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \param[in] p_q the given query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # virtual int radiusSearch (const PointT &p_q, double radius, std::vector<int> &k_indices,std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const = 0;
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] cloud the point cloud data
+        # * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (const PointCloud &cloud, int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \param[in] point the given query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # template <typename PointTDiff> inline int radiusSearchT (const PointTDiff &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius (zero-copy).
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] index a \a valid index representing a \a valid query point in the dataset given 
+        # * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in 
+        # * the indices vector.
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (int index, double radius, std::vector<int> &k_indices,std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        # * \param[in] eps precision (error bound) for nearest neighbors searches
+        # virtual inline void setEpsilon (float eps)
+        # * \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+        # inline float getEpsilon () const
+        # * \brief Minimum allowed number of k nearest neighbors points that a viable result must contain. 
+        # * \param[in] min_pts the minimum number of neighbors in a viable neighborhood 
+        # inline void setMinPts (int min_pts)
+        # * \brief Get the minimum allowed number of k nearest neighbors points that a viable result must contain. */
+        # inline int getMinPts () const
+
+ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+
+ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+###
+
+# kdtree_flann.h
+# NG
+# cdef cppclass KdTreeFLANN[T](KdTree[T]):
+# namespace pcl
+# template <typename PointT, typename Dist = flann::L2_Simple<float> >
+# class KdTreeFLANN : public pcl::KdTree<PointT>
+cdef extern from "pcl/kdtree/kdtree_flann.h" namespace "pcl":
+    cdef cppclass KdTreeFLANN[T]:
+        KdTreeFLANN()
+        # KdTreeFLANN (bool sorted)
+        # KdTreeFLANN (const KdTreeFLANN<PointT> &k) : 
+        #       inline KdTreeFLANN<PointT>& operator = (const KdTreeFLANN<PointT>& k)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] point a given \a valid (i.e., finite) query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        #   */
+        # int nearestKSearch (cpp.PointCloud[T], int, vector[int], vector[float])
+        # inline define
+        int nearestKSearch (cpp.PointCloud[T], int, int, vector[int], vector[float])
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] point a given \a valid (i.e., finite) query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        #   */
+        # int radiusSearch (cpp.PointCloud[T], double, vector[int], vector[float])
+        # int radiusSearch (cpp.PointCloud[T], double, vector[int], vector[float], unsigned int)
+        # inline define
+        int radiusSearch (cpp.PointCloud[T], int, double, vector[int], vector[float])
+        # int radiusSearch (const PointT &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+
+        # using KdTree<PointT>::input_;
+        # using KdTree<PointT>::indices_;
+        # using KdTree<PointT>::epsilon_;
+        # using KdTree<PointT>::sorted_;
+        # using KdTree<PointT>::point_representation_;
+        # using KdTree<PointT>::nearestKSearch;
+        # using KdTree<PointT>::radiusSearch;
+        # typedef typename KdTree<PointT>::PointCloud PointCloud;
+        # typedef typename KdTree<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # typedef flann::Index<Dist> FLANNIndex;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<KdTreeFLANN<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTreeFLANN<PointT> > ConstPtr;
+        # /** \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        #   * \param[in] eps precision (error bound) for nearest neighbors searches
+        #   */
+        # inline void setEpsilon (float eps)
+        # inline void setSortedResults (bool sorted)
+        # inline Ptr makeShared ()
+###
+
+# template <>
+# class KdTreeFLANN <Eigen::MatrixXf>
+#       public:
+#       typedef pcl::PointCloud<Eigen::MatrixXf> PointCloud;
+#       typedef PointCloud::ConstPtr PointCloudConstPtr;
+#       typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+#       typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+#       typedef flann::Index<flann::L2_Simple<float> > FLANNIndex;
+#       typedef pcl::PointRepresentation<Eigen::MatrixXf> PointRepresentation;
+#       typedef boost::shared_ptr<const PointRepresentation> PointRepresentationConstPtr;
+#       // Boost shared pointers
+#       typedef boost::shared_ptr<KdTreeFLANN<Eigen::MatrixXf> > Ptr;
+#       typedef boost::shared_ptr<const KdTreeFLANN<Eigen::MatrixXf> > ConstPtr;
+# 
+#       KdTreeFLANN (bool sorted = true) : 
+#       KdTreeFLANN (const KdTreeFLANN<Eigen::MatrixXf> &k) : 
+#       inline KdTreeFLANN& operator = (const KdTreeFLANN<Eigen::MatrixXf>& k)
+#       inline void setEpsilon (float eps)
+#       inline Ptr makeShared ()
+#       void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+#       inline IndicesConstPtr getIndices () const
+#       inline PointCloudConstPtr getInputCloud () const
+#       template <typename T> int nearestKSearch (const T &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       inline int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       inline int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       template <typename T> int radiusSearch (const T &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_dists, unsigned int max_nn = 0) const
+#       inline int radiusSearch (const PointCloud &cloud, int index, double radius, 
+#                     std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, 
+#                     unsigned int max_nn = 0) const
+#       inline int radiusSearch (int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+#       /** \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+#       inline float getEpsilon () const
+#       protected:
+#       /** \brief The input point cloud dataset containing the points we need to use. */
+#       PointCloudConstPtr input_;
+#       /** \brief A pointer to the vector of point indices to use. */
+#       IndicesConstPtr indices_;
+#       /** \brief Epsilon precision (error bound) for nearest neighbors searches. */
+#       float epsilon_;
+#       /** \brief Return the radius search neighbours sorted **/
+#       bool sorted_;
+### 
+
+ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+
+###
+
diff --git a/pcl/pcl_kdtree_172.pxd b/pcl/pcl_kdtree_172.pxd
new file mode 100644
index 0000000..f7d4ae0
--- /dev/null
+++ b/pcl/pcl_kdtree_172.pxd
@@ -0,0 +1,331 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+
+from boost_shared_ptr cimport shared_ptr
+
+# flann.h
+###
+
+# io.h
+# namespace pcl
+# {
+#   /** \brief Get a set of approximate indices for a given point cloud into a reference point cloud. 
+#     * The coordinates of the two point clouds can differ. The method uses an internal KdTree for 
+#     * finding the closest neighbors from \a cloud_in in \a cloud_ref. 
+#     *
+#     * \param[in] cloud_in the input point cloud dataset
+#     * \param[in] cloud_ref the reference point cloud dataset
+#     * \param[out] indices the resultant set of nearest neighbor indices of \a cloud_in in \a cloud_ref
+#     * \ingroup kdtree
+#     */
+#   template <typename PointT> void 
+#   getApproximateIndices (const typename pcl::PointCloud<PointT>::Ptr &cloud_in, 
+#                          const typename pcl::PointCloud<PointT>::Ptr &cloud_ref,
+#                          std::vector<int> &indices);
+# 
+#   /** \brief Get a set of approximate indices for a given point cloud into a reference point cloud. 
+#     * The coordinates of the two point clouds can differ. The method uses an internal KdTree for 
+#     * finding the closest neighbors from \a cloud_in in \a cloud_ref. 
+#     *
+#     * \param[in] cloud_in the input point cloud dataset
+#     * \param[in] cloud_ref the reference point cloud dataset
+#     * \param[out] indices the resultant set of nearest neighbor indices of \a cloud_in in \a cloud_ref
+#     * \ingroup kdtree
+#     */
+#   template <typename Point1T, typename Point2T> void 
+#   getApproximateIndices (const typename pcl::PointCloud<Point1T>::Ptr &cloud_in, 
+#                          const typename pcl::PointCloud<Point2T>::Ptr &cloud_ref,
+#                          std::vector<int> &indices);
+# }
+###
+
+# kdtree.h
+# namespace pcl
+# template <typename PointT>
+# class KdTree
+cdef extern from "pcl/kdtree/kdtree.h" namespace "pcl::search":
+    cdef cppclass KdTree[T]:
+        KdTree()
+        # KdTree (bool sorted)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # public:
+        # typedef boost::shared_ptr <std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr <const std::vector<int> > IndicesConstPtr;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # typedef pcl::PointRepresentation<PointT> PointRepresentation;
+        # //typedef boost::shared_ptr<PointRepresentation> PointRepresentationPtr;
+        # typedef boost::shared_ptr<const PointRepresentation> PointRepresentationConstPtr;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<KdTree<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTree<PointT> > ConstPtr;
+        # /** \brief Empty constructor for KdTree. Sets some internal values to their defaults. 
+        # * \param[in] sorted set to true if the application that the tree will be used for requires sorted nearest neighbor indices (default). False otherwise. 
+        # */
+        # KdTree (bool sorted = true)
+        # /** \brief Provide a pointer to the input dataset.
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # * \param[in] indices the point indices subset that is to be used from \a cloud - if NULL the whole cloud is used
+        # virtual void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        # /** \brief Get a pointer to the vector of indices used. */
+        # inline IndicesConstPtr getIndices () const
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # inline PointCloudConstPtr getInputCloud () const
+        # /** \brief Provide a pointer to the point representation to use to convert points into k-D vectors. 
+        # * \param[in] point_representation the const boost shared pointer to a PointRepresentation
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # /** \brief Get a pointer to the point representation used when converting points into k-D vectors. */
+        # inline PointRepresentationConstPtr getPointRepresentation () const
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        # * \param[in] p_q the given query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # virtual int nearestKSearch (const PointT &p_q, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const = 0;
+        # * \brief Search for k-nearest neighbors for the given query point.
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] cloud the point cloud data
+        # * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for k-nearest neighbors for the given query point. 
+        # * This method accepts a different template parameter for the point type.
+        # * \param[in] point the given query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # template <typename PointTDiff> inline int nearestKSearchT (const PointTDiff &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for k-nearest neighbors for the given query point (zero-copy).
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] index a \a valid index representing a \a valid query point in the dataset given 
+        # * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in 
+        # * the indices vector.
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \param[in] p_q the given query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # virtual int radiusSearch (const PointT &p_q, double radius, std::vector<int> &k_indices,std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const = 0;
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] cloud the point cloud data
+        # * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (const PointCloud &cloud, int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \param[in] point the given query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # template <typename PointTDiff> inline int radiusSearchT (const PointTDiff &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius (zero-copy).
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] index a \a valid index representing a \a valid query point in the dataset given 
+        # * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in 
+        # * the indices vector.
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (int index, double radius, std::vector<int> &k_indices,std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        # * \param[in] eps precision (error bound) for nearest neighbors searches
+        # virtual inline void setEpsilon (float eps)
+        # * \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+        # inline float getEpsilon () const
+        # * \brief Minimum allowed number of k nearest neighbors points that a viable result must contain. 
+        # * \param[in] min_pts the minimum number of neighbors in a viable neighborhood 
+        # inline void setMinPts (int min_pts)
+        # * \brief Get the minimum allowed number of k nearest neighbors points that a viable result must contain. */
+        # inline int getMinPts () const
+
+ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+
+ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+###
+
+# kdtree_flann.h
+# NG
+# cdef cppclass KdTreeFLANN[T](KdTree[T]):
+# namespace pcl
+# template <typename PointT, typename Dist = flann::L2_Simple<float> >
+# class KdTreeFLANN : public pcl::KdTree<PointT>
+cdef extern from "pcl/kdtree/kdtree_flann.h" namespace "pcl":
+    cdef cppclass KdTreeFLANN[T]:
+        KdTreeFLANN()
+        # KdTreeFLANN (bool sorted)
+        # KdTreeFLANN (const KdTreeFLANN<PointT> &k) : 
+        #       inline KdTreeFLANN<PointT>& operator = (const KdTreeFLANN<PointT>& k)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] point a given \a valid (i.e., finite) query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        #   */
+        # int nearestKSearch (cpp.PointCloud[T], int, vector[int], vector[float])
+        # inline define
+        int nearestKSearch (cpp.PointCloud[T], int, int, vector[int], vector[float])
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] point a given \a valid (i.e., finite) query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        #   */
+        # int radiusSearch (cpp.PointCloud[T], double, vector[int], vector[float])
+        # int radiusSearch (cpp.PointCloud[T], double, vector[int], vector[float], unsigned int)
+        # inline define
+        int radiusSearch (cpp.PointCloud[T], int, double, vector[int], vector[float])
+        # int radiusSearch (const PointT &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+
+        # using KdTree<PointT>::input_;
+        # using KdTree<PointT>::indices_;
+        # using KdTree<PointT>::epsilon_;
+        # using KdTree<PointT>::sorted_;
+        # using KdTree<PointT>::point_representation_;
+        # using KdTree<PointT>::nearestKSearch;
+        # using KdTree<PointT>::radiusSearch;
+        # typedef typename KdTree<PointT>::PointCloud PointCloud;
+        # typedef typename KdTree<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # typedef flann::Index<Dist> FLANNIndex;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<KdTreeFLANN<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTreeFLANN<PointT> > ConstPtr;
+        # /** \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        #   * \param[in] eps precision (error bound) for nearest neighbors searches
+        #   */
+        # inline void setEpsilon (float eps)
+        # inline void setSortedResults (bool sorted)
+        # inline Ptr makeShared ()
+###
+
+# template <>
+# class KdTreeFLANN <Eigen::MatrixXf>
+#       public:
+#       typedef pcl::PointCloud<Eigen::MatrixXf> PointCloud;
+#       typedef PointCloud::ConstPtr PointCloudConstPtr;
+#       typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+#       typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+#       typedef flann::Index<flann::L2_Simple<float> > FLANNIndex;
+#       typedef pcl::PointRepresentation<Eigen::MatrixXf> PointRepresentation;
+#       typedef boost::shared_ptr<const PointRepresentation> PointRepresentationConstPtr;
+#       // Boost shared pointers
+#       typedef boost::shared_ptr<KdTreeFLANN<Eigen::MatrixXf> > Ptr;
+#       typedef boost::shared_ptr<const KdTreeFLANN<Eigen::MatrixXf> > ConstPtr;
+# 
+#       KdTreeFLANN (bool sorted = true) : 
+#       KdTreeFLANN (const KdTreeFLANN<Eigen::MatrixXf> &k) : 
+#       inline KdTreeFLANN& operator = (const KdTreeFLANN<Eigen::MatrixXf>& k)
+#       inline void setEpsilon (float eps)
+#       inline Ptr makeShared ()
+#       void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+#       inline IndicesConstPtr getIndices () const
+#       inline PointCloudConstPtr getInputCloud () const
+#       template <typename T> int nearestKSearch (const T &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       inline int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       inline int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       template <typename T> int radiusSearch (const T &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_dists, unsigned int max_nn = 0) const
+#       inline int radiusSearch (const PointCloud &cloud, int index, double radius, 
+#                     std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, 
+#                     unsigned int max_nn = 0) const
+#       inline int radiusSearch (int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+#       /** \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+#       inline float getEpsilon () const
+#       protected:
+#       /** \brief The input point cloud dataset containing the points we need to use. */
+#       PointCloudConstPtr input_;
+#       /** \brief A pointer to the vector of point indices to use. */
+#       IndicesConstPtr indices_;
+#       /** \brief Epsilon precision (error bound) for nearest neighbors searches. */
+#       float epsilon_;
+#       /** \brief Return the radius search neighbours sorted **/
+#       bool sorted_;
+### 
+
+ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+
+###
+
+# flann.h
+# io.h
+# kdtree.h
+# kdtree_flann.h
diff --git a/pcl/pcl_kdtree_180.pxd b/pcl/pcl_kdtree_180.pxd
new file mode 100644
index 0000000..f7d4ae0
--- /dev/null
+++ b/pcl/pcl_kdtree_180.pxd
@@ -0,0 +1,331 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+
+from boost_shared_ptr cimport shared_ptr
+
+# flann.h
+###
+
+# io.h
+# namespace pcl
+# {
+#   /** \brief Get a set of approximate indices for a given point cloud into a reference point cloud. 
+#     * The coordinates of the two point clouds can differ. The method uses an internal KdTree for 
+#     * finding the closest neighbors from \a cloud_in in \a cloud_ref. 
+#     *
+#     * \param[in] cloud_in the input point cloud dataset
+#     * \param[in] cloud_ref the reference point cloud dataset
+#     * \param[out] indices the resultant set of nearest neighbor indices of \a cloud_in in \a cloud_ref
+#     * \ingroup kdtree
+#     */
+#   template <typename PointT> void 
+#   getApproximateIndices (const typename pcl::PointCloud<PointT>::Ptr &cloud_in, 
+#                          const typename pcl::PointCloud<PointT>::Ptr &cloud_ref,
+#                          std::vector<int> &indices);
+# 
+#   /** \brief Get a set of approximate indices for a given point cloud into a reference point cloud. 
+#     * The coordinates of the two point clouds can differ. The method uses an internal KdTree for 
+#     * finding the closest neighbors from \a cloud_in in \a cloud_ref. 
+#     *
+#     * \param[in] cloud_in the input point cloud dataset
+#     * \param[in] cloud_ref the reference point cloud dataset
+#     * \param[out] indices the resultant set of nearest neighbor indices of \a cloud_in in \a cloud_ref
+#     * \ingroup kdtree
+#     */
+#   template <typename Point1T, typename Point2T> void 
+#   getApproximateIndices (const typename pcl::PointCloud<Point1T>::Ptr &cloud_in, 
+#                          const typename pcl::PointCloud<Point2T>::Ptr &cloud_ref,
+#                          std::vector<int> &indices);
+# }
+###
+
+# kdtree.h
+# namespace pcl
+# template <typename PointT>
+# class KdTree
+cdef extern from "pcl/kdtree/kdtree.h" namespace "pcl::search":
+    cdef cppclass KdTree[T]:
+        KdTree()
+        # KdTree (bool sorted)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        # public:
+        # typedef boost::shared_ptr <std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr <const std::vector<int> > IndicesConstPtr;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # typedef pcl::PointRepresentation<PointT> PointRepresentation;
+        # //typedef boost::shared_ptr<PointRepresentation> PointRepresentationPtr;
+        # typedef boost::shared_ptr<const PointRepresentation> PointRepresentationConstPtr;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<KdTree<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTree<PointT> > ConstPtr;
+        # /** \brief Empty constructor for KdTree. Sets some internal values to their defaults. 
+        # * \param[in] sorted set to true if the application that the tree will be used for requires sorted nearest neighbor indices (default). False otherwise. 
+        # */
+        # KdTree (bool sorted = true)
+        # /** \brief Provide a pointer to the input dataset.
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # * \param[in] indices the point indices subset that is to be used from \a cloud - if NULL the whole cloud is used
+        # virtual void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        # /** \brief Get a pointer to the vector of indices used. */
+        # inline IndicesConstPtr getIndices () const
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # inline PointCloudConstPtr getInputCloud () const
+        # /** \brief Provide a pointer to the point representation to use to convert points into k-D vectors. 
+        # * \param[in] point_representation the const boost shared pointer to a PointRepresentation
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # /** \brief Get a pointer to the point representation used when converting points into k-D vectors. */
+        # inline PointRepresentationConstPtr getPointRepresentation () const
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        # * \param[in] p_q the given query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # virtual int nearestKSearch (const PointT &p_q, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const = 0;
+        # * \brief Search for k-nearest neighbors for the given query point.
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] cloud the point cloud data
+        # * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for k-nearest neighbors for the given query point. 
+        # * This method accepts a different template parameter for the point type.
+        # * \param[in] point the given query point
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # template <typename PointTDiff> inline int nearestKSearchT (const PointTDiff &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for k-nearest neighbors for the given query point (zero-copy).
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] index a \a valid index representing a \a valid query point in the dataset given 
+        # * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in 
+        # * the indices vector.
+        # * \param[in] k the number of neighbors to search for
+        # * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        # * a priori!)
+        # * \return number of neighbors found
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \param[in] p_q the given query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # virtual int radiusSearch (const PointT &p_q, double radius, std::vector<int> &k_indices,std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const = 0;
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] cloud the point cloud data
+        # * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (const PointCloud &cloud, int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius.
+        # * \param[in] point the given query point
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # template <typename PointTDiff> inline int radiusSearchT (const PointTDiff &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Search for all the nearest neighbors of the query point in a given radius (zero-copy).
+        # * \attention This method does not do any bounds checking for the input index
+        # * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        # * \param[in] index a \a valid index representing a \a valid query point in the dataset given 
+        # * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in 
+        # * the indices vector.
+        # * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        # * \param[out] k_indices the resultant indices of the neighboring points
+        # * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        # * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        # * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        # * returned.
+        # * \return number of neighbors found in radius
+        # * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (int index, double radius, std::vector<int> &k_indices,std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # * \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        # * \param[in] eps precision (error bound) for nearest neighbors searches
+        # virtual inline void setEpsilon (float eps)
+        # * \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+        # inline float getEpsilon () const
+        # * \brief Minimum allowed number of k nearest neighbors points that a viable result must contain. 
+        # * \param[in] min_pts the minimum number of neighbors in a viable neighborhood 
+        # inline void setMinPts (int min_pts)
+        # * \brief Get the minimum allowed number of k nearest neighbors points that a viable result must contain. */
+        # inline int getMinPts () const
+
+ctypedef KdTree[cpp.PointXYZ] KdTree_t
+ctypedef KdTree[cpp.PointXYZI] KdTree_PointXYZI_t
+ctypedef KdTree[cpp.PointXYZRGB] KdTree_PointXYZRGB_t
+ctypedef KdTree[cpp.PointXYZRGBA] KdTree_PointXYZRGBA_t
+
+ctypedef shared_ptr[KdTree[cpp.PointXYZ]] KdTreePtr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZI]] KdTree_PointXYZI_Ptr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZRGB]] KdTree_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[KdTree[cpp.PointXYZRGBA]] KdTree_PointXYZRGBA_Ptr_t
+###
+
+# kdtree_flann.h
+# NG
+# cdef cppclass KdTreeFLANN[T](KdTree[T]):
+# namespace pcl
+# template <typename PointT, typename Dist = flann::L2_Simple<float> >
+# class KdTreeFLANN : public pcl::KdTree<PointT>
+cdef extern from "pcl/kdtree/kdtree_flann.h" namespace "pcl":
+    cdef cppclass KdTreeFLANN[T]:
+        KdTreeFLANN()
+        # KdTreeFLANN (bool sorted)
+        # KdTreeFLANN (const KdTreeFLANN<PointT> &k) : 
+        #       inline KdTreeFLANN<PointT>& operator = (const KdTreeFLANN<PointT>& k)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] point a given \a valid (i.e., finite) query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k 
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        #   */
+        # int nearestKSearch (cpp.PointCloud[T], int, vector[int], vector[float])
+        # inline define
+        int nearestKSearch (cpp.PointCloud[T], int, int, vector[int], vector[float])
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] point a given \a valid (i.e., finite) query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        #   */
+        # int radiusSearch (cpp.PointCloud[T], double, vector[int], vector[float])
+        # int radiusSearch (cpp.PointCloud[T], double, vector[int], vector[float], unsigned int)
+        # inline define
+        int radiusSearch (cpp.PointCloud[T], int, double, vector[int], vector[float])
+        # int radiusSearch (const PointT &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+
+        # using KdTree<PointT>::input_;
+        # using KdTree<PointT>::indices_;
+        # using KdTree<PointT>::epsilon_;
+        # using KdTree<PointT>::sorted_;
+        # using KdTree<PointT>::point_representation_;
+        # using KdTree<PointT>::nearestKSearch;
+        # using KdTree<PointT>::radiusSearch;
+        # typedef typename KdTree<PointT>::PointCloud PointCloud;
+        # typedef typename KdTree<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # typedef flann::Index<Dist> FLANNIndex;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<KdTreeFLANN<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTreeFLANN<PointT> > ConstPtr;
+        # /** \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        #   * \param[in] eps precision (error bound) for nearest neighbors searches
+        #   */
+        # inline void setEpsilon (float eps)
+        # inline void setSortedResults (bool sorted)
+        # inline Ptr makeShared ()
+###
+
+# template <>
+# class KdTreeFLANN <Eigen::MatrixXf>
+#       public:
+#       typedef pcl::PointCloud<Eigen::MatrixXf> PointCloud;
+#       typedef PointCloud::ConstPtr PointCloudConstPtr;
+#       typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+#       typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+#       typedef flann::Index<flann::L2_Simple<float> > FLANNIndex;
+#       typedef pcl::PointRepresentation<Eigen::MatrixXf> PointRepresentation;
+#       typedef boost::shared_ptr<const PointRepresentation> PointRepresentationConstPtr;
+#       // Boost shared pointers
+#       typedef boost::shared_ptr<KdTreeFLANN<Eigen::MatrixXf> > Ptr;
+#       typedef boost::shared_ptr<const KdTreeFLANN<Eigen::MatrixXf> > ConstPtr;
+# 
+#       KdTreeFLANN (bool sorted = true) : 
+#       KdTreeFLANN (const KdTreeFLANN<Eigen::MatrixXf> &k) : 
+#       inline KdTreeFLANN& operator = (const KdTreeFLANN<Eigen::MatrixXf>& k)
+#       inline void setEpsilon (float eps)
+#       inline Ptr makeShared ()
+#       void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+#       inline IndicesConstPtr getIndices () const
+#       inline PointCloudConstPtr getInputCloud () const
+#       template <typename T> int nearestKSearch (const T &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       inline int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       inline int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#       template <typename T> int radiusSearch (const T &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_dists, unsigned int max_nn = 0) const
+#       inline int radiusSearch (const PointCloud &cloud, int index, double radius, 
+#                     std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, 
+#                     unsigned int max_nn = 0) const
+#       inline int radiusSearch (int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+#       /** \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+#       inline float getEpsilon () const
+#       protected:
+#       /** \brief The input point cloud dataset containing the points we need to use. */
+#       PointCloudConstPtr input_;
+#       /** \brief A pointer to the vector of point indices to use. */
+#       IndicesConstPtr indices_;
+#       /** \brief Epsilon precision (error bound) for nearest neighbors searches. */
+#       float epsilon_;
+#       /** \brief Return the radius search neighbours sorted **/
+#       bool sorted_;
+### 
+
+ctypedef KdTreeFLANN[cpp.PointXYZ] KdTreeFLANN_t
+ctypedef KdTreeFLANN[cpp.PointXYZI] KdTreeFLANN_PointXYZI_t
+ctypedef KdTreeFLANN[cpp.PointXYZRGB] KdTreeFLANN_PointXYZRGB_t
+ctypedef KdTreeFLANN[cpp.PointXYZRGBA] KdTreeFLANN_PointXYZRGBA_t
+
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNPtr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_Ptr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_Ptr_t
+
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZ]] KdTreeFLANNConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZI]] KdTreeFLANN_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGB]] KdTreeFLANN_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const KdTreeFLANN[cpp.PointXYZRGBA]] KdTreeFLANN_PointXYZRGBA_ConstPtr_t
+
+###
+
+# flann.h
+# io.h
+# kdtree.h
+# kdtree_flann.h
diff --git a/pcl/pcl_keypoints.pxd b/pcl/pcl_keypoints.pxd
new file mode 100644
index 0000000..283c59a
--- /dev/null
+++ b/pcl/pcl_keypoints.pxd
@@ -0,0 +1,344 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_features as pclftr
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# keypoint.h
+# template <typename PointInT, typename PointOutT>
+# class Keypoint : public PCLBase<PointInT>
+cdef extern from "pcl/keypoints/keypoint.h" namespace "pcl":
+    cdef cppclass Keypoint[In, Out](cpp.PCLBase[In]):
+        Keypoint ()
+        # public:
+        # brief Provide a pointer to the input dataset that we need to estimate features at every point for.
+        # param cloud the const boost shared pointer to a PointCloud message
+        # void setSearchSurface (const PointCloudInConstPtr &cloud)
+        # void setSearchSurface (const PointCloud[In] &cloud)
+        
+        # brief Get a pointer to the surface point cloud dataset.
+        # PointCloudInConstPtr getSearchSurface ()
+        # PointCloud[In] getSearchSurface ()
+        
+        # brief Provide a pointer to the search object.
+        # param tree a pointer to the spatial search object.
+        # void setSearchMethod (const KdTreePtr &tree)
+        # void setSearchMethod (-.KdTree &tree)
+        
+        # brief Get a pointer to the search method used.
+        # KdTreePtr getSearchMethod ()
+        # -.KdTree getSearchMethod ()
+        
+        # brief Get the internal search parameter.
+        double getSearchParameter ()
+        
+        # brief Set the number of k nearest neighbors to use for the feature estimation.
+        # param k the number of k-nearest neighbors
+        void setKSearch (int k)
+        
+        # brief get the number of k nearest neighbors used for the feature estimation. */
+        int getKSearch ()
+        
+        # brief Set the sphere radius that is to be used for determining the nearest neighbors used for the key point detection
+        # param radius the sphere radius used as the maximum distance to consider a point a neighbor
+        void setRadiusSearch (double radius)
+        
+        # brief Get the sphere radius used for determining the neighbors. */
+        double getRadiusSearch ()
+        
+        # brief Base method for key point detection for all points given in <setInputCloud (), setIndices ()> using
+        # the surface in setSearchSurface () and the spatial locator in setSearchMethod ()
+        # param output the resultant point cloud model dataset containing the estimated features
+        # inline void compute (PointCloudOut &output);
+        void compute (cpp.PointCloud[Out] &output)
+        
+        # brief Search for k-nearest neighbors using the spatial locator from \a setSearchmethod, and the given surface
+        # from \a setSearchSurface.
+        # param index the index of the query point
+        # param parameter the search parameter (either k or radius)
+        # param indices the resultant vector of indices representing the k-nearest neighbors
+        # param distances the resultant vector of distances representing the distances from the query point to the
+        # k-nearest neighbors
+        # inline int searchForNeighbors (int index, double parameter, vector[int] &indices, vector[float] &distances)
+        int searchForNeighbors (int index, double parameter, vector[int] &indices, vector[float] &distances)
+
+
+###
+
+# harris_keypoint3D.h (1.6.0)
+# harris_3d.h (1.7.2)
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class HarrisKeypoint3D : public Keypoint<PointInT, PointOutT>
+cdef extern from "pcl/keypoints/harris_keypoint3D.h" namespace "pcl":
+    cdef cppclass HarrisKeypoint3D[In, Out, NormalT](Keypoint[In, Out]):
+        HarrisKeypoint3D ()
+        # HarrisKeypoint3D (ResponseMethod method = HARRIS, float radius = 0.01f, float threshold = 0.0f)
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        
+        # typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+        
+        # brief Set the method of the response to be calculated.
+        # param[in] type
+        # void setMethod (ResponseMethod type)
+        # void setMethod (ResponseMethod2 type)
+        void setMethod (int type)
+        
+        # * \brief Set the radius for normal estimation and non maxima supression.
+        # * \param[in] radius
+        # void setRadius (float radius)
+        void setRadius (float radius)
+        
+        # * \brief Set the threshold value for detecting corners. This is only evaluated if non maxima suppression is turned on.
+        # * \brief note non maxima suppression needs to be activated in order to use this feature.
+        # * \param[in] threshold
+        void setThreshold (float threshold)
+        
+        # * \brief Whether non maxima suppression should be applied or the response for each point should be returned
+        # * \note this value needs to be turned on in order to apply thresholding and refinement
+        # * \param[in] nonmax default is false
+        # void setNonMaxSupression (bool = false)
+        void setNonMaxSupression (bool param)
+        
+        # * \brief Whether the detected key points should be refined or not. If turned of, the key points are a subset of the original point cloud. Otherwise the key points may be arbitrary.
+        # * \brief note non maxima supression needs to be on in order to use this feature.
+        # * \param[in] do_refine
+        void setRefine (bool do_refine)
+        
+        # * \brief Set normals if precalculated normals are available.
+        # * \param normals
+        # void setNormals (const PointCloudNPtr &normals)
+        # void setNormals (const cpp.PointCloud[NormalT] &normals)
+        
+        # * \brief Provide a pointer to a dataset to add additional information
+        # * to estimate the features for every point in the input dataset.  This
+        # * is optional, if this is not set, it will only use the data in the
+        # * input cloud to estimate the features.  This is useful when you only
+        # * need to compute the features for a downsampled cloud.
+        # * \param[in] cloud a pointer to a PointCloud message
+        # virtual void setSearchSurface (const PointCloudInConstPtr &cloud)
+        # void setSearchSurface (const PointCloudInConstPtr &cloud)
+        
+        # * \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (int nr_threads)
+        void setNumberOfThreads (int nr_threads)
+
+
+ctypedef HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZI_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGBA_Ptr_t
+###
+
+# narf_keypoint.h
+# class PCL_EXPORTS NarfKeypoint : public Keypoint<PointWithRange, int>
+cdef extern from "pcl/keypoints/narf_keypoint.h" namespace "pcl":
+    cdef cppclass NarfKeypoint(Keypoint[cpp.PointWithRange, int]):
+        NarfKeypoint ()
+        NarfKeypoint (pclftr.RangeImageBorderExtractor range_image_border_extractor, float support_size)
+        # NarfKeypoint (RangeImageBorderExtractor* range_image_border_extractor=NULL, float support_size=-1.0f);
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef Keypoint<PointWithRange, int> BaseClass;
+        # typedef Keypoint<PointWithRange, int>::PointCloudOut PointCloudOut;
+        # // =====PUBLIC STRUCTS=====
+        # //! Parameters used in this class
+        # cdef struct Parameters
+        # {
+        #     Parameters() : support_size(-1.0f), max_no_of_interest_points(-1), min_distance_between_interest_points(0.25f),
+        #            optimal_distance_to_high_surface_change(0.25), min_interest_value(0.45f),
+        #            min_surface_change_score(0.2f), optimal_range_image_patch_size(10),
+        #            distance_for_additional_points(0.0f), add_points_on_straight_edges(false),
+        #            do_non_maximum_suppression(true), no_of_polynomial_approximations_per_point(0),
+        #            max_no_of_threads(1), use_recursive_scale_reduction(false),
+        #            calculate_sparse_interest_image(true) {}
+        # 
+        #     float support_size;  //!< This defines the area 'covered' by an interest point (in meters)
+        #     int max_no_of_interest_points;  //!< The maximum number of interest points that will be returned
+        #     float min_distance_between_interest_points;  /**< Minimum distance between maximas
+        #                                            *  (this is a factor for support_size, i.e. the distance is
+        #                                            *  min_distance_between_interest_points*support_size) */
+        #     float optimal_distance_to_high_surface_change;  /**< The distance we want keep between keypoints and areas
+        #                                               *  of high surface change
+        #                                               *  (this is a factor for support_size, i.e., the distance is
+        #                                               *  optimal_distance_to_high_surface_change*support_size) */
+        #     float min_interest_value;  //!< The minimum value to consider a point as an interest point
+        #     float min_surface_change_score;  //!< The minimum value  of the surface change score to consider a point
+        #     int optimal_range_image_patch_size;  /**< The size (in pixels) of the image patches from which the interest value
+        #                                    *  should be computed. This influences, which range image is selected from
+        #                                    *  the scale space to compute the interest value of a pixel at a certain
+        #                                    *  distance. */
+        #     // TODO:
+        #     float distance_for_additional_points;  /**< All points in this distance to a found maximum, that
+        #                                      *  are above min_interest_value are also added as interest points
+        #                                      *  (this is a factor for support_size, i.e. the distance is
+        #                                      *  distance_for_additional_points*support_size) */
+        #     bool add_points_on_straight_edges;  /**< If this is set to true, there will also be interest points on
+        #                                   *   straight edges, e.g., just indicating an area of high surface change */
+        #     bool do_non_maximum_suppression;  /**< If this is set to false there will be much more points
+        #                                 *  (can be used to spread points over the whole scene
+        #                                 *  (combined with a low min_interest_value)) */
+        #     bool no_of_polynomial_approximations_per_point; /**< If this is >0, the exact position of the interest point is
+        #                                                  determined using bivariate polynomial approximations of the
+        #                                                  interest values of the area. */
+        #     int max_no_of_threads;  //!< The maximum number of threads this code is allowed to use with OPNEMP
+        #     bool use_recursive_scale_reduction;  /**< Try to decrease runtime by extracting interest points at lower reolution
+        #                                    *  in areas that contain enough points, i.e., have lower range. */
+        #     bool calculate_sparse_interest_image;  /**< Use some heuristics to decide which areas of the interest image
+        #                                         can be left out to improve the runtime. */
+        # };
+        # 
+        # =====PUBLIC METHODS=====
+        # Erase all data calculated for the current range image
+        void clearData ()
+        
+        # //! Set the RangeImageBorderExtractor member (required)
+        # void setRangeImageBorderExtractor (RangeImageBorderExtractor* range_image_border_extractor);
+        void setRangeImageBorderExtractor (pclftr.RangeImageBorderExtractor range_image_border_extractor)
+        
+        # //! Get the RangeImageBorderExtractor member
+        # RangeImageBorderExtractor* getRangeImageBorderExtractor ()
+        pclftr.RangeImageBorderExtractor getRangeImageBorderExtractor ()
+        
+        # //! Set the RangeImage member of the RangeImageBorderExtractor
+        # void setRangeImage (const RangeImage* range_image)
+        # void setRangeImage (const RangeImage_Ptr range_image)
+        
+        # /** Extract interest value per image point */
+        # float* getInterestImage () { calculateInterestImage(); return interest_image_;}
+        # float[] getInterestImage ()
+        
+        # //! Extract maxima from an interest image
+        # const ::pcl::PointCloud<InterestPoint>& getInterestPoints () { calculateInterestPoints(); return *interest_points_;}
+        
+        # //! Set all points in the image that are interest points to true, the rest to false
+        # const std::vector<bool>& getIsInterestPointImage ()
+        
+        # //! Getter for the parameter struct
+        # Parameters& getParameters ()
+        
+        # //! Getter for the range image of range_image_border_extractor_
+        # const RangeImage& getRangeImage ();
+        
+        # //! Overwrite the compute function of the base class
+        # void compute (PointCloudOut& output);
+
+# ingroup keypoints
+# operator
+# inline std::ostream& operator << (std::ostream& os, const NarfKeypoint::Parameters& p)
+
+ctypedef NarfKeypoint NarfKeypoint_t
+ctypedef shared_ptr[NarfKeypoint] NarfKeypointPtr_t
+###
+
+# sift_keypoint.h
+# template <typename PointInT, typename PointOutT>
+# class SIFTKeypoint : public Keypoint<PointInT, PointOutT>
+cdef extern from "pcl/keypoints/sift_keypoint.h" namespace "pcl":
+    cdef cppclass SIFTKeypoint[In, Out](Keypoint[In, Out]):
+        SIFTKeypoint ()
+        # public:
+        # /** \brief Specify the range of scales over which to search for keypoints
+        # * \param min_scale the standard deviation of the smallest scale in the scale space
+        # * \param nr_octaves the number of octaves (i.e. doublings of scale) to compute 
+        # * \param nr_scales_per_octave the number of scales to compute within each octave
+        void setScales (float min_scale, int nr_octaves, int nr_scales_per_octave)
+        
+        # /** \brief Provide a threshold to limit detection of keypoints without sufficient contrast
+        # * \param min_contrast the minimum contrast required for detection
+        void setMinimumContrast (float min_contrast)
+
+
+# pcl::SIFTKeypoint<pcl::PointNormal, pcl::PointWithScale> sift;
+ctypedef SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale] SIFTKeypoint_t
+ctypedef shared_ptr[SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale]] SIFTKeypointPtr_t
+###
+
+# smoothed_surfaces_keypoint.h
+# template <typename PointT, typename PointNT>
+# class SmoothedSurfacesKeypoint : public Keypoint <PointT, PointT>
+cdef extern from "pcl/keypoints/smoothed_surfaces_keypoint.h" namespace "pcl":
+    cdef cppclass SmoothedSurfacesKeypoint[In, Out](Keypoint[In, Out]):
+        SmoothedSurfacesKeypoint ()
+        # public:
+        # void addSmoothedPointCloud (const PointCloudTConstPtr &cloud, const PointCloudNTConstPtr &normals, KdTreePtr &kdtree, float &scale);
+        
+        void resetClouds ()
+        
+        # inline void setNeighborhoodConstant (float neighborhood_constant)
+        
+        # inline float getNeighborhoodConstant ()
+        
+        # inline void setInputNormals (const PointCloudNTConstPtr &normals)
+        
+        # inline void setInputScale (float input_scale)
+        
+        # void detectKeypoints (PointCloudT &output);
+
+
+###
+
+# uniform_sampling.h
+# template <typename PointInT>
+# class UniformSampling: public Keypoint<PointInT, int>
+cdef extern from "pcl/keypoints/uniform_sampling.h" namespace "pcl":
+    cdef cppclass UniformSampling[In](Keypoint[In, int]):
+        UniformSampling ()
+        # public:
+        # brief Set the 3D grid leaf size.
+        # param radius the 3D grid leaf size
+        void setRadiusSearch (double radius)
+
+
+ctypedef UniformSampling[cpp.PointXYZ] UniformSampling_t
+ctypedef UniformSampling[cpp.PointXYZI] UniformSampling_PointXYZI_t
+ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t
+ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGB]] UniformSampling_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGBA]] UniformSampling_PointXYZRGBA_Ptr_t
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# 1.6.0
+# NG : use Template parameters Class Internal
+# typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+
+# 1.7.2
+# NG : use Template parameters Class Internal
+# RESPONSEMETHOD_HARRIS "pcl::HarrisKeypoint3D::HARRIS", 
+# RESPONSEMETHOD_NOBLE "pcl::HarrisKeypoint3D::NOBLE", 
+# RESPONSEMETHOD_LOWE "pcl::HarrisKeypoint3D::LOWE", 
+# RESPONSEMETHOD_TOMASI "pcl::HarrisKeypoint3D::TOMASI", 
+# RESPONSEMETHOD_CURVATURE "pcl::HarrisKeypoint3D::CURVATURE"
+
+
diff --git a/pcl/pcl_keypoints_172.pxd b/pcl/pcl_keypoints_172.pxd
new file mode 100644
index 0000000..ac852e4
--- /dev/null
+++ b/pcl/pcl_keypoints_172.pxd
@@ -0,0 +1,1295 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# pcl
+cimport pcl_defs as cpp
+cimport pcl_features_172 as pclftr
+cimport pcl_kdtree_172 as pclkdt
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# keypoint.h
+# template <typename PointInT, typename PointOutT>
+# class Keypoint : public PCLBase<PointInT>
+cdef extern from "pcl/keypoints/keypoint.h" namespace "pcl":
+    cdef cppclass Keypoint[In, Out](cpp.PCLBase[In]):
+        Keypoint ()
+        # public:
+        # brief Provide a pointer to the input dataset that we need to estimate features at every point for.
+        # param cloud the const boost shared pointer to a PointCloud message
+        # void setSearchSurface (const PointCloudInConstPtr &cloud)
+        # void setSearchSurface (const PointCloud[In] &cloud)
+        
+        # brief Get a pointer to the surface point cloud dataset.
+        # PointCloudInConstPtr getSearchSurface ()
+        # PointCloud[In] getSearchSurface ()
+        
+        # brief Provide a pointer to the search object.
+        # param tree a pointer to the spatial search object.
+        # void setSearchMethod (const KdTreePtr &tree)
+        # void setSearchMethod (-.KdTree &tree)
+        
+        # brief Get a pointer to the search method used.
+        # KdTreePtr getSearchMethod ()
+        # -.KdTree getSearchMethod ()
+        
+        # brief Get the internal search parameter.
+        double getSearchParameter ()
+        
+        # brief Set the number of k nearest neighbors to use for the feature estimation.
+        # param k the number of k-nearest neighbors
+        void setKSearch (int k)
+        
+        # brief get the number of k nearest neighbors used for the feature estimation. */
+        int getKSearch ()
+        
+        # brief Set the sphere radius that is to be used for determining the nearest neighbors used for the key point detection
+        # param radius the sphere radius used as the maximum distance to consider a point a neighbor
+        void setRadiusSearch (double radius)
+        
+        # brief Get the sphere radius used for determining the neighbors. */
+        double getRadiusSearch ()
+        
+        # brief Base method for key point detection for all points given in <setInputCloud (), setIndices ()> using
+        # the surface in setSearchSurface () and the spatial locator in setSearchMethod ()
+        # param output the resultant point cloud model dataset containing the estimated features
+        # inline void compute (PointCloudOut &output);
+        void compute (cpp.PointCloud[Out] &output)
+        
+        # brief Search for k-nearest neighbors using the spatial locator from \a setSearchmethod, and the given surface
+        # from \a setSearchSurface.
+        # param index the index of the query point
+        # param parameter the search parameter (either k or radius)
+        # param indices the resultant vector of indices representing the k-nearest neighbors
+        # param distances the resultant vector of distances representing the distances from the query point to the
+        # k-nearest neighbors
+        # inline int searchForNeighbors (int index, double parameter, vector[int] &indices, vector[float] &distances)
+        int searchForNeighbors (int index, double parameter, vector[int] &indices, vector[float] &distances)
+
+
+###
+
+# harris_keypoint3D.h (1.6.0)
+# harris_3d.h (1.7.2)
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class HarrisKeypoint3D : public Keypoint<PointInT, PointOutT>
+cdef extern from "pcl/keypoints/harris_3d.h" namespace "pcl":
+    cdef cppclass HarrisKeypoint3D[In, Out, NormalT](Keypoint[In, Out]):
+        HarrisKeypoint3D ()
+        # HarrisKeypoint3D (ResponseMethod method = HARRIS, float radius = 0.01f, float threshold = 0.0f)
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        
+        # typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+        
+        # brief Set the method of the response to be calculated.
+        # param[in] type
+        # void setMethod (ResponseMethod type)
+        # void setMethod (ResponseMethod2 type)
+        void setMethod (int type)
+        
+        # * \brief Set the radius for normal estimation and non maxima supression.
+        # * \param[in] radius
+        # void setRadius (float radius)
+        void setRadius (float radius)
+        
+        # * \brief Set the threshold value for detecting corners. This is only evaluated if non maxima suppression is turned on.
+        # * \brief note non maxima suppression needs to be activated in order to use this feature.
+        # * \param[in] threshold
+        void setThreshold (float threshold)
+        
+        # * \brief Whether non maxima suppression should be applied or the response for each point should be returned
+        # * \note this value needs to be turned on in order to apply thresholding and refinement
+        # * \param[in] nonmax default is false
+        # void setNonMaxSupression (bool = false)
+        void setNonMaxSupression (bool param)
+        
+        # * \brief Whether the detected key points should be refined or not. If turned of, the key points are a subset of the original point cloud. Otherwise the key points may be arbitrary.
+        # * \brief note non maxima supression needs to be on in order to use this feature.
+        # * \param[in] do_refine
+        void setRefine (bool do_refine)
+        
+        # * \brief Set normals if precalculated normals are available.
+        # * \param normals
+        # void setNormals (const PointCloudNPtr &normals)
+        # void setNormals (const cpp.PointCloud[NormalT] &normals)
+        
+        # * \brief Provide a pointer to a dataset to add additional information
+        # * to estimate the features for every point in the input dataset.  This
+        # * is optional, if this is not set, it will only use the data in the
+        # * input cloud to estimate the features.  This is useful when you only
+        # * need to compute the features for a downsampled cloud.
+        # * \param[in] cloud a pointer to a PointCloud message
+        # virtual void setSearchSurface (const PointCloudInConstPtr &cloud)
+        # void setSearchSurface (const PointCloudInConstPtr &cloud)
+        
+        # * \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (int nr_threads)
+        void setNumberOfThreads (int nr_threads)
+
+
+ctypedef HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZI_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGBA_Ptr_t
+###
+
+# narf_keypoint.h
+# class PCL_EXPORTS NarfKeypoint : public Keypoint<PointWithRange, int>
+cdef extern from "pcl/keypoints/narf_keypoint.h" namespace "pcl":
+    cdef cppclass NarfKeypoint(Keypoint[cpp.PointWithRange, int]):
+        NarfKeypoint ()
+        NarfKeypoint (pclftr.RangeImageBorderExtractor range_image_border_extractor, float support_size)
+        # NarfKeypoint (RangeImageBorderExtractor* range_image_border_extractor=NULL, float support_size=-1.0f);
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef Keypoint<PointWithRange, int> BaseClass;
+        # typedef Keypoint<PointWithRange, int>::PointCloudOut PointCloudOut;
+        # // =====PUBLIC STRUCTS=====
+        # //! Parameters used in this class
+        # cdef struct Parameters
+        # {
+        #     Parameters() : support_size(-1.0f), max_no_of_interest_points(-1), min_distance_between_interest_points(0.25f),
+        #            optimal_distance_to_high_surface_change(0.25), min_interest_value(0.45f),
+        #            min_surface_change_score(0.2f), optimal_range_image_patch_size(10),
+        #            distance_for_additional_points(0.0f), add_points_on_straight_edges(false),
+        #            do_non_maximum_suppression(true), no_of_polynomial_approximations_per_point(0),
+        #            max_no_of_threads(1), use_recursive_scale_reduction(false),
+        #            calculate_sparse_interest_image(true) {}
+        # 
+        #     float support_size;  //!< This defines the area 'covered' by an interest point (in meters)
+        #     int max_no_of_interest_points;  //!< The maximum number of interest points that will be returned
+        #     float min_distance_between_interest_points;  /**< Minimum distance between maximas
+        #                                            *  (this is a factor for support_size, i.e. the distance is
+        #                                            *  min_distance_between_interest_points*support_size) */
+        #     float optimal_distance_to_high_surface_change;  /**< The distance we want keep between keypoints and areas
+        #                                               *  of high surface change
+        #                                               *  (this is a factor for support_size, i.e., the distance is
+        #                                               *  optimal_distance_to_high_surface_change*support_size) */
+        #     float min_interest_value;  //!< The minimum value to consider a point as an interest point
+        #     float min_surface_change_score;  //!< The minimum value  of the surface change score to consider a point
+        #     int optimal_range_image_patch_size;  /**< The size (in pixels) of the image patches from which the interest value
+        #                                    *  should be computed. This influences, which range image is selected from
+        #                                    *  the scale space to compute the interest value of a pixel at a certain
+        #                                    *  distance. */
+        #     // TODO:
+        #     float distance_for_additional_points;  /**< All points in this distance to a found maximum, that
+        #                                      *  are above min_interest_value are also added as interest points
+        #                                      *  (this is a factor for support_size, i.e. the distance is
+        #                                      *  distance_for_additional_points*support_size) */
+        #     bool add_points_on_straight_edges;  /**< If this is set to true, there will also be interest points on
+        #                                   *   straight edges, e.g., just indicating an area of high surface change */
+        #     bool do_non_maximum_suppression;  /**< If this is set to false there will be much more points
+        #                                 *  (can be used to spread points over the whole scene
+        #                                 *  (combined with a low min_interest_value)) */
+        #     bool no_of_polynomial_approximations_per_point; /**< If this is >0, the exact position of the interest point is
+        #                                                  determined using bivariate polynomial approximations of the
+        #                                                  interest values of the area. */
+        #     int max_no_of_threads;  //!< The maximum number of threads this code is allowed to use with OPNEMP
+        #     bool use_recursive_scale_reduction;  /**< Try to decrease runtime by extracting interest points at lower reolution
+        #                                    *  in areas that contain enough points, i.e., have lower range. */
+        #     bool calculate_sparse_interest_image;  /**< Use some heuristics to decide which areas of the interest image
+        #                                         can be left out to improve the runtime. */
+        # };
+        # 
+        # =====PUBLIC METHODS=====
+        # Erase all data calculated for the current range image
+        void clearData ()
+        
+        # //! Set the RangeImageBorderExtractor member (required)
+        # void setRangeImageBorderExtractor (RangeImageBorderExtractor* range_image_border_extractor);
+        void setRangeImageBorderExtractor (pclftr.RangeImageBorderExtractor range_image_border_extractor)
+        
+        # //! Get the RangeImageBorderExtractor member
+        # RangeImageBorderExtractor* getRangeImageBorderExtractor ()
+        pclftr.RangeImageBorderExtractor getRangeImageBorderExtractor ()
+        
+        # //! Set the RangeImage member of the RangeImageBorderExtractor
+        # void setRangeImage (const RangeImage* range_image)
+        # void setRangeImage (const RangeImage_Ptr range_image)
+        
+        # /** Extract interest value per image point */
+        # float* getInterestImage () { calculateInterestImage(); return interest_image_;}
+        # float[] getInterestImage ()
+        
+        # //! Extract maxima from an interest image
+        # const ::pcl::PointCloud<InterestPoint>& getInterestPoints () { calculateInterestPoints(); return *interest_points_;}
+        
+        # //! Set all points in the image that are interest points to true, the rest to false
+        # const std::vector<bool>& getIsInterestPointImage ()
+        
+        # //! Getter for the parameter struct
+        # Parameters& getParameters ()
+        
+        # //! Getter for the range image of range_image_border_extractor_
+        # const RangeImage& getRangeImage ();
+        
+        # //! Overwrite the compute function of the base class
+        # void compute (PointCloudOut& output);
+
+# ingroup keypoints
+# operator
+# inline std::ostream& operator << (std::ostream& os, const NarfKeypoint::Parameters& p)
+
+ctypedef NarfKeypoint NarfKeypoint_t
+ctypedef shared_ptr[NarfKeypoint] NarfKeypointPtr_t
+###
+
+# sift_keypoint.h
+# template <typename PointInT, typename PointOutT>
+# class SIFTKeypoint : public Keypoint<PointInT, PointOutT>
+cdef extern from "pcl/keypoints/sift_keypoint.h" namespace "pcl":
+    cdef cppclass SIFTKeypoint[In, Out](Keypoint[In, Out]):
+        SIFTKeypoint ()
+        # public:
+        # /** \brief Specify the range of scales over which to search for keypoints
+        # * \param min_scale the standard deviation of the smallest scale in the scale space
+        # * \param nr_octaves the number of octaves (i.e. doublings of scale) to compute 
+        # * \param nr_scales_per_octave the number of scales to compute within each octave
+        void setScales (float min_scale, int nr_octaves, int nr_scales_per_octave)
+        
+        # /** \brief Provide a threshold to limit detection of keypoints without sufficient contrast
+        # * \param min_contrast the minimum contrast required for detection
+        void setMinimumContrast (float min_contrast)
+
+
+# pcl::SIFTKeypoint<pcl::PointNormal, pcl::PointWithScale> sift;
+ctypedef SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale] SIFTKeypoint_t
+ctypedef shared_ptr[SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale]] SIFTKeypointPtr_t
+###
+
+# smoothed_surfaces_keypoint.h
+# template <typename PointT, typename PointNT>
+# class SmoothedSurfacesKeypoint : public Keypoint <PointT, PointT>
+cdef extern from "pcl/keypoints/smoothed_surfaces_keypoint.h" namespace "pcl":
+    cdef cppclass SmoothedSurfacesKeypoint[In, Out](Keypoint[In, Out]):
+        SmoothedSurfacesKeypoint ()
+        # public:
+        # void addSmoothedPointCloud (const PointCloudTConstPtr &cloud, const PointCloudNTConstPtr &normals, KdTreePtr &kdtree, float &scale);
+        
+        void resetClouds ()
+        
+        # inline void setNeighborhoodConstant (float neighborhood_constant)
+        
+        # inline float getNeighborhoodConstant ()
+        
+        # inline void setInputNormals (const PointCloudNTConstPtr &normals)
+        
+        # inline void setInputScale (float input_scale)
+        
+        # void detectKeypoints (PointCloudT &output);
+
+
+###
+
+# uniform_sampling.h
+# template <typename PointInT>
+# class UniformSampling: public Keypoint<PointInT, int>
+cdef extern from "pcl/keypoints/uniform_sampling.h" namespace "pcl":
+    cdef cppclass UniformSampling[In](Keypoint[In, int]):
+        UniformSampling ()
+        # public:
+        # brief Set the 3D grid leaf size.
+        # param radius the 3D grid leaf size
+        void setRadiusSearch (double radius)
+
+
+ctypedef UniformSampling[cpp.PointXYZ] UniformSampling_t
+ctypedef UniformSampling[cpp.PointXYZI] UniformSampling_PointXYZI_t
+ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t
+ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGB]] UniformSampling_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGBA]] UniformSampling_PointXYZRGBA_Ptr_t
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# 1.6.0
+# NG : use Template parameters Class Internal
+# typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+
+# 1.7.2
+# NG : use Template parameters Class Internal
+# RESPONSEMETHOD_HARRIS "pcl::HarrisKeypoint3D::HARRIS", 
+# RESPONSEMETHOD_NOBLE "pcl::HarrisKeypoint3D::NOBLE", 
+# RESPONSEMETHOD_LOWE "pcl::HarrisKeypoint3D::LOWE", 
+# RESPONSEMETHOD_TOMASI "pcl::HarrisKeypoint3D::TOMASI", 
+# RESPONSEMETHOD_CURVATURE "pcl::HarrisKeypoint3D::CURVATURE"
+
+
+############################
+# 1.7.2 Add
+
+# agast_2d.h
+# namespace pcl
+# namespace keypoints
+# namespace agast
+# /** \brief Abstract detector class for AGAST corner point detectors.
+#  * Adapted from the C++ implementation of Elmar Mair 
+#  * (http://www6.in.tum.de/Main/ResearchAgast).
+#  * \author Stefan Holzer
+#  * \ingroup keypoints
+#  */
+# class PCL_EXPORTS AbstractAgastDetector
+        # AbstractAgastDetector (const size_t width, 
+        #                        const size_t height, 
+        #                        const double threshold,
+        #                        const double bmax) 
+        # public:
+        # typedef boost::shared_ptr<AbstractAgastDetector> Ptr;
+        # typedef boost::shared_ptr<const AbstractAgastDetector> ConstPtr;
+        # /** \brief Constructor. 
+        # * \param[in] width the width of the image to process
+        # * \param[in] height the height of the image to process
+        # * \param[in] threshold the corner detection threshold
+        # * \param[in] bmax the max image value (default: 255)
+        # */
+        # /** \brief Detects corner points. 
+        # * \param intensity_data
+        # * \param output
+        # */
+        # void 
+        # detectKeypoints (const std::vector<unsigned char> &intensity_data, 
+        #            pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Detects corner points. 
+        # * \param intensity_data
+        # * \param output
+        # */
+        # void 
+        # detectKeypoints (const std::vector<float> &intensity_data, 
+        #            pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Applies non-max-suppression. 
+        # * \param[in] intensity_data the image data
+        # * \param[in] input the keypoint positions
+        # * \param[out] output the resultant keypoints after non-max-supression
+        # */
+        # void
+        # applyNonMaxSuppression (const std::vector<unsigned char>& intensity_data, 
+        #                   const pcl::PointCloud<pcl::PointUV> &input, 
+        #                   pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Applies non-max-suppression. 
+        # * \param[in] intensity_data the image data
+        # * \param[in] input the keypoint positions
+        # * \param[out] output the resultant keypoints after non-max-supression
+        # */
+        # void
+        # applyNonMaxSuppression (const std::vector<float>& intensity_data, 
+        #                   const pcl::PointCloud<pcl::PointUV> &input, 
+        #                   pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Computes corner score. 
+        # * \param[in] im the pixels to compute the score at
+        # */
+        # virtual int 
+        # computeCornerScore (const unsigned char* im) const = 0;
+        # /** \brief Computes corner score. 
+        # * \param[in] im the pixels to compute the score at
+        # */
+        # virtual int 
+        # computeCornerScore (const float* im) const = 0;
+        # /** \brief Sets the threshold for corner detection.
+        # * \param[in] threshold the threshold used for corner detection.
+        # */
+        # inline void
+        # setThreshold (const double threshold)
+        # /** \brief Get the threshold for corner detection, as set by the user. */
+        # inline double
+        # getThreshold ()
+        # /** \brief Sets the maximum number of keypoints to return. The
+        # * estimated keypoints are sorted by their internal score.
+        # * \param[in] nr_max_keypoints set the maximum number of keypoints to return
+        # */
+        # inline void
+        # setMaxKeypoints (const unsigned int nr_max_keypoints)
+        # /** \brief Get the maximum nuber of keypoints to return, as set by the user. */
+        # inline unsigned int 
+        # getMaxKeypoints ()
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # * \param[out] corners_all the resultant set of keypoints detected
+        # */
+        # virtual void 
+        # detect (const unsigned char* im, 
+        #   std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const = 0;
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # */
+        # virtual void 
+        # detect (const float* im, 
+        #   std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &) const = 0;
+        # protected:
+        # /** \brief Structure holding an index and the associated keypoint score. */
+        # struct ScoreIndex
+        # {
+        # int idx;
+        # int score;
+        # };
+        # /** \brief Score index comparator. */
+        # struct CompareScoreIndex
+        # {
+        # /** \brief Comparator
+        # * \param[in] i1 the first score index
+        # * \param[in] i2 the second score index
+        # */
+        # inline bool
+        # operator() (const ScoreIndex &i1, const ScoreIndex &i2)
+        # {
+        # return (i1.score > i2.score);
+        # }
+        # };
+        # /** \brief Initializes the sample pattern. */
+        # virtual void
+        # initPattern () = 0;
+        # /** \brief Non-max-suppression helper method.
+        # * \param[in] input the keypoint positions
+        # * \param[in] scores the keypoint scores computed on the image data
+        # * \param[out] output the resultant keypoints after non-max-supression
+        # */
+        # void
+        # applyNonMaxSuppression (const pcl::PointCloud<pcl::PointUV> &input, 
+        #                   const std::vector<ScoreIndex>& scores, 
+        #                   pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Computes corner scores for the specified points. 
+        # * \param im
+        # * \param corners_all
+        # * \param scores
+        # */
+        # void 
+        # computeCornerScores (const unsigned char* im, 
+        #                const std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > & corners_all, 
+        #                std::vector<ScoreIndex> & scores);
+        # /** \brief Computes corner scores for the specified points. 
+        # * \param im
+        # * \param corners_all
+        # * \param scores
+        # */
+        # void 
+        # computeCornerScores (const float* im, 
+        #                const std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > & corners_all, 
+        #                std::vector<ScoreIndex> & scores);
+        # /** \brief Width of the image to process. */
+        # size_t width_;
+        # /** \brief Height of the image to process. */
+        # size_t height_;
+        # /** \brief Threshold for corner detection. */
+        # double threshold_;
+        # /** \brief The maximum number of keypoints to return. */
+        # unsigned int nr_max_keypoints_;
+        # /** \brief Max image value. */
+        # double bmax_;
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace agast
+        # /** \brief Detector class for AGAST corner point detector (7_12s). 
+        # *        
+        # * Adapted from the C++ implementation of Elmar Mair 
+        # * (http://www6.in.tum.de/Main/ResearchAgast).
+        # *
+        # * \author Stefan Holzer
+        # * \ingroup keypoints
+        # */
+        # class PCL_EXPORTS AgastDetector7_12s : public AbstractAgastDetector
+        # AgastDetector7_12s (const size_t width, 
+        #           const size_t height, 
+        #           const double threshold,
+        #           const double bmax = 255) 
+        # public:
+        # typedef boost::shared_ptr<AgastDetector7_12s> Ptr;
+        # typedef boost::shared_ptr<const AgastDetector7_12s> ConstPtr;
+        # /** \brief Computes corner score. 
+        # * \param im 
+        # */
+        # int 
+        # computeCornerScore (const unsigned char* im) const;
+        # /** \brief Computes corner score. 
+        # * \param im 
+        # */
+        # int 
+        # computeCornerScore (const float* im) const;
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # * \param[out] corners_all the resultant set of keypoints detected
+        # */
+        # void 
+        # detect (const unsigned char* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # * \param[out] corners_all the resultant set of keypoints detected
+        # */
+        # void 
+        # detect (const float* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+        # protected:
+        # /** \brief Initializes the sample pattern. */
+        # void 
+        # initPattern ();
+###
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace agast
+        # /** \brief Detector class for AGAST corner point detector (5_8). 
+        # *        
+        # * Adapted from the C++ implementation of Elmar Mair 
+        # * (http://www6.in.tum.de/Main/ResearchAgast).
+        # *
+        # * \author Stefan Holzer
+        # * \ingroup keypoints
+        # */
+        # class PCL_EXPORTS AgastDetector5_8 : public AbstractAgastDetector
+        # public:
+            # typedef boost::shared_ptr<AgastDetector5_8> Ptr;
+            # typedef boost::shared_ptr<const AgastDetector5_8> ConstPtr;
+            # /** \brief Constructor. 
+            # * \param[in] width the width of the image to process
+            # * \param[in] height the height of the image to process
+            # * \param[in] threshold the corner detection threshold
+            # * \param[in] bmax the max image value (default: 255)
+            # */
+            # AgastDetector5_8 (const size_t width, 
+            #               const size_t height, 
+            #               const double threshold,
+            #               const double bmax = 255) 
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const unsigned char* im) const;
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const float* im) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const unsigned char* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const float* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # protected:
+            # /** \brief Initializes the sample pattern. */
+            # void initPattern ();
+###
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace agast
+        # /** \brief Detector class for AGAST corner point detector (OAST 9_16). 
+        #   *        
+        #   * Adapted from the C++ implementation of Elmar Mair 
+        #   * (http://www6.in.tum.de/Main/ResearchAgast).
+        #   *
+        #   * \author Stefan Holzer
+        #   * \ingroup keypoints
+        #   */
+        # class PCL_EXPORTS OastDetector9_16 : public AbstractAgastDetector
+            # public:
+            # typedef boost::shared_ptr<OastDetector9_16> Ptr;
+            # typedef boost::shared_ptr<const OastDetector9_16> ConstPtr;
+            # /** \brief Constructor. 
+            #   * \param[in] width the width of the image to process
+            #   * \param[in] height the height of the image to process
+            #   * \param[in] threshold the corner detection threshold
+            #   * \param[in] bmax the max image value (default: 255)
+            #   */
+            # OastDetector9_16 (const size_t width, 
+            #                   const size_t height, 
+            #                   const double threshold,
+            #                   const double bmax = 255) 
+            # 
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const unsigned char* im) const;
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const float* im) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const unsigned char* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const float* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # protected:
+            # /** \brief Initializes the sample pattern. */
+            # void initPattern ();
+###
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace internal
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <typename Out> 
+        # struct AgastApplyNonMaxSuppresion
+        # {
+        # AgastApplyNonMaxSuppresion (
+        #     const std::vector<unsigned char> &image_data, 
+        #     const pcl::PointCloud<pcl::PointUV> &tmp_cloud,
+        #     const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #     pcl::PointCloud<Out> &output)
+        # {
+        #   pcl::PointCloud<pcl::PointUV> output_temp;
+        #   detector->applyNonMaxSuppression (image_data, tmp_cloud, output_temp);
+        #   pcl::copyPointCloud<pcl::PointUV, Out> (output_temp, output);
+        # }
+        
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <>
+        # struct AgastApplyNonMaxSuppresion<pcl::PointUV>
+        # {
+        #   AgastApplyNonMaxSuppresion (
+        #       const std::vector<unsigned char> &image_data, 
+        #       const pcl::PointCloud<pcl::PointUV> &tmp_cloud,
+        #       const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #       pcl::PointCloud<pcl::PointUV> &output)
+        #   {
+        #     detector->applyNonMaxSuppression (image_data, tmp_cloud, output);
+        #   }
+        # };
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <typename Out> 
+        # struct AgastDetector
+        # {
+        #   AgastDetector (
+        #       const std::vector<unsigned char> &image_data, 
+        #       const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #       pcl::PointCloud<Out> &output)
+        #   {
+        #     pcl::PointCloud<pcl::PointUV> output_temp;
+        #     detector->detectKeypoints (image_data, output_temp);
+        #     pcl::copyPointCloud<pcl::PointUV, Out> (output_temp, output);
+        #   }
+        # };
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <>
+        # struct AgastDetector<pcl::PointUV>
+        # {
+        #   AgastDetector (
+        #       const std::vector<unsigned char> &image_data, 
+        #       const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #       pcl::PointCloud<pcl::PointUV> &output)
+        #   {
+        #     detector->detectKeypoints (image_data, output);
+        #   }
+        # };
+
+# namespace pcl
+# /** \brief Detects 2D AGAST corner points. Based on the original work and
+# * paper reference by
+# *
+# * \par
+# * Elmar Mair, Gregory D. Hager, Darius Burschka, Michael Suppa, and Gerhard Hirzinger. 
+# * Adaptive and generic corner detection based on the accelerated segment test. 
+# * In Proceedings of the European Conference on Computer Vision (ECCV'10), September 2010.
+# *
+# * \note This is an abstract base class. All children must implement a detectKeypoints method, based on the type of AGAST keypoint to be used.
+# *
+# * \author Stefan Holzer, Radu B. Rusu
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename IntensityT = pcl::common::IntensityFieldAccessor<PointInT> >
+# class AgastKeypoint2DBase : public Keypoint<PointInT, PointOutT>
+        # AgastKeypoint2DBase ()
+        # public:
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef pcl::keypoints::agast::AbstractAgastDetector::Ptr AgastDetectorPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+
+        # 
+        # /** \brief Sets the threshold for corner detection.
+        # * \param[in] threshold the threshold used for corner detection.
+        # */
+        # inline void setThreshold (const double threshold)
+        # /** \brief Get the threshold for corner detection, as set by the user. */
+        # inline double getThreshold ()
+        # /** \brief Sets the maximum number of keypoints to return. The
+        # * estimated keypoints are sorted by their internal score.
+        # * \param[in] nr_max_keypoints set the maximum number of keypoints to return
+        # */
+        # inline void setMaxKeypoints (const unsigned int nr_max_keypoints)
+        # /** \brief Get the maximum nuber of keypoints to return, as set by the user. */
+        # inline unsigned int getMaxKeypoints ()
+        # /** \brief Sets the max image data value (affects how many iterations AGAST does)
+        # * \param[in] bmax the max image data value
+        # */
+        # inline void setMaxDataValue (const double bmax)
+        # /** \brief Get the bmax image value, as set by the user. */
+        # inline double getMaxDataValue ()
+        # /** \brief Sets whether non-max-suppression is applied or not.
+        # * \param[in] enabled determines whether non-max-suppression is enabled.
+        # */
+        # inline void setNonMaxSuppression (const bool enabled)
+        # /** \brief Returns whether non-max-suppression is applied or not. */
+        # inline bool getNonMaxSuppression ()
+        # inline void setAgastDetector (const AgastDetectorPtr &detector)
+        # inline AgastDetectorPtr getAgastDetector ()
+        # protected:
+        # /** \brief Initializes everything and checks whether input data is fine. */
+        # bool initCompute ();
+        # /** \brief Detects the keypoints.
+        # * \param[out] output the resultant keypoints
+        # */
+        # virtual void detectKeypoints (PointCloudOut &output) = 0;
+        # /** \brief Intensity field accessor. */
+        # IntensityT intensity_;
+        # /** \brief Threshold for corner detection. */
+        # double threshold_;
+        # /** \brief Determines whether non-max-suppression is activated. */
+        # bool apply_non_max_suppression_;
+        # /** \brief Max image value. */
+        # double bmax_;
+        # /** \brief The Agast detector to use. */
+        # AgastDetectorPtr detector_;
+        # /** \brief The maximum number of keypoints to return. */
+        # unsigned int nr_max_keypoints_;
+### 
+
+# /** \brief Detects 2D AGAST corner points. Based on the original work and
+# * paper reference by
+# * \par
+# * Elmar Mair, Gregory D. Hager, Darius Burschka, Michael Suppa, and Gerhard Hirzinger. 
+# * Adaptive and generic corner detection based on the accelerated segment test. 
+# * In Proceedings of the European Conference on Computer Vision (ECCV'10), September 2010.
+# * Code example:
+# * \code
+# * pcl::PointCloud<pcl::PointXYZRGBA> cloud;
+# * pcl::AgastKeypoint2D<pcl::PointXYZRGBA> agast;
+# * agast.setThreshold (30);
+# * agast.setInputCloud (cloud);
+# * PointCloud<pcl::PointUV> keypoints;
+# * agast.compute (keypoints);
+# * \endcode
+# * \note The AGAST keypoint type used is 7_12s.
+# * \author Stefan Holzer, Radu B. Rusu
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT = pcl::PointUV>
+# class AgastKeypoint2D : public AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >
+        # AgastKeypoint2D()
+        # public:
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::intensity_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::threshold_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::bmax_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::apply_non_max_suppression_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::detector_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::nr_max_keypoints_;
+        # protected:
+        # /** \brief Detects the keypoints.
+        #  * \param[out] output the resultant keypoints
+        #  */
+        # virtual void detectKeypoints (PointCloudOut &output);
+
+# /** \brief Detects 2D AGAST corner points. Based on the original work and
+# * paper reference by
+# *
+# * \par
+# * Elmar Mair, Gregory D. Hager, Darius Burschka, Michael Suppa, and Gerhard Hirzinger. 
+# * Adaptive and generic corner detection based on the accelerated segment test. 
+# * In Proceedings of the European Conference on Computer Vision (ECCV'10), September 2010.
+# *
+# * Code example:
+# *
+# * \code
+# * pcl::PointCloud<pcl::PointXYZRGBA> cloud;
+# * pcl::AgastKeypoint2D<pcl::PointXYZRGBA> agast;
+# * agast.setThreshold (30);
+# * agast.setInputCloud (cloud);
+# *
+# * PointCloud<pcl::PointUV> keypoints;
+# * agast.compute (keypoints);
+# * \endcode
+# *
+# * \note This is a specialized version for PointXYZ clouds, and operates on depth (z) as float. The output keypoints are of the PointXY type.
+# * \note The AGAST keypoint type used is 7_12s.
+# *
+# * \author Stefan Holzer, Radu B. Rusu
+# * \ingroup keypoints
+# */
+# template <>
+# class AgastKeypoint2D<pcl::PointXYZ, pcl::PointUV>
+# : public AgastKeypoint2DBase<pcl::PointXYZ, pcl::PointUV, pcl::common::IntensityFieldAccessor<pcl::PointXYZ> > 
+#   public:
+#   AgastKeypoint2D ()
+#   protected:
+#   /** \brief Detects the keypoints.
+#   * \param[out] output the resultant keypoints
+#   */
+#   virtual void detectKeypoints (pcl::PointCloud<pcl::PointUV> &output);
+# 
+###
+
+# harris_3d.h
+# namespace pcl
+# /** \brief HarrisKeypoint3D uses the idea of 2D Harris keypoints, but instead of using image gradients, it uses
+# * surface normals.
+# * \author Suat Gedikli
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class HarrisKeypoint3D : public Keypoint<PointInT, PointOutT>
+        # /** \brief Constructor
+        #  * \param[in] method the method to be used to determine the corner responses
+        #  * \param[in] radius the radius for normal estimation as well as for non maxima suppression
+        #  * \param[in] threshold the threshold to filter out weak corners
+        #  */
+        # HarrisKeypoint3D (ResponseMethod method = HARRIS, float radius = 0.01f, float threshold = 0.0f)
+        # HarrisKeypoint3D ()
+        # public:
+        # typedef boost::shared_ptr<HarrisKeypoint3D<PointInT, PointOutT, NormalT> > Ptr;
+        # typedef boost::shared_ptr<const HarrisKeypoint3D<PointInT, PointOutT, NormalT> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # using Keypoint<PointInT, PointOutT>::initCompute;
+        # using PCLBase<PointInT>::setInputCloud;
+        # typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # virtual void setInputCloud (const PointCloudInConstPtr &cloud);
+        # /** \brief Set the method of the response to be calculated.
+        # * \param[in] type
+        # */
+        # void 
+        # setMethod (ResponseMethod type);
+        # /** \brief Set the radius for normal estimation and non maxima supression.
+        # * \param[in] radius
+        # */
+        # void 
+        # setRadius (float radius);
+        # /** \brief Set the threshold value for detecting corners. This is only evaluated if non maxima suppression is turned on.
+        # * \brief note non maxima suppression needs to be activated in order to use this feature.
+        # * \param[in] threshold
+        # */
+        # void 
+        # setThreshold (float threshold);
+        # /** \brief Whether non maxima suppression should be applied or the response for each point should be returned
+        # * \note this value needs to be turned on in order to apply thresholding and refinement
+        # * \param[in] nonmax default is false
+        # */
+        # void 
+        # setNonMaxSupression (bool = false);
+        # /** \brief Whether the detected key points should be refined or not. If turned of, the key points are a subset of the original point cloud. Otherwise the key points may be arbitrary.
+        # * \brief note non maxima supression needs to be on in order to use this feature.
+        # * \param[in] do_refine
+        # */
+        # void 
+        # setRefine (bool do_refine);
+        # /** \brief Set normals if precalculated normals are available.
+        # * \param normals
+        # */
+        # void 
+        # setNormals (const PointCloudNConstPtr &normals);
+        # /** \brief Provide a pointer to a dataset to add additional information
+        # * to estimate the features for every point in the input dataset.  This
+        # * is optional, if this is not set, it will only use the data in the
+        # * input cloud to estimate the features.  This is useful when you only
+        # * need to compute the features for a downsampled cloud.
+        # * \param[in] cloud a pointer to a PointCloud message
+        # */
+        # virtual void setSearchSurface (const PointCloudInConstPtr &cloud) { surface_ = cloud; normals_.reset(); }
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void setNumberOfThreads (unsigned int nr_threads = 0)
+        # protected:
+        # bool
+        # initCompute ();
+        # void detectKeypoints (PointCloudOut &output);
+        # /** \brief gets the corner response for valid input points*/
+        # void responseHarris (PointCloudOut &output) const;
+        # void responseNoble (PointCloudOut &output) const;
+        # void responseLowe (PointCloudOut &output) const;
+        # void responseTomasi (PointCloudOut &output) const;
+        # void responseCurvature (PointCloudOut &output) const;
+        # void refineCorners (PointCloudOut &corners) const;
+        # /** \brief calculates the upper triangular part of unnormalized covariance matrix over the normals given by the indices.*/
+        # void calculateNormalCovar (const std::vector<int>& neighbors, float* coefficients) const;
+###
+
+# harris_6d.h
+# namespace pcl
+# /** \brief Keypoint detector for detecting corners in 3D (XYZ), 2D (intensity) AND mixed versions of these.
+# * \author Suat Gedikli
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class HarrisKeypoint6D : public Keypoint<PointInT, PointOutT>
+        # /**
+        #  * @brief Constructor
+        #  * @param radius the radius for normal estimation as well as for non maxima suppression
+        #  * @param threshold the threshold to filter out weak corners
+        #  */
+        # HarrisKeypoint6D (float radius = 0.01, float threshold = 0.0)
+        # HarrisKeypoint6D ()
+        # public:
+        # typedef boost::shared_ptr<HarrisKeypoint6D<PointInT, PointOutT, NormalT> > Ptr;
+        # typedef boost::shared_ptr<const HarrisKeypoint6D<PointInT, PointOutT, NormalT> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # 
+        # /**
+        # * @brief set the radius for normal estimation and non maxima supression.
+        # * @param radius
+        # */
+        # void setRadius (float radius);
+        # /**
+        # * @brief set the threshold value for detecting corners. This is only evaluated if non maxima suppression is turned on.
+        # * @brief note non maxima suppression needs to be activated in order to use this feature.
+        # * @param threshold
+        # */
+        # void setThreshold (float threshold);
+        # /**
+        # * @brief whether non maxima suppression should be applied or the response for each point should be returned
+        # * @note this value needs to be turned on in order to apply thresholding and refinement
+        # * @param nonmax default is false
+        # */
+        # void setNonMaxSupression (bool = false);
+        # /**
+        # * @brief whether the detected key points should be refined or not. If turned of, the key points are a subset of the original point cloud. Otherwise the key points may be arbitrary.
+        # * @brief note non maxima supression needs to be on in order to use this feature.
+        # * @param do_refine
+        # */
+        # void setRefine (bool do_refine);
+        # virtual void
+        # setSearchSurface (const PointCloudInConstPtr &cloud) { surface_ = cloud; normals_->clear (); intensity_gradients_->clear ();}
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void
+        # setNumberOfThreads (unsigned int nr_threads = 0) { threads_ = nr_threads; }
+        # protected:
+        # void detectKeypoints (PointCloudOut &output);
+        # void responseTomasi (PointCloudOut &output) const;
+        # void refineCorners (PointCloudOut &corners) const;
+        # void calculateCombinedCovar (const std::vector<int>& neighbors, float* coefficients) const;
+###
+
+# iss_3d.h
+# namespace pcl
+# /** \brief ISSKeypoint3D detects the Intrinsic Shape Signatures keypoints for a given
+# * point cloud. This class is based on a particular implementation made by Federico
+# * Tombari and Samuele Salti and it has been explicitly adapted to PCL.
+# * For more information about the original ISS detector, see:
+# *\par
+# * Yu Zhong, “Intrinsic shape signatures: A shape descriptor for 3D object recognition,”
+# * Computer Vision Workshops (ICCV Workshops), 2009 IEEE 12th International Conference on ,
+# * vol., no., pp.689-696, Sept. 27 2009-Oct. 4 2009
+# * Code example:
+# * \code
+# * pcl::PointCloud<pcl::PointXYZRGBA>::Ptr model (new pcl::PointCloud<pcl::PointXYZRGBA> ());;
+# * pcl::PointCloud<pcl::PointXYZRGBA>::Ptr model_keypoints (new pcl::PointCloud<pcl::PointXYZRGBA> ());
+# * pcl::search::KdTree<pcl::PointXYZRGBA>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZRGBA> ());
+# * // Fill in the model cloud
+# * double model_resolution;
+# * // Compute model_resolution
+# * pcl::ISSKeypoint3D<pcl::PointXYZRGBA, pcl::PointXYZRGBA> iss_detector;
+# * iss_detector.setSearchMethod (tree);
+# * iss_detector.setSalientRadius (6 * model_resolution);
+# * iss_detector.setNonMaxRadius (4 * model_resolution);
+# * iss_detector.setThreshold21 (0.975);
+# * iss_detector.setThreshold32 (0.975);
+# * iss_detector.setMinNeighbors (5);
+# * iss_detector.setNumberOfThreads (4);
+# * iss_detector.setInputCloud (model);
+# * iss_detector.compute (*model_keypoints);
+# * \endcode
+# * \author Gioia Ballin
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class ISSKeypoint3D : public Keypoint<PointInT, PointOutT>
+        # /** \brief Constructor.
+        # * \param[in] salient_radius the radius of the spherical neighborhood used to compute the scatter matrix.
+        # */
+        # ISSKeypoint3D (double salient_radius = 0.0001)
+        # ISSKeypoint3D ()
+        # public:
+        # typedef boost::shared_ptr<ISSKeypoint3D<PointInT, PointOutT, NormalT> > Ptr;
+        # typedef boost::shared_ptr<const ISSKeypoint3D<PointInT, PointOutT, NormalT> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::octree::OctreePointCloudSearch<PointInT> OctreeSearchIn;
+        # typedef typename OctreeSearchIn::Ptr OctreeSearchInPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # 
+        #   /** \brief Set the radius of the spherical neighborhood used to compute the scatter matrix.
+        # * \param[in] salient_radius the radius of the spherical neighborhood
+        # */
+        # void
+        # setSalientRadius (double salient_radius);
+        # /** \brief Set the radius for the application of the non maxima supression algorithm.
+        # * \param[in] non_max_radius the non maxima suppression radius
+        # */
+        # void
+        # setNonMaxRadius (double non_max_radius);
+        # /** \brief Set the radius used for the estimation of the surface normals of the input cloud. If the radius is
+        # * too large, the temporal performances of the detector may degrade significantly.
+        # * \param[in] normal_radius the radius used to estimate surface normals
+        # */
+        # void
+        # setNormalRadius (double normal_radius);
+        # /** \brief Set the radius used for the estimation of the boundary points. If the radius is too large,
+        # * the temporal performances of the detector may degrade significantly.
+        # * \param[in] border_radius the radius used to compute the boundary points
+        # */
+        # void
+        # setBorderRadius (double border_radius);
+        # /** \brief Set the upper bound on the ratio between the second and the first eigenvalue.
+        # * \param[in] gamma_21 the upper bound on the ratio between the second and the first eigenvalue
+        # */
+        # void
+        # setThreshold21 (double gamma_21);
+        # /** \brief Set the upper bound on the ratio between the third and the second eigenvalue.
+        # * \param[in] gamma_32 the upper bound on the ratio between the third and the second eigenvalue
+        # */
+        # void
+        # setThreshold32 (double gamma_32);
+        # /** \brief Set the minimum number of neighbors that has to be found while applying the non maxima suppression algorithm.
+        # * \param[in] min_neighbors the minimum number of neighbors required
+        # */
+        # void
+        # setMinNeighbors (int min_neighbors);
+        # /** \brief Set the normals if pre-calculated normals are available.
+        # * \param[in] normals the given cloud of normals
+        # */
+        # void
+        # setNormals (const PointCloudNConstPtr &normals);
+        # /** \brief Set the decision boundary (angle threshold) that marks points as boundary or regular.
+        # * (default \f$\pi / 2.0\f$)
+        # * \param[in] angle the angle threshold
+        # */
+        # inline void setAngleThreshold (float angle)
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param[in] nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void setNumberOfThreads (unsigned int nr_threads = 0)
+        # protected:
+        # /** \brief Compute the boundary points for the given input cloud.
+        # * \param[in] input the input cloud
+        # * \param[in] border_radius the radius used to compute the boundary points
+        # * \param[in] angle_threshold the decision boundary that marks the points as boundary
+        # * \return the vector of boolean values in which the information about the boundary points is stored
+        # */
+        # bool* getBoundaryPoints (PointCloudIn &input, double border_radius, float angle_threshold);
+        # /** \brief Compute the scatter matrix for a point index.
+        # * \param[in] current_index the index of the point
+        # * \param[out] cov_m the point scatter matrix
+        # */
+        # void getScatterMatrix (const int &current_index, Eigen::Matrix3d &cov_m);
+        # /** \brief Perform the initial checks before computing the keypoints.
+        # *  \return true if all the checks are passed, false otherwise
+        # */
+        # bool initCompute ();
+        # /** \brief Detect the keypoints by performing the EVD of the scatter matrix.
+        # * \param[out] output the resultant cloud of keypoints
+        # */
+        # void detectKeypoints (PointCloudOut &output);
+        # /** \brief The radius of the spherical neighborhood used to compute the scatter matrix.*/
+        # double salient_radius_;
+        # /** \brief The non maxima suppression radius. */
+        # double non_max_radius_;
+        # /** \brief The radius used to compute the normals of the input cloud. */
+        # double normal_radius_;
+        # /** \brief The radius used to compute the boundary points of the input cloud. */
+        # double border_radius_;
+        # /** \brief The upper bound on the ratio between the second and the first eigenvalue returned by the EVD. */
+        # double gamma_21_;
+        # /** \brief The upper bound on the ratio between the third and the second eigenvalue returned by the EVD. */
+        # double gamma_32_;
+        # /** \brief Store the third eigen value associated to each point in the input cloud. */
+        # double *third_eigen_value_;
+        # /** \brief Store the information about the boundary points of the input cloud. */
+        # bool *edge_points_;
+        # /** \brief Minimum number of neighbors that has to be found while applying the non maxima suppression algorithm. */
+        # int min_neighbors_;
+        # /** \brief The cloud of normals related to the input surface. */
+        # PointCloudNConstPtr normals_;
+        # /** \brief The decision boundary (angle threshold) that marks points as boundary or regular. (default \f$\pi / 2.0\f$) */
+        # float angle_threshold_;
+        # /** \brief The number of threads that has to be used by the scheduler. */
+        # unsigned int threads_;
+#### 
+
+# # susan.h
+# namespace pcl
+# /** \brief SUSANKeypoint implements a RGB-D extension of the SUSAN detector inluding normal 
+#  * directions variation in top of intensity variation. 
+#  * It is different from Harris in that it exploits normals directly so it is faster.  
+#  * Original paper "SUSAN 窶A New Approach to Low Level Image Processing", Smith,
+#  * Stephen M. and Brady, J. Michael 
+#  *
+#  * \author Nizar Sallem 
+#  * \ingroup keypoints
+#  */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal, typename IntensityT= pcl::common::IntensityFieldAccessor<PointInT> >
+# class SUSANKeypoint : public Keypoint<PointInT, PointOutT>
+        # /** \brief Constructor
+        #   * \param[in] radius the radius for normal estimation as well as for non maxima suppression
+        #   * \param[in] distance_threshold to test if the nucleus is far enough from the centroid
+        #   * \param[in] angular_threshold to test if normals are parallel
+        #   * \param[in] intensity_threshold to test if points are of same color
+        #   */
+        # SUSANKeypoint (float radius = 0.01f, 
+        #                float distance_threshold = 0.001f, 
+        #                float angular_threshold = 0.0001f, 
+        #                float intensity_threshold = 7.0f)
+        # SUSANKeypoint()
+        # public:
+        # typedef boost::shared_ptr<SUSANKeypoint<PointInT, PointOutT, NormalT, IntensityT> > Ptr;
+        # typedef boost::shared_ptr<const SUSANKeypoint<PointInT, PointOutT, NormalT, Intensity> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # using Keypoint<PointInT, PointOutT>::initCompute;
+        # /** \brief set the radius for normal estimation and non maxima supression.
+        # * \param[in] radius
+        # */
+        # void setRadius (float radius);
+        # void setDistanceThreshold (float distance_threshold);
+        # /** \brief set the angular_threshold value for detecting corners. Normals are considered as 
+        # * parallel if 1 - angular_threshold <= (Ni.Nj) <= 1
+        # * \param[in] angular_threshold
+        # */
+        # void setAngularThreshold (float angular_threshold);
+        # /** \brief set the intensity_threshold value for detecting corners. 
+        # * \param[in] intensity_threshold
+        # */
+        # void setIntensityThreshold (float intensity_threshold);
+        # /**
+        # * \brief set normals if precalculated normals are available.
+        # * \param normals
+        # */
+        # void setNormals (const PointCloudNConstPtr &normals);
+        # virtual void setSearchSurface (const PointCloudInConstPtr &cloud);
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # void setNumberOfThreads (unsigned int nr_threads);
+        # /** \brief Apply non maxima suppression to the responses to keep strongest corners.
+        # * \note in SUSAN points with less response or stronger corners
+        # */
+        # void setNonMaxSupression (bool nonmax);
+        # /** \brief Filetr false positive using geometric criteria. 
+        # * The nucleus and the centroid should at least distance_threshold_ from each other AND all the 
+        # * points belonging to the USAN must be within the segment [nucleus centroid].
+        # * \param[in] validate 
+        # */
+        # void setGeometricValidation (bool validate);
+        # protected:
+        # bool initCompute ();
+        # void detectKeypoints (PointCloudOut &output);
+        # /** \brief return true if a point lies within the line between the nucleus and the centroid
+        # * \param[in] nucleus coordinate of the nucleus
+        # * \param[in] centroid of the SUSAN
+        # * \param[in] nc to centroid vector (used to speed up since it is constant for a given
+        # * neighborhood)
+        # * \param[in] point the query point to test against
+        # * \return true if the point lies within [nucleus centroid]
+        # */
+        # bool isWithinNucleusCentroid (const Eigen::Vector3f& nucleus,
+        #                        const Eigen::Vector3f& centroid,
+        #                        const Eigen::Vector3f& nc,
+        #                        const PointInT& point) const;
+###
+
+
+# harris_3d.h
+###
+
+# harris_6d.h
+###
+
+# iss_3d.h
+###
+
+
diff --git a/pcl/pcl_keypoints_180.pxd b/pcl/pcl_keypoints_180.pxd
new file mode 100644
index 0000000..ac852e4
--- /dev/null
+++ b/pcl/pcl_keypoints_180.pxd
@@ -0,0 +1,1295 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# pcl
+cimport pcl_defs as cpp
+cimport pcl_features_172 as pclftr
+cimport pcl_kdtree_172 as pclkdt
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# keypoint.h
+# template <typename PointInT, typename PointOutT>
+# class Keypoint : public PCLBase<PointInT>
+cdef extern from "pcl/keypoints/keypoint.h" namespace "pcl":
+    cdef cppclass Keypoint[In, Out](cpp.PCLBase[In]):
+        Keypoint ()
+        # public:
+        # brief Provide a pointer to the input dataset that we need to estimate features at every point for.
+        # param cloud the const boost shared pointer to a PointCloud message
+        # void setSearchSurface (const PointCloudInConstPtr &cloud)
+        # void setSearchSurface (const PointCloud[In] &cloud)
+        
+        # brief Get a pointer to the surface point cloud dataset.
+        # PointCloudInConstPtr getSearchSurface ()
+        # PointCloud[In] getSearchSurface ()
+        
+        # brief Provide a pointer to the search object.
+        # param tree a pointer to the spatial search object.
+        # void setSearchMethod (const KdTreePtr &tree)
+        # void setSearchMethod (-.KdTree &tree)
+        
+        # brief Get a pointer to the search method used.
+        # KdTreePtr getSearchMethod ()
+        # -.KdTree getSearchMethod ()
+        
+        # brief Get the internal search parameter.
+        double getSearchParameter ()
+        
+        # brief Set the number of k nearest neighbors to use for the feature estimation.
+        # param k the number of k-nearest neighbors
+        void setKSearch (int k)
+        
+        # brief get the number of k nearest neighbors used for the feature estimation. */
+        int getKSearch ()
+        
+        # brief Set the sphere radius that is to be used for determining the nearest neighbors used for the key point detection
+        # param radius the sphere radius used as the maximum distance to consider a point a neighbor
+        void setRadiusSearch (double radius)
+        
+        # brief Get the sphere radius used for determining the neighbors. */
+        double getRadiusSearch ()
+        
+        # brief Base method for key point detection for all points given in <setInputCloud (), setIndices ()> using
+        # the surface in setSearchSurface () and the spatial locator in setSearchMethod ()
+        # param output the resultant point cloud model dataset containing the estimated features
+        # inline void compute (PointCloudOut &output);
+        void compute (cpp.PointCloud[Out] &output)
+        
+        # brief Search for k-nearest neighbors using the spatial locator from \a setSearchmethod, and the given surface
+        # from \a setSearchSurface.
+        # param index the index of the query point
+        # param parameter the search parameter (either k or radius)
+        # param indices the resultant vector of indices representing the k-nearest neighbors
+        # param distances the resultant vector of distances representing the distances from the query point to the
+        # k-nearest neighbors
+        # inline int searchForNeighbors (int index, double parameter, vector[int] &indices, vector[float] &distances)
+        int searchForNeighbors (int index, double parameter, vector[int] &indices, vector[float] &distances)
+
+
+###
+
+# harris_keypoint3D.h (1.6.0)
+# harris_3d.h (1.7.2)
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class HarrisKeypoint3D : public Keypoint<PointInT, PointOutT>
+cdef extern from "pcl/keypoints/harris_3d.h" namespace "pcl":
+    cdef cppclass HarrisKeypoint3D[In, Out, NormalT](Keypoint[In, Out]):
+        HarrisKeypoint3D ()
+        # HarrisKeypoint3D (ResponseMethod method = HARRIS, float radius = 0.01f, float threshold = 0.0f)
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        
+        # typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+        
+        # brief Set the method of the response to be calculated.
+        # param[in] type
+        # void setMethod (ResponseMethod type)
+        # void setMethod (ResponseMethod2 type)
+        void setMethod (int type)
+        
+        # * \brief Set the radius for normal estimation and non maxima supression.
+        # * \param[in] radius
+        # void setRadius (float radius)
+        void setRadius (float radius)
+        
+        # * \brief Set the threshold value for detecting corners. This is only evaluated if non maxima suppression is turned on.
+        # * \brief note non maxima suppression needs to be activated in order to use this feature.
+        # * \param[in] threshold
+        void setThreshold (float threshold)
+        
+        # * \brief Whether non maxima suppression should be applied or the response for each point should be returned
+        # * \note this value needs to be turned on in order to apply thresholding and refinement
+        # * \param[in] nonmax default is false
+        # void setNonMaxSupression (bool = false)
+        void setNonMaxSupression (bool param)
+        
+        # * \brief Whether the detected key points should be refined or not. If turned of, the key points are a subset of the original point cloud. Otherwise the key points may be arbitrary.
+        # * \brief note non maxima supression needs to be on in order to use this feature.
+        # * \param[in] do_refine
+        void setRefine (bool do_refine)
+        
+        # * \brief Set normals if precalculated normals are available.
+        # * \param normals
+        # void setNormals (const PointCloudNPtr &normals)
+        # void setNormals (const cpp.PointCloud[NormalT] &normals)
+        
+        # * \brief Provide a pointer to a dataset to add additional information
+        # * to estimate the features for every point in the input dataset.  This
+        # * is optional, if this is not set, it will only use the data in the
+        # * input cloud to estimate the features.  This is useful when you only
+        # * need to compute the features for a downsampled cloud.
+        # * \param[in] cloud a pointer to a PointCloud message
+        # virtual void setSearchSurface (const PointCloudInConstPtr &cloud)
+        # void setSearchSurface (const PointCloudInConstPtr &cloud)
+        
+        # * \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        # inline void setNumberOfThreads (int nr_threads)
+        void setNumberOfThreads (int nr_threads)
+
+
+ctypedef HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZI_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGB_t
+ctypedef HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal] HarrisKeypoint3D_PointXYZRGBA_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZ, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3DPtr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZI, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZI_Ptr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGB, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[HarrisKeypoint3D[cpp.PointXYZRGBA, cpp.PointXYZI, cpp.Normal]] HarrisKeypoint3D_PointXYZRGBA_Ptr_t
+###
+
+# narf_keypoint.h
+# class PCL_EXPORTS NarfKeypoint : public Keypoint<PointWithRange, int>
+cdef extern from "pcl/keypoints/narf_keypoint.h" namespace "pcl":
+    cdef cppclass NarfKeypoint(Keypoint[cpp.PointWithRange, int]):
+        NarfKeypoint ()
+        NarfKeypoint (pclftr.RangeImageBorderExtractor range_image_border_extractor, float support_size)
+        # NarfKeypoint (RangeImageBorderExtractor* range_image_border_extractor=NULL, float support_size=-1.0f);
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef Keypoint<PointWithRange, int> BaseClass;
+        # typedef Keypoint<PointWithRange, int>::PointCloudOut PointCloudOut;
+        # // =====PUBLIC STRUCTS=====
+        # //! Parameters used in this class
+        # cdef struct Parameters
+        # {
+        #     Parameters() : support_size(-1.0f), max_no_of_interest_points(-1), min_distance_between_interest_points(0.25f),
+        #            optimal_distance_to_high_surface_change(0.25), min_interest_value(0.45f),
+        #            min_surface_change_score(0.2f), optimal_range_image_patch_size(10),
+        #            distance_for_additional_points(0.0f), add_points_on_straight_edges(false),
+        #            do_non_maximum_suppression(true), no_of_polynomial_approximations_per_point(0),
+        #            max_no_of_threads(1), use_recursive_scale_reduction(false),
+        #            calculate_sparse_interest_image(true) {}
+        # 
+        #     float support_size;  //!< This defines the area 'covered' by an interest point (in meters)
+        #     int max_no_of_interest_points;  //!< The maximum number of interest points that will be returned
+        #     float min_distance_between_interest_points;  /**< Minimum distance between maximas
+        #                                            *  (this is a factor for support_size, i.e. the distance is
+        #                                            *  min_distance_between_interest_points*support_size) */
+        #     float optimal_distance_to_high_surface_change;  /**< The distance we want keep between keypoints and areas
+        #                                               *  of high surface change
+        #                                               *  (this is a factor for support_size, i.e., the distance is
+        #                                               *  optimal_distance_to_high_surface_change*support_size) */
+        #     float min_interest_value;  //!< The minimum value to consider a point as an interest point
+        #     float min_surface_change_score;  //!< The minimum value  of the surface change score to consider a point
+        #     int optimal_range_image_patch_size;  /**< The size (in pixels) of the image patches from which the interest value
+        #                                    *  should be computed. This influences, which range image is selected from
+        #                                    *  the scale space to compute the interest value of a pixel at a certain
+        #                                    *  distance. */
+        #     // TODO:
+        #     float distance_for_additional_points;  /**< All points in this distance to a found maximum, that
+        #                                      *  are above min_interest_value are also added as interest points
+        #                                      *  (this is a factor for support_size, i.e. the distance is
+        #                                      *  distance_for_additional_points*support_size) */
+        #     bool add_points_on_straight_edges;  /**< If this is set to true, there will also be interest points on
+        #                                   *   straight edges, e.g., just indicating an area of high surface change */
+        #     bool do_non_maximum_suppression;  /**< If this is set to false there will be much more points
+        #                                 *  (can be used to spread points over the whole scene
+        #                                 *  (combined with a low min_interest_value)) */
+        #     bool no_of_polynomial_approximations_per_point; /**< If this is >0, the exact position of the interest point is
+        #                                                  determined using bivariate polynomial approximations of the
+        #                                                  interest values of the area. */
+        #     int max_no_of_threads;  //!< The maximum number of threads this code is allowed to use with OPNEMP
+        #     bool use_recursive_scale_reduction;  /**< Try to decrease runtime by extracting interest points at lower reolution
+        #                                    *  in areas that contain enough points, i.e., have lower range. */
+        #     bool calculate_sparse_interest_image;  /**< Use some heuristics to decide which areas of the interest image
+        #                                         can be left out to improve the runtime. */
+        # };
+        # 
+        # =====PUBLIC METHODS=====
+        # Erase all data calculated for the current range image
+        void clearData ()
+        
+        # //! Set the RangeImageBorderExtractor member (required)
+        # void setRangeImageBorderExtractor (RangeImageBorderExtractor* range_image_border_extractor);
+        void setRangeImageBorderExtractor (pclftr.RangeImageBorderExtractor range_image_border_extractor)
+        
+        # //! Get the RangeImageBorderExtractor member
+        # RangeImageBorderExtractor* getRangeImageBorderExtractor ()
+        pclftr.RangeImageBorderExtractor getRangeImageBorderExtractor ()
+        
+        # //! Set the RangeImage member of the RangeImageBorderExtractor
+        # void setRangeImage (const RangeImage* range_image)
+        # void setRangeImage (const RangeImage_Ptr range_image)
+        
+        # /** Extract interest value per image point */
+        # float* getInterestImage () { calculateInterestImage(); return interest_image_;}
+        # float[] getInterestImage ()
+        
+        # //! Extract maxima from an interest image
+        # const ::pcl::PointCloud<InterestPoint>& getInterestPoints () { calculateInterestPoints(); return *interest_points_;}
+        
+        # //! Set all points in the image that are interest points to true, the rest to false
+        # const std::vector<bool>& getIsInterestPointImage ()
+        
+        # //! Getter for the parameter struct
+        # Parameters& getParameters ()
+        
+        # //! Getter for the range image of range_image_border_extractor_
+        # const RangeImage& getRangeImage ();
+        
+        # //! Overwrite the compute function of the base class
+        # void compute (PointCloudOut& output);
+
+# ingroup keypoints
+# operator
+# inline std::ostream& operator << (std::ostream& os, const NarfKeypoint::Parameters& p)
+
+ctypedef NarfKeypoint NarfKeypoint_t
+ctypedef shared_ptr[NarfKeypoint] NarfKeypointPtr_t
+###
+
+# sift_keypoint.h
+# template <typename PointInT, typename PointOutT>
+# class SIFTKeypoint : public Keypoint<PointInT, PointOutT>
+cdef extern from "pcl/keypoints/sift_keypoint.h" namespace "pcl":
+    cdef cppclass SIFTKeypoint[In, Out](Keypoint[In, Out]):
+        SIFTKeypoint ()
+        # public:
+        # /** \brief Specify the range of scales over which to search for keypoints
+        # * \param min_scale the standard deviation of the smallest scale in the scale space
+        # * \param nr_octaves the number of octaves (i.e. doublings of scale) to compute 
+        # * \param nr_scales_per_octave the number of scales to compute within each octave
+        void setScales (float min_scale, int nr_octaves, int nr_scales_per_octave)
+        
+        # /** \brief Provide a threshold to limit detection of keypoints without sufficient contrast
+        # * \param min_contrast the minimum contrast required for detection
+        void setMinimumContrast (float min_contrast)
+
+
+# pcl::SIFTKeypoint<pcl::PointNormal, pcl::PointWithScale> sift;
+ctypedef SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale] SIFTKeypoint_t
+ctypedef shared_ptr[SIFTKeypoint[cpp.PointNormal, cpp.PointWithScale]] SIFTKeypointPtr_t
+###
+
+# smoothed_surfaces_keypoint.h
+# template <typename PointT, typename PointNT>
+# class SmoothedSurfacesKeypoint : public Keypoint <PointT, PointT>
+cdef extern from "pcl/keypoints/smoothed_surfaces_keypoint.h" namespace "pcl":
+    cdef cppclass SmoothedSurfacesKeypoint[In, Out](Keypoint[In, Out]):
+        SmoothedSurfacesKeypoint ()
+        # public:
+        # void addSmoothedPointCloud (const PointCloudTConstPtr &cloud, const PointCloudNTConstPtr &normals, KdTreePtr &kdtree, float &scale);
+        
+        void resetClouds ()
+        
+        # inline void setNeighborhoodConstant (float neighborhood_constant)
+        
+        # inline float getNeighborhoodConstant ()
+        
+        # inline void setInputNormals (const PointCloudNTConstPtr &normals)
+        
+        # inline void setInputScale (float input_scale)
+        
+        # void detectKeypoints (PointCloudT &output);
+
+
+###
+
+# uniform_sampling.h
+# template <typename PointInT>
+# class UniformSampling: public Keypoint<PointInT, int>
+cdef extern from "pcl/keypoints/uniform_sampling.h" namespace "pcl":
+    cdef cppclass UniformSampling[In](Keypoint[In, int]):
+        UniformSampling ()
+        # public:
+        # brief Set the 3D grid leaf size.
+        # param radius the 3D grid leaf size
+        void setRadiusSearch (double radius)
+
+
+ctypedef UniformSampling[cpp.PointXYZ] UniformSampling_t
+ctypedef UniformSampling[cpp.PointXYZI] UniformSampling_PointXYZI_t
+ctypedef UniformSampling[cpp.PointXYZRGB] UniformSampling_PointXYZRGB_t
+ctypedef UniformSampling[cpp.PointXYZRGBA] UniformSampling_PointXYZRGBA_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZ]] UniformSamplingPtr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZI]] UniformSampling_PointXYZI_Ptr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGB]] UniformSampling_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[UniformSampling[cpp.PointXYZRGBA]] UniformSampling_PointXYZRGBA_Ptr_t
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# 1.6.0
+# NG : use Template parameters Class Internal
+# typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+
+# 1.7.2
+# NG : use Template parameters Class Internal
+# RESPONSEMETHOD_HARRIS "pcl::HarrisKeypoint3D::HARRIS", 
+# RESPONSEMETHOD_NOBLE "pcl::HarrisKeypoint3D::NOBLE", 
+# RESPONSEMETHOD_LOWE "pcl::HarrisKeypoint3D::LOWE", 
+# RESPONSEMETHOD_TOMASI "pcl::HarrisKeypoint3D::TOMASI", 
+# RESPONSEMETHOD_CURVATURE "pcl::HarrisKeypoint3D::CURVATURE"
+
+
+############################
+# 1.7.2 Add
+
+# agast_2d.h
+# namespace pcl
+# namespace keypoints
+# namespace agast
+# /** \brief Abstract detector class for AGAST corner point detectors.
+#  * Adapted from the C++ implementation of Elmar Mair 
+#  * (http://www6.in.tum.de/Main/ResearchAgast).
+#  * \author Stefan Holzer
+#  * \ingroup keypoints
+#  */
+# class PCL_EXPORTS AbstractAgastDetector
+        # AbstractAgastDetector (const size_t width, 
+        #                        const size_t height, 
+        #                        const double threshold,
+        #                        const double bmax) 
+        # public:
+        # typedef boost::shared_ptr<AbstractAgastDetector> Ptr;
+        # typedef boost::shared_ptr<const AbstractAgastDetector> ConstPtr;
+        # /** \brief Constructor. 
+        # * \param[in] width the width of the image to process
+        # * \param[in] height the height of the image to process
+        # * \param[in] threshold the corner detection threshold
+        # * \param[in] bmax the max image value (default: 255)
+        # */
+        # /** \brief Detects corner points. 
+        # * \param intensity_data
+        # * \param output
+        # */
+        # void 
+        # detectKeypoints (const std::vector<unsigned char> &intensity_data, 
+        #            pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Detects corner points. 
+        # * \param intensity_data
+        # * \param output
+        # */
+        # void 
+        # detectKeypoints (const std::vector<float> &intensity_data, 
+        #            pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Applies non-max-suppression. 
+        # * \param[in] intensity_data the image data
+        # * \param[in] input the keypoint positions
+        # * \param[out] output the resultant keypoints after non-max-supression
+        # */
+        # void
+        # applyNonMaxSuppression (const std::vector<unsigned char>& intensity_data, 
+        #                   const pcl::PointCloud<pcl::PointUV> &input, 
+        #                   pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Applies non-max-suppression. 
+        # * \param[in] intensity_data the image data
+        # * \param[in] input the keypoint positions
+        # * \param[out] output the resultant keypoints after non-max-supression
+        # */
+        # void
+        # applyNonMaxSuppression (const std::vector<float>& intensity_data, 
+        #                   const pcl::PointCloud<pcl::PointUV> &input, 
+        #                   pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Computes corner score. 
+        # * \param[in] im the pixels to compute the score at
+        # */
+        # virtual int 
+        # computeCornerScore (const unsigned char* im) const = 0;
+        # /** \brief Computes corner score. 
+        # * \param[in] im the pixels to compute the score at
+        # */
+        # virtual int 
+        # computeCornerScore (const float* im) const = 0;
+        # /** \brief Sets the threshold for corner detection.
+        # * \param[in] threshold the threshold used for corner detection.
+        # */
+        # inline void
+        # setThreshold (const double threshold)
+        # /** \brief Get the threshold for corner detection, as set by the user. */
+        # inline double
+        # getThreshold ()
+        # /** \brief Sets the maximum number of keypoints to return. The
+        # * estimated keypoints are sorted by their internal score.
+        # * \param[in] nr_max_keypoints set the maximum number of keypoints to return
+        # */
+        # inline void
+        # setMaxKeypoints (const unsigned int nr_max_keypoints)
+        # /** \brief Get the maximum nuber of keypoints to return, as set by the user. */
+        # inline unsigned int 
+        # getMaxKeypoints ()
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # * \param[out] corners_all the resultant set of keypoints detected
+        # */
+        # virtual void 
+        # detect (const unsigned char* im, 
+        #   std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const = 0;
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # */
+        # virtual void 
+        # detect (const float* im, 
+        #   std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &) const = 0;
+        # protected:
+        # /** \brief Structure holding an index and the associated keypoint score. */
+        # struct ScoreIndex
+        # {
+        # int idx;
+        # int score;
+        # };
+        # /** \brief Score index comparator. */
+        # struct CompareScoreIndex
+        # {
+        # /** \brief Comparator
+        # * \param[in] i1 the first score index
+        # * \param[in] i2 the second score index
+        # */
+        # inline bool
+        # operator() (const ScoreIndex &i1, const ScoreIndex &i2)
+        # {
+        # return (i1.score > i2.score);
+        # }
+        # };
+        # /** \brief Initializes the sample pattern. */
+        # virtual void
+        # initPattern () = 0;
+        # /** \brief Non-max-suppression helper method.
+        # * \param[in] input the keypoint positions
+        # * \param[in] scores the keypoint scores computed on the image data
+        # * \param[out] output the resultant keypoints after non-max-supression
+        # */
+        # void
+        # applyNonMaxSuppression (const pcl::PointCloud<pcl::PointUV> &input, 
+        #                   const std::vector<ScoreIndex>& scores, 
+        #                   pcl::PointCloud<pcl::PointUV> &output);
+        # /** \brief Computes corner scores for the specified points. 
+        # * \param im
+        # * \param corners_all
+        # * \param scores
+        # */
+        # void 
+        # computeCornerScores (const unsigned char* im, 
+        #                const std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > & corners_all, 
+        #                std::vector<ScoreIndex> & scores);
+        # /** \brief Computes corner scores for the specified points. 
+        # * \param im
+        # * \param corners_all
+        # * \param scores
+        # */
+        # void 
+        # computeCornerScores (const float* im, 
+        #                const std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > & corners_all, 
+        #                std::vector<ScoreIndex> & scores);
+        # /** \brief Width of the image to process. */
+        # size_t width_;
+        # /** \brief Height of the image to process. */
+        # size_t height_;
+        # /** \brief Threshold for corner detection. */
+        # double threshold_;
+        # /** \brief The maximum number of keypoints to return. */
+        # unsigned int nr_max_keypoints_;
+        # /** \brief Max image value. */
+        # double bmax_;
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace agast
+        # /** \brief Detector class for AGAST corner point detector (7_12s). 
+        # *        
+        # * Adapted from the C++ implementation of Elmar Mair 
+        # * (http://www6.in.tum.de/Main/ResearchAgast).
+        # *
+        # * \author Stefan Holzer
+        # * \ingroup keypoints
+        # */
+        # class PCL_EXPORTS AgastDetector7_12s : public AbstractAgastDetector
+        # AgastDetector7_12s (const size_t width, 
+        #           const size_t height, 
+        #           const double threshold,
+        #           const double bmax = 255) 
+        # public:
+        # typedef boost::shared_ptr<AgastDetector7_12s> Ptr;
+        # typedef boost::shared_ptr<const AgastDetector7_12s> ConstPtr;
+        # /** \brief Computes corner score. 
+        # * \param im 
+        # */
+        # int 
+        # computeCornerScore (const unsigned char* im) const;
+        # /** \brief Computes corner score. 
+        # * \param im 
+        # */
+        # int 
+        # computeCornerScore (const float* im) const;
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # * \param[out] corners_all the resultant set of keypoints detected
+        # */
+        # void 
+        # detect (const unsigned char* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+        # /** \brief Detects points of interest (i.e., keypoints) in the given image
+        # * \param[in] im the image to detect keypoints in 
+        # * \param[out] corners_all the resultant set of keypoints detected
+        # */
+        # void 
+        # detect (const float* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+        # protected:
+        # /** \brief Initializes the sample pattern. */
+        # void 
+        # initPattern ();
+###
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace agast
+        # /** \brief Detector class for AGAST corner point detector (5_8). 
+        # *        
+        # * Adapted from the C++ implementation of Elmar Mair 
+        # * (http://www6.in.tum.de/Main/ResearchAgast).
+        # *
+        # * \author Stefan Holzer
+        # * \ingroup keypoints
+        # */
+        # class PCL_EXPORTS AgastDetector5_8 : public AbstractAgastDetector
+        # public:
+            # typedef boost::shared_ptr<AgastDetector5_8> Ptr;
+            # typedef boost::shared_ptr<const AgastDetector5_8> ConstPtr;
+            # /** \brief Constructor. 
+            # * \param[in] width the width of the image to process
+            # * \param[in] height the height of the image to process
+            # * \param[in] threshold the corner detection threshold
+            # * \param[in] bmax the max image value (default: 255)
+            # */
+            # AgastDetector5_8 (const size_t width, 
+            #               const size_t height, 
+            #               const double threshold,
+            #               const double bmax = 255) 
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const unsigned char* im) const;
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const float* im) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const unsigned char* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const float* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # protected:
+            # /** \brief Initializes the sample pattern. */
+            # void initPattern ();
+###
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace agast
+        # /** \brief Detector class for AGAST corner point detector (OAST 9_16). 
+        #   *        
+        #   * Adapted from the C++ implementation of Elmar Mair 
+        #   * (http://www6.in.tum.de/Main/ResearchAgast).
+        #   *
+        #   * \author Stefan Holzer
+        #   * \ingroup keypoints
+        #   */
+        # class PCL_EXPORTS OastDetector9_16 : public AbstractAgastDetector
+            # public:
+            # typedef boost::shared_ptr<OastDetector9_16> Ptr;
+            # typedef boost::shared_ptr<const OastDetector9_16> ConstPtr;
+            # /** \brief Constructor. 
+            #   * \param[in] width the width of the image to process
+            #   * \param[in] height the height of the image to process
+            #   * \param[in] threshold the corner detection threshold
+            #   * \param[in] bmax the max image value (default: 255)
+            #   */
+            # OastDetector9_16 (const size_t width, 
+            #                   const size_t height, 
+            #                   const double threshold,
+            #                   const double bmax = 255) 
+            # 
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const unsigned char* im) const;
+            # /** \brief Computes corner score. 
+            # * \param im 
+            # */
+            # int computeCornerScore (const float* im) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const unsigned char* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # /** \brief Detects points of interest (i.e., keypoints) in the given image
+            # * \param[in] im the image to detect keypoints in 
+            # * \param[out] corners_all the resultant set of keypoints detected
+            # */
+            # void detect (const float* im, std::vector<pcl::PointUV, Eigen::aligned_allocator<pcl::PointUV> > &corners_all) const;
+            # protected:
+            # /** \brief Initializes the sample pattern. */
+            # void initPattern ();
+###
+
+        # namespace pcl
+        # namespace keypoints
+        # namespace internal
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <typename Out> 
+        # struct AgastApplyNonMaxSuppresion
+        # {
+        # AgastApplyNonMaxSuppresion (
+        #     const std::vector<unsigned char> &image_data, 
+        #     const pcl::PointCloud<pcl::PointUV> &tmp_cloud,
+        #     const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #     pcl::PointCloud<Out> &output)
+        # {
+        #   pcl::PointCloud<pcl::PointUV> output_temp;
+        #   detector->applyNonMaxSuppression (image_data, tmp_cloud, output_temp);
+        #   pcl::copyPointCloud<pcl::PointUV, Out> (output_temp, output);
+        # }
+        
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <>
+        # struct AgastApplyNonMaxSuppresion<pcl::PointUV>
+        # {
+        #   AgastApplyNonMaxSuppresion (
+        #       const std::vector<unsigned char> &image_data, 
+        #       const pcl::PointCloud<pcl::PointUV> &tmp_cloud,
+        #       const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #       pcl::PointCloud<pcl::PointUV> &output)
+        #   {
+        #     detector->applyNonMaxSuppression (image_data, tmp_cloud, output);
+        #   }
+        # };
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <typename Out> 
+        # struct AgastDetector
+        # {
+        #   AgastDetector (
+        #       const std::vector<unsigned char> &image_data, 
+        #       const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #       pcl::PointCloud<Out> &output)
+        #   {
+        #     pcl::PointCloud<pcl::PointUV> output_temp;
+        #     detector->detectKeypoints (image_data, output_temp);
+        #     pcl::copyPointCloud<pcl::PointUV, Out> (output_temp, output);
+        #   }
+        # };
+        # /////////////////////////////////////////////////////////////////////////////////////
+        # template <>
+        # struct AgastDetector<pcl::PointUV>
+        # {
+        #   AgastDetector (
+        #       const std::vector<unsigned char> &image_data, 
+        #       const pcl::keypoints::agast::AbstractAgastDetector::Ptr &detector,
+        #       pcl::PointCloud<pcl::PointUV> &output)
+        #   {
+        #     detector->detectKeypoints (image_data, output);
+        #   }
+        # };
+
+# namespace pcl
+# /** \brief Detects 2D AGAST corner points. Based on the original work and
+# * paper reference by
+# *
+# * \par
+# * Elmar Mair, Gregory D. Hager, Darius Burschka, Michael Suppa, and Gerhard Hirzinger. 
+# * Adaptive and generic corner detection based on the accelerated segment test. 
+# * In Proceedings of the European Conference on Computer Vision (ECCV'10), September 2010.
+# *
+# * \note This is an abstract base class. All children must implement a detectKeypoints method, based on the type of AGAST keypoint to be used.
+# *
+# * \author Stefan Holzer, Radu B. Rusu
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename IntensityT = pcl::common::IntensityFieldAccessor<PointInT> >
+# class AgastKeypoint2DBase : public Keypoint<PointInT, PointOutT>
+        # AgastKeypoint2DBase ()
+        # public:
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef pcl::keypoints::agast::AbstractAgastDetector::Ptr AgastDetectorPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+
+        # 
+        # /** \brief Sets the threshold for corner detection.
+        # * \param[in] threshold the threshold used for corner detection.
+        # */
+        # inline void setThreshold (const double threshold)
+        # /** \brief Get the threshold for corner detection, as set by the user. */
+        # inline double getThreshold ()
+        # /** \brief Sets the maximum number of keypoints to return. The
+        # * estimated keypoints are sorted by their internal score.
+        # * \param[in] nr_max_keypoints set the maximum number of keypoints to return
+        # */
+        # inline void setMaxKeypoints (const unsigned int nr_max_keypoints)
+        # /** \brief Get the maximum nuber of keypoints to return, as set by the user. */
+        # inline unsigned int getMaxKeypoints ()
+        # /** \brief Sets the max image data value (affects how many iterations AGAST does)
+        # * \param[in] bmax the max image data value
+        # */
+        # inline void setMaxDataValue (const double bmax)
+        # /** \brief Get the bmax image value, as set by the user. */
+        # inline double getMaxDataValue ()
+        # /** \brief Sets whether non-max-suppression is applied or not.
+        # * \param[in] enabled determines whether non-max-suppression is enabled.
+        # */
+        # inline void setNonMaxSuppression (const bool enabled)
+        # /** \brief Returns whether non-max-suppression is applied or not. */
+        # inline bool getNonMaxSuppression ()
+        # inline void setAgastDetector (const AgastDetectorPtr &detector)
+        # inline AgastDetectorPtr getAgastDetector ()
+        # protected:
+        # /** \brief Initializes everything and checks whether input data is fine. */
+        # bool initCompute ();
+        # /** \brief Detects the keypoints.
+        # * \param[out] output the resultant keypoints
+        # */
+        # virtual void detectKeypoints (PointCloudOut &output) = 0;
+        # /** \brief Intensity field accessor. */
+        # IntensityT intensity_;
+        # /** \brief Threshold for corner detection. */
+        # double threshold_;
+        # /** \brief Determines whether non-max-suppression is activated. */
+        # bool apply_non_max_suppression_;
+        # /** \brief Max image value. */
+        # double bmax_;
+        # /** \brief The Agast detector to use. */
+        # AgastDetectorPtr detector_;
+        # /** \brief The maximum number of keypoints to return. */
+        # unsigned int nr_max_keypoints_;
+### 
+
+# /** \brief Detects 2D AGAST corner points. Based on the original work and
+# * paper reference by
+# * \par
+# * Elmar Mair, Gregory D. Hager, Darius Burschka, Michael Suppa, and Gerhard Hirzinger. 
+# * Adaptive and generic corner detection based on the accelerated segment test. 
+# * In Proceedings of the European Conference on Computer Vision (ECCV'10), September 2010.
+# * Code example:
+# * \code
+# * pcl::PointCloud<pcl::PointXYZRGBA> cloud;
+# * pcl::AgastKeypoint2D<pcl::PointXYZRGBA> agast;
+# * agast.setThreshold (30);
+# * agast.setInputCloud (cloud);
+# * PointCloud<pcl::PointUV> keypoints;
+# * agast.compute (keypoints);
+# * \endcode
+# * \note The AGAST keypoint type used is 7_12s.
+# * \author Stefan Holzer, Radu B. Rusu
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT = pcl::PointUV>
+# class AgastKeypoint2D : public AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >
+        # AgastKeypoint2D()
+        # public:
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::intensity_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::threshold_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::bmax_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::apply_non_max_suppression_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::detector_;
+        # using AgastKeypoint2DBase<PointInT, PointOutT, pcl::common::IntensityFieldAccessor<PointInT> >::nr_max_keypoints_;
+        # protected:
+        # /** \brief Detects the keypoints.
+        #  * \param[out] output the resultant keypoints
+        #  */
+        # virtual void detectKeypoints (PointCloudOut &output);
+
+# /** \brief Detects 2D AGAST corner points. Based on the original work and
+# * paper reference by
+# *
+# * \par
+# * Elmar Mair, Gregory D. Hager, Darius Burschka, Michael Suppa, and Gerhard Hirzinger. 
+# * Adaptive and generic corner detection based on the accelerated segment test. 
+# * In Proceedings of the European Conference on Computer Vision (ECCV'10), September 2010.
+# *
+# * Code example:
+# *
+# * \code
+# * pcl::PointCloud<pcl::PointXYZRGBA> cloud;
+# * pcl::AgastKeypoint2D<pcl::PointXYZRGBA> agast;
+# * agast.setThreshold (30);
+# * agast.setInputCloud (cloud);
+# *
+# * PointCloud<pcl::PointUV> keypoints;
+# * agast.compute (keypoints);
+# * \endcode
+# *
+# * \note This is a specialized version for PointXYZ clouds, and operates on depth (z) as float. The output keypoints are of the PointXY type.
+# * \note The AGAST keypoint type used is 7_12s.
+# *
+# * \author Stefan Holzer, Radu B. Rusu
+# * \ingroup keypoints
+# */
+# template <>
+# class AgastKeypoint2D<pcl::PointXYZ, pcl::PointUV>
+# : public AgastKeypoint2DBase<pcl::PointXYZ, pcl::PointUV, pcl::common::IntensityFieldAccessor<pcl::PointXYZ> > 
+#   public:
+#   AgastKeypoint2D ()
+#   protected:
+#   /** \brief Detects the keypoints.
+#   * \param[out] output the resultant keypoints
+#   */
+#   virtual void detectKeypoints (pcl::PointCloud<pcl::PointUV> &output);
+# 
+###
+
+# harris_3d.h
+# namespace pcl
+# /** \brief HarrisKeypoint3D uses the idea of 2D Harris keypoints, but instead of using image gradients, it uses
+# * surface normals.
+# * \author Suat Gedikli
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class HarrisKeypoint3D : public Keypoint<PointInT, PointOutT>
+        # /** \brief Constructor
+        #  * \param[in] method the method to be used to determine the corner responses
+        #  * \param[in] radius the radius for normal estimation as well as for non maxima suppression
+        #  * \param[in] threshold the threshold to filter out weak corners
+        #  */
+        # HarrisKeypoint3D (ResponseMethod method = HARRIS, float radius = 0.01f, float threshold = 0.0f)
+        # HarrisKeypoint3D ()
+        # public:
+        # typedef boost::shared_ptr<HarrisKeypoint3D<PointInT, PointOutT, NormalT> > Ptr;
+        # typedef boost::shared_ptr<const HarrisKeypoint3D<PointInT, PointOutT, NormalT> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # using Keypoint<PointInT, PointOutT>::initCompute;
+        # using PCLBase<PointInT>::setInputCloud;
+        # typedef enum {HARRIS = 1, NOBLE, LOWE, TOMASI, CURVATURE} ResponseMethod;
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # virtual void setInputCloud (const PointCloudInConstPtr &cloud);
+        # /** \brief Set the method of the response to be calculated.
+        # * \param[in] type
+        # */
+        # void 
+        # setMethod (ResponseMethod type);
+        # /** \brief Set the radius for normal estimation and non maxima supression.
+        # * \param[in] radius
+        # */
+        # void 
+        # setRadius (float radius);
+        # /** \brief Set the threshold value for detecting corners. This is only evaluated if non maxima suppression is turned on.
+        # * \brief note non maxima suppression needs to be activated in order to use this feature.
+        # * \param[in] threshold
+        # */
+        # void 
+        # setThreshold (float threshold);
+        # /** \brief Whether non maxima suppression should be applied or the response for each point should be returned
+        # * \note this value needs to be turned on in order to apply thresholding and refinement
+        # * \param[in] nonmax default is false
+        # */
+        # void 
+        # setNonMaxSupression (bool = false);
+        # /** \brief Whether the detected key points should be refined or not. If turned of, the key points are a subset of the original point cloud. Otherwise the key points may be arbitrary.
+        # * \brief note non maxima supression needs to be on in order to use this feature.
+        # * \param[in] do_refine
+        # */
+        # void 
+        # setRefine (bool do_refine);
+        # /** \brief Set normals if precalculated normals are available.
+        # * \param normals
+        # */
+        # void 
+        # setNormals (const PointCloudNConstPtr &normals);
+        # /** \brief Provide a pointer to a dataset to add additional information
+        # * to estimate the features for every point in the input dataset.  This
+        # * is optional, if this is not set, it will only use the data in the
+        # * input cloud to estimate the features.  This is useful when you only
+        # * need to compute the features for a downsampled cloud.
+        # * \param[in] cloud a pointer to a PointCloud message
+        # */
+        # virtual void setSearchSurface (const PointCloudInConstPtr &cloud) { surface_ = cloud; normals_.reset(); }
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void setNumberOfThreads (unsigned int nr_threads = 0)
+        # protected:
+        # bool
+        # initCompute ();
+        # void detectKeypoints (PointCloudOut &output);
+        # /** \brief gets the corner response for valid input points*/
+        # void responseHarris (PointCloudOut &output) const;
+        # void responseNoble (PointCloudOut &output) const;
+        # void responseLowe (PointCloudOut &output) const;
+        # void responseTomasi (PointCloudOut &output) const;
+        # void responseCurvature (PointCloudOut &output) const;
+        # void refineCorners (PointCloudOut &corners) const;
+        # /** \brief calculates the upper triangular part of unnormalized covariance matrix over the normals given by the indices.*/
+        # void calculateNormalCovar (const std::vector<int>& neighbors, float* coefficients) const;
+###
+
+# harris_6d.h
+# namespace pcl
+# /** \brief Keypoint detector for detecting corners in 3D (XYZ), 2D (intensity) AND mixed versions of these.
+# * \author Suat Gedikli
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class HarrisKeypoint6D : public Keypoint<PointInT, PointOutT>
+        # /**
+        #  * @brief Constructor
+        #  * @param radius the radius for normal estimation as well as for non maxima suppression
+        #  * @param threshold the threshold to filter out weak corners
+        #  */
+        # HarrisKeypoint6D (float radius = 0.01, float threshold = 0.0)
+        # HarrisKeypoint6D ()
+        # public:
+        # typedef boost::shared_ptr<HarrisKeypoint6D<PointInT, PointOutT, NormalT> > Ptr;
+        # typedef boost::shared_ptr<const HarrisKeypoint6D<PointInT, PointOutT, NormalT> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # 
+        # /**
+        # * @brief set the radius for normal estimation and non maxima supression.
+        # * @param radius
+        # */
+        # void setRadius (float radius);
+        # /**
+        # * @brief set the threshold value for detecting corners. This is only evaluated if non maxima suppression is turned on.
+        # * @brief note non maxima suppression needs to be activated in order to use this feature.
+        # * @param threshold
+        # */
+        # void setThreshold (float threshold);
+        # /**
+        # * @brief whether non maxima suppression should be applied or the response for each point should be returned
+        # * @note this value needs to be turned on in order to apply thresholding and refinement
+        # * @param nonmax default is false
+        # */
+        # void setNonMaxSupression (bool = false);
+        # /**
+        # * @brief whether the detected key points should be refined or not. If turned of, the key points are a subset of the original point cloud. Otherwise the key points may be arbitrary.
+        # * @brief note non maxima supression needs to be on in order to use this feature.
+        # * @param do_refine
+        # */
+        # void setRefine (bool do_refine);
+        # virtual void
+        # setSearchSurface (const PointCloudInConstPtr &cloud) { surface_ = cloud; normals_->clear (); intensity_gradients_->clear ();}
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void
+        # setNumberOfThreads (unsigned int nr_threads = 0) { threads_ = nr_threads; }
+        # protected:
+        # void detectKeypoints (PointCloudOut &output);
+        # void responseTomasi (PointCloudOut &output) const;
+        # void refineCorners (PointCloudOut &corners) const;
+        # void calculateCombinedCovar (const std::vector<int>& neighbors, float* coefficients) const;
+###
+
+# iss_3d.h
+# namespace pcl
+# /** \brief ISSKeypoint3D detects the Intrinsic Shape Signatures keypoints for a given
+# * point cloud. This class is based on a particular implementation made by Federico
+# * Tombari and Samuele Salti and it has been explicitly adapted to PCL.
+# * For more information about the original ISS detector, see:
+# *\par
+# * Yu Zhong, “Intrinsic shape signatures: A shape descriptor for 3D object recognition,”
+# * Computer Vision Workshops (ICCV Workshops), 2009 IEEE 12th International Conference on ,
+# * vol., no., pp.689-696, Sept. 27 2009-Oct. 4 2009
+# * Code example:
+# * \code
+# * pcl::PointCloud<pcl::PointXYZRGBA>::Ptr model (new pcl::PointCloud<pcl::PointXYZRGBA> ());;
+# * pcl::PointCloud<pcl::PointXYZRGBA>::Ptr model_keypoints (new pcl::PointCloud<pcl::PointXYZRGBA> ());
+# * pcl::search::KdTree<pcl::PointXYZRGBA>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZRGBA> ());
+# * // Fill in the model cloud
+# * double model_resolution;
+# * // Compute model_resolution
+# * pcl::ISSKeypoint3D<pcl::PointXYZRGBA, pcl::PointXYZRGBA> iss_detector;
+# * iss_detector.setSearchMethod (tree);
+# * iss_detector.setSalientRadius (6 * model_resolution);
+# * iss_detector.setNonMaxRadius (4 * model_resolution);
+# * iss_detector.setThreshold21 (0.975);
+# * iss_detector.setThreshold32 (0.975);
+# * iss_detector.setMinNeighbors (5);
+# * iss_detector.setNumberOfThreads (4);
+# * iss_detector.setInputCloud (model);
+# * iss_detector.compute (*model_keypoints);
+# * \endcode
+# * \author Gioia Ballin
+# * \ingroup keypoints
+# */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal>
+# class ISSKeypoint3D : public Keypoint<PointInT, PointOutT>
+        # /** \brief Constructor.
+        # * \param[in] salient_radius the radius of the spherical neighborhood used to compute the scatter matrix.
+        # */
+        # ISSKeypoint3D (double salient_radius = 0.0001)
+        # ISSKeypoint3D ()
+        # public:
+        # typedef boost::shared_ptr<ISSKeypoint3D<PointInT, PointOutT, NormalT> > Ptr;
+        # typedef boost::shared_ptr<const ISSKeypoint3D<PointInT, PointOutT, NormalT> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::octree::OctreePointCloudSearch<PointInT> OctreeSearchIn;
+        # typedef typename OctreeSearchIn::Ptr OctreeSearchInPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # 
+        #   /** \brief Set the radius of the spherical neighborhood used to compute the scatter matrix.
+        # * \param[in] salient_radius the radius of the spherical neighborhood
+        # */
+        # void
+        # setSalientRadius (double salient_radius);
+        # /** \brief Set the radius for the application of the non maxima supression algorithm.
+        # * \param[in] non_max_radius the non maxima suppression radius
+        # */
+        # void
+        # setNonMaxRadius (double non_max_radius);
+        # /** \brief Set the radius used for the estimation of the surface normals of the input cloud. If the radius is
+        # * too large, the temporal performances of the detector may degrade significantly.
+        # * \param[in] normal_radius the radius used to estimate surface normals
+        # */
+        # void
+        # setNormalRadius (double normal_radius);
+        # /** \brief Set the radius used for the estimation of the boundary points. If the radius is too large,
+        # * the temporal performances of the detector may degrade significantly.
+        # * \param[in] border_radius the radius used to compute the boundary points
+        # */
+        # void
+        # setBorderRadius (double border_radius);
+        # /** \brief Set the upper bound on the ratio between the second and the first eigenvalue.
+        # * \param[in] gamma_21 the upper bound on the ratio between the second and the first eigenvalue
+        # */
+        # void
+        # setThreshold21 (double gamma_21);
+        # /** \brief Set the upper bound on the ratio between the third and the second eigenvalue.
+        # * \param[in] gamma_32 the upper bound on the ratio between the third and the second eigenvalue
+        # */
+        # void
+        # setThreshold32 (double gamma_32);
+        # /** \brief Set the minimum number of neighbors that has to be found while applying the non maxima suppression algorithm.
+        # * \param[in] min_neighbors the minimum number of neighbors required
+        # */
+        # void
+        # setMinNeighbors (int min_neighbors);
+        # /** \brief Set the normals if pre-calculated normals are available.
+        # * \param[in] normals the given cloud of normals
+        # */
+        # void
+        # setNormals (const PointCloudNConstPtr &normals);
+        # /** \brief Set the decision boundary (angle threshold) that marks points as boundary or regular.
+        # * (default \f$\pi / 2.0\f$)
+        # * \param[in] angle the angle threshold
+        # */
+        # inline void setAngleThreshold (float angle)
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param[in] nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void setNumberOfThreads (unsigned int nr_threads = 0)
+        # protected:
+        # /** \brief Compute the boundary points for the given input cloud.
+        # * \param[in] input the input cloud
+        # * \param[in] border_radius the radius used to compute the boundary points
+        # * \param[in] angle_threshold the decision boundary that marks the points as boundary
+        # * \return the vector of boolean values in which the information about the boundary points is stored
+        # */
+        # bool* getBoundaryPoints (PointCloudIn &input, double border_radius, float angle_threshold);
+        # /** \brief Compute the scatter matrix for a point index.
+        # * \param[in] current_index the index of the point
+        # * \param[out] cov_m the point scatter matrix
+        # */
+        # void getScatterMatrix (const int &current_index, Eigen::Matrix3d &cov_m);
+        # /** \brief Perform the initial checks before computing the keypoints.
+        # *  \return true if all the checks are passed, false otherwise
+        # */
+        # bool initCompute ();
+        # /** \brief Detect the keypoints by performing the EVD of the scatter matrix.
+        # * \param[out] output the resultant cloud of keypoints
+        # */
+        # void detectKeypoints (PointCloudOut &output);
+        # /** \brief The radius of the spherical neighborhood used to compute the scatter matrix.*/
+        # double salient_radius_;
+        # /** \brief The non maxima suppression radius. */
+        # double non_max_radius_;
+        # /** \brief The radius used to compute the normals of the input cloud. */
+        # double normal_radius_;
+        # /** \brief The radius used to compute the boundary points of the input cloud. */
+        # double border_radius_;
+        # /** \brief The upper bound on the ratio between the second and the first eigenvalue returned by the EVD. */
+        # double gamma_21_;
+        # /** \brief The upper bound on the ratio between the third and the second eigenvalue returned by the EVD. */
+        # double gamma_32_;
+        # /** \brief Store the third eigen value associated to each point in the input cloud. */
+        # double *third_eigen_value_;
+        # /** \brief Store the information about the boundary points of the input cloud. */
+        # bool *edge_points_;
+        # /** \brief Minimum number of neighbors that has to be found while applying the non maxima suppression algorithm. */
+        # int min_neighbors_;
+        # /** \brief The cloud of normals related to the input surface. */
+        # PointCloudNConstPtr normals_;
+        # /** \brief The decision boundary (angle threshold) that marks points as boundary or regular. (default \f$\pi / 2.0\f$) */
+        # float angle_threshold_;
+        # /** \brief The number of threads that has to be used by the scheduler. */
+        # unsigned int threads_;
+#### 
+
+# # susan.h
+# namespace pcl
+# /** \brief SUSANKeypoint implements a RGB-D extension of the SUSAN detector inluding normal 
+#  * directions variation in top of intensity variation. 
+#  * It is different from Harris in that it exploits normals directly so it is faster.  
+#  * Original paper "SUSAN 窶A New Approach to Low Level Image Processing", Smith,
+#  * Stephen M. and Brady, J. Michael 
+#  *
+#  * \author Nizar Sallem 
+#  * \ingroup keypoints
+#  */
+# template <typename PointInT, typename PointOutT, typename NormalT = pcl::Normal, typename IntensityT= pcl::common::IntensityFieldAccessor<PointInT> >
+# class SUSANKeypoint : public Keypoint<PointInT, PointOutT>
+        # /** \brief Constructor
+        #   * \param[in] radius the radius for normal estimation as well as for non maxima suppression
+        #   * \param[in] distance_threshold to test if the nucleus is far enough from the centroid
+        #   * \param[in] angular_threshold to test if normals are parallel
+        #   * \param[in] intensity_threshold to test if points are of same color
+        #   */
+        # SUSANKeypoint (float radius = 0.01f, 
+        #                float distance_threshold = 0.001f, 
+        #                float angular_threshold = 0.0001f, 
+        #                float intensity_threshold = 7.0f)
+        # SUSANKeypoint()
+        # public:
+        # typedef boost::shared_ptr<SUSANKeypoint<PointInT, PointOutT, NormalT, IntensityT> > Ptr;
+        # typedef boost::shared_ptr<const SUSANKeypoint<PointInT, PointOutT, NormalT, Intensity> > ConstPtr;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+        # typedef typename Keypoint<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+        # typedef typename Keypoint<PointInT, PointOutT>::KdTree KdTree;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # typedef typename pcl::PointCloud<NormalT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # using Keypoint<PointInT, PointOutT>::name_;
+        # using Keypoint<PointInT, PointOutT>::input_;
+        # using Keypoint<PointInT, PointOutT>::indices_;
+        # using Keypoint<PointInT, PointOutT>::surface_;
+        # using Keypoint<PointInT, PointOutT>::tree_;
+        # using Keypoint<PointInT, PointOutT>::k_;
+        # using Keypoint<PointInT, PointOutT>::search_radius_;
+        # using Keypoint<PointInT, PointOutT>::search_parameter_;
+        # using Keypoint<PointInT, PointOutT>::keypoints_indices_;
+        # using Keypoint<PointInT, PointOutT>::initCompute;
+        # /** \brief set the radius for normal estimation and non maxima supression.
+        # * \param[in] radius
+        # */
+        # void setRadius (float radius);
+        # void setDistanceThreshold (float distance_threshold);
+        # /** \brief set the angular_threshold value for detecting corners. Normals are considered as 
+        # * parallel if 1 - angular_threshold <= (Ni.Nj) <= 1
+        # * \param[in] angular_threshold
+        # */
+        # void setAngularThreshold (float angular_threshold);
+        # /** \brief set the intensity_threshold value for detecting corners. 
+        # * \param[in] intensity_threshold
+        # */
+        # void setIntensityThreshold (float intensity_threshold);
+        # /**
+        # * \brief set normals if precalculated normals are available.
+        # * \param normals
+        # */
+        # void setNormals (const PointCloudNConstPtr &normals);
+        # virtual void setSearchSurface (const PointCloudInConstPtr &cloud);
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # void setNumberOfThreads (unsigned int nr_threads);
+        # /** \brief Apply non maxima suppression to the responses to keep strongest corners.
+        # * \note in SUSAN points with less response or stronger corners
+        # */
+        # void setNonMaxSupression (bool nonmax);
+        # /** \brief Filetr false positive using geometric criteria. 
+        # * The nucleus and the centroid should at least distance_threshold_ from each other AND all the 
+        # * points belonging to the USAN must be within the segment [nucleus centroid].
+        # * \param[in] validate 
+        # */
+        # void setGeometricValidation (bool validate);
+        # protected:
+        # bool initCompute ();
+        # void detectKeypoints (PointCloudOut &output);
+        # /** \brief return true if a point lies within the line between the nucleus and the centroid
+        # * \param[in] nucleus coordinate of the nucleus
+        # * \param[in] centroid of the SUSAN
+        # * \param[in] nc to centroid vector (used to speed up since it is constant for a given
+        # * neighborhood)
+        # * \param[in] point the query point to test against
+        # * \return true if the point lies within [nucleus centroid]
+        # */
+        # bool isWithinNucleusCentroid (const Eigen::Vector3f& nucleus,
+        #                        const Eigen::Vector3f& centroid,
+        #                        const Eigen::Vector3f& nc,
+        #                        const PointInT& point) const;
+###
+
+
+# harris_3d.h
+###
+
+# harris_6d.h
+###
+
+# iss_3d.h
+###
+
+
diff --git a/pcl/pcl_octree.pxd b/pcl/pcl_octree.pxd
new file mode 100644
index 0000000..c566abf
--- /dev/null
+++ b/pcl/pcl_octree.pxd
@@ -0,0 +1,1253 @@
+# -*- coding: utf-8 -*-

+from libcpp cimport bool

+from libcpp.vector cimport vector

+

+# main

+cimport pcl_defs as cpp

+from boost_shared_ptr cimport shared_ptr

+

+cimport eigen as eig

+from vector cimport vector as vector2

+

+###############################################################################

+# Types

+###############################################################################

+

+### base class ###

+

+# octree_base.h

+# namespace pcl

+#   namespace octree

+# template<typename DataT, typename LeafT = OctreeContainerDataT<DataT>, typename BranchT = OctreeContainerEmpty<DataT> >

+# class OctreeBase

+cdef extern from "pcl/octree/octree_base.h" namespace "pcl::octree":

+    cdef cppclass OctreeBase[DataT]:

+        OctreeBase()

+        # OctreeBase (const OctreeBase& source) :

+        # inline OctreeBase& operator = (const OctreeBase &source)

+        # public:

+        # typedef OctreeBase<DataT, OctreeContainerDataT<DataT>, OctreeContainerEmpty<DataT> > SingleObjLeafContainer;

+        # typedef OctreeBase<DataT, OctreeContainerDataTVector<DataT>, OctreeContainerEmpty<DataT> > MultipleObjsLeafContainer;

+        # typedef OctreeBase<DataT, LeafT, BranchT> OctreeT;

+        # // iterators are friends

+        # friend class OctreeIteratorBase<DataT, OctreeT> ;

+        # friend class OctreeDepthFirstIterator<DataT, OctreeT> ;

+        # friend class OctreeBreadthFirstIterator<DataT, OctreeT> ;

+        # friend class OctreeLeafNodeIterator<DataT, OctreeT> ;

+        # typedef OctreeBranchNode<BranchT> BranchNode;

+        # typedef OctreeLeafNode<LeafT> LeafNode;

+        # // Octree iterators

+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> Iterator;

+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstIterator;

+        # typedef OctreeLeafNodeIterator<DataT, OctreeT> LeafNodeIterator;

+        # typedef const OctreeLeafNodeIterator<DataT, OctreeT> ConstLeafNodeIterator;

+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> DepthFirstIterator;

+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstDepthFirstIterator;

+        # typedef OctreeBreadthFirstIterator<DataT, OctreeT> BreadthFirstIterator;

+        # typedef const OctreeBreadthFirstIterator<DataT, OctreeT> ConstBreadthFirstIterator;

+        

+        # void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg)

+        void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg)

+        

+        # \brief Set the maximum depth of the octree.

+        # \param depth_arg: maximum depth of octree

+        # void setTreeDepth (unsigned int depth_arg);

+        void setTreeDepth (unsigned int depth_arg)

+        

+        # \brief Get the maximum depth of the octree.

+        # \return depth_arg: maximum depth of octree

+        # inline unsigned int getTreeDepth () const

+        unsigned int getTreeDepth ()

+        

+        # \brief Enable dynamic octree structure

+        # \note Leaf nodes are kept as close to the root as possible and are only expanded if the number of DataT objects within a leaf node exceeds a fixed limit.

+        # \return maxObjsPerLeaf: maximum number of DataT objects per leaf

+        # inline void enableDynamicDepth ( size_t maxObjsPerLeaf )

+        void enableDynamicDepth ( size_t maxObjsPerLeaf )

+        

+        # \brief Add a const DataT element to leaf node at (idxX, idxY, idxZ). If leaf node does not exist, it is created and added to the octree.

+        # \param idxX_arg: index of leaf node in the X axis.

+        # \param idxY_arg: index of leaf node in the Y axis.

+        # \param idxZ_arg: index of leaf node in the Z axis.

+        # \param data_arg: const reference to DataT object to be added.

+        # void addData (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, const DataT& data_arg)

+        

+        # \brief Retrieve a DataT element from leaf node at (idxX, idxY, idxZ). It returns false if leaf node does not exist.

+        # \param idxX_arg: index of leaf node in the X axis.

+        # \param idxY_arg: index of leaf node in the Y axis.

+        # \param idxZ_arg: index of leaf node in the Z axis.

+        # \param data_arg: reference to DataT object that contains content of leaf node if search was successful.

+        # \return "true" if leaf node search is successful, otherwise it returns "false".

+        # bool getData (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, DataT& data_arg) const 

+        

+        # \brief Check for the existence of leaf node at (idxX, idxY, idxZ).

+        # \param idxX_arg: index of leaf node in the X axis.

+        # \param idxY_arg: index of leaf node in the Y axis.

+        # \param idxZ_arg: index of leaf node in the Z axis.

+        # \return "true" if leaf node search is successful, otherwise it returns "false".

+        # bool existLeaf (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg) const 

+        

+        # \brief Remove leaf node at (idxX_arg, idxY_arg, idxZ_arg).

+        # \param idxX_arg: index of leaf node in the X axis.

+        # \param idxY_arg: index of leaf node in the Y axis.

+        # \param idxZ_arg: index of leaf node in the Z axis.

+        # void removeLeaf (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg)

+        

+        # \brief Return the amount of existing leafs in the octree.

+        # \return amount of registered leaf nodes.

+        # inline std::size_t getLeafCount () const

+        size_t getLeafCount ()

+        

+        # \brief Return the amount of existing branches in the octree.

+        # \return amount of branch nodes.

+        # inline std::size_t getBranchCount () const

+        size_t getBranchCount ()

+        

+        # \brief Delete the octree structure and its leaf nodes.

+        # \param freeMemory_arg: if "true", allocated octree nodes are deleted, otherwise they are pushed to the octree node pool

+        # void deleteTree ( bool freeMemory_arg = true )

+        void deleteTree ( bool freeMemory_arg)

+        

+        # \brief Serialize octree into a binary output vector describing its branch node structure.

+        # \param binaryTreeOut_arg: reference to output vector for writing binary tree structure.

+        # void serializeTree (vector[char]& binaryTreeOut_arg)

+        void serializeTree (vector[char]& binaryTreeOut_arg)

+        

+        # \brief Serialize octree into a binary output vector describing its branch node structure and push all DataT elements stored in the octree to a vector.

+        # \param binaryTreeOut_arg: reference to output vector for writing binary tree structure.

+        # \param dataVector_arg: reference of DataT vector that receives a copy of all DataT objects in the octree

+        # void serializeTree (vector[char]& binaryTreeOut_arg, vector[DataT]& dataVector_arg);

+        void serializeTree (vector[char]& binaryTreeOut_arg, vector[DataT]& dataVector_arg)

+        

+        # \brief Outputs a vector of all DataT elements that are stored within the octree leaf nodes.

+        # \param dataVector_arg: reference to DataT vector that receives a copy of all DataT objects in the octree.

+        # void serializeLeafs (std::vector<DataT>& dataVector_arg);

+        void serializeLeafs (vector[DataT]& dataVector_arg)

+        

+        # \brief Deserialize a binary octree description vector and create a corresponding octree structure. Leaf nodes are initialized with getDataTByKey(..).

+        # \param binaryTreeIn_arg: reference to input vector for reading binary tree structure.

+        # void deserializeTree (std::vector<char>& binaryTreeIn_arg);

+        void deserializeTree (vector[char]& binaryTreeIn_arg)

+        

+        # \brief Deserialize a binary octree description and create a corresponding octree structure. Leaf nodes are initialized with DataT elements from the dataVector.

+        # \param binaryTreeIn_arg: reference to input vector for reading binary tree structure.

+        # \param dataVector_arg: reference to DataT vector that provides DataT objects for initializing leaf nodes.

+        # void deserializeTree (std::vector<char>& binaryTreeIn_arg, std::vector<DataT>& dataVector_arg);

+        void deserializeTree (vector[char]& binaryTreeIn_arg, vector[DataT]& dataVector_arg)

+

+

+ctypedef OctreeBase[int] OctreeBase_t

+# ctypedef shared_ptr[OctreeBase[int]] OctreeBasePtr_t

+###

+

+### Inheritance class ###

+

+# octree.h

+# header include

+###

+

+# Version 1.7.2

+# octree2buf_base.h

+# namespace pcl

+# namespace octree

+    # template<typename ContainerT>

+    # class BufferedBranchNode : public OctreeNode, ContainerT

+    # {

+        # using ContainerT::getSize;

+        # using ContainerT::getData;

+        # using ContainerT::setData;

+        # 

+        # public:

+        # /** \brief Empty constructor. */

+        # BufferedBranchNode () : OctreeNode(), ContainerT(),  preBuf(0xFFFFFF), postBuf(0xFFFFFF)

+        # /** \brief Copy constructor. */

+        # BufferedBranchNode (const BufferedBranchNode& source) : ContainerT(source)

+        # /** \brief Copy operator. */

+        # inline BufferedBranchNode& operator = (const BufferedBranchNode &source_arg)

+        # /** \brief Empty constructor. */

+        # virtual ~BufferedBranchNode ()

+        # 

+        # /** \brief Method to perform a deep copy of the octree */

+        # virtual BufferedBranchNode* deepCopy () const

+        # 

+        # /** \brief Get child pointer in current branch node

+        #  *  \param buffer_arg: buffer selector

+        #  *  \param index_arg: index of child in node

+        #  *  \return pointer to child node

+        #  * */

+        # inline OctreeNode* getChildPtr (unsigned char buffer_arg, unsigned char index_arg) const

+        # 

+        # /** \brief Set child pointer in current branch node

+        #  *  \param buffer_arg: buffer selector

+        #  *  \param index_arg: index of child in node

+        #  *  \param newNode_arg: pointer to new child node

+        #  * */

+        # inline void setChildPtr (unsigned char buffer_arg, unsigned char index_arg, OctreeNode* newNode_arg)

+        # 

+        # /** \brief Check if branch is pointing to a particular child node

+        #  *  \param buffer_arg: buffer selector

+        #  *  \param index_arg: index of child in node

+        #  *  \return "true" if pointer to child node exists; "false" otherwise

+        #  * */

+        # inline bool hasChild (unsigned char buffer_arg, unsigned char index_arg) const

+        # 

+        # /** \brief Get the type of octree node. Returns LEAVE_NODE type */

+        # virtual node_type_t getNodeType () const

+        # 

+        # /** \brief Reset branch node container for every branch buffer. */

+        # inline void reset ()

+

+

+###

+

+# namespace pcl

+# namespace octree

+# /** \brief @b Octree double buffer class

+#  * \note This octree implementation keeps two separate octree structures

+#  * in memory. This enables to create octree structures at high rate due to

+#  * an advanced memory management.

+#  * \note Furthermore, it allows for detecting and differentially compare the adjacent octree structures.

+#  * \note The tree depth defines the maximum amount of octree voxels / leaf nodes (should be initially defined).

+#  * \note All leaf nodes are addressed by integer indices.

+#  * \note Note: The tree depth equates to the bit length of the voxel indices.

+#  * \ingroup octree

+#  * \author Julius Kammerl (julius@kammerl.de)

+#  */

+# template<typename DataT, typename LeafT = OctreeContainerDataT<DataT>,

+# typename BranchT = OctreeContainerEmpty<DataT> >

+# class Octree2BufBase

+cdef extern from "pcl/octree/octree2buf_base.h" namespace "pcl::octree":

+    # cdef cppclass Octree2BufBase[DataT, OctreeContainerDataT[DataT], OctreeContainerEmpty[DataT]]:

+    cdef cppclass Octree2BufBase[DataT]:

+        Octree2BufBase()

+        # public:

+        # typedef Octree2BufBase<DataT, LeafT, BranchT> OctreeT;

+        # // iterators are friends

+        # friend class OctreeIteratorBase<DataT, OctreeT> ;

+        # friend class OctreeDepthFirstIterator<DataT, OctreeT> ;

+        # friend class OctreeBreadthFirstIterator<DataT, OctreeT> ;

+        # friend class OctreeLeafNodeIterator<DataT, OctreeT> ;

+        # typedef BufferedBranchNode<BranchT> BranchNode;

+        # typedef OctreeLeafNode<LeafT> LeafNode;

+        # 

+        # // Octree iterators

+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> Iterator;

+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstIterator;

+        # typedef OctreeLeafNodeIterator<DataT, OctreeT> LeafNodeIterator;

+        # typedef const OctreeLeafNodeIterator<DataT, OctreeT> ConstLeafNodeIterator;

+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> DepthFirstIterator;

+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstDepthFirstIterator;

+        # typedef OctreeBreadthFirstIterator<DataT, OctreeT> BreadthFirstIterator;

+        # typedef const OctreeBreadthFirstIterator<DataT, OctreeT> ConstBreadthFirstIterator;

+        # 

+        # /** \brief Empty constructor. */

+        # Octree2BufBase ();

+        # 

+        # /** \brief Empty deconstructor. */

+        # virtual ~Octree2BufBase ();

+        # 

+        # /** \brief Copy constructor. */

+        # Octree2BufBase (const Octree2BufBase& source) :

+        #     leafCount_ (source.leafCount_), branchCount_ (source.branchCount_), objectCount_ (

+        #     source.objectCount_), rootNode_ (

+        #       new (BranchNode) (* (source.rootNode_))), depthMask_ (

+        #       source.depthMask_), maxKey_ (source.maxKey_), branchNodePool_ (), leafNodePool_ (), bufferSelector_ (

+        #         source.bufferSelector_), treeDirtyFlag_ (source.treeDirtyFlag_), octreeDepth_ (

+        #         source.octreeDepth_)

+        # 

+        # /** \brief Copy constructor. */

+        # inline Octree2BufBase& operator = (const Octree2BufBase& source)

+        # 

+        # /** \brief Set the maximum amount of voxels per dimension.

+        #  *  \param maxVoxelIndex_arg: maximum amount of voxels per dimension

+        #  */

+        # void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg);

+        void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg)

+        

+        # /** \brief Set the maximum depth of the octree.

+        #  *  \param depth_arg: maximum depth of octree

+        #  */

+        # void setTreeDepth (unsigned int depth_arg);

+        void setTreeDepth (unsigned int depth_arg)

+        

+        # /** \brief Get the maximum depth of the octree.

+        #  *  \return depth_arg: maximum depth of octree

+        #  */

+        # inline unsigned int getTreeDepth () const

+        unsigned int getTreeDepth ()

+        

+        # /** \brief Add a const DataT element to leaf node at (idxX, idxY, idxZ). If leaf node does not exist, it is added to the octree.

+        #  *  \param idxX_arg: index of leaf node in the X axis.

+        #  *  \param idxY_arg: index of leaf node in the Y axis.

+        #  *  \param idxZ_arg: index of leaf node in the Z axis.

+        #  *  \param data_arg: const reference to DataT object that is fed to the lead node.

+        #  */

+        # void addData (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, const DataT& data_arg);

+        void addData (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, const DataT& data_arg)

+        

+        # 

+        # /** \brief Retrieve a DataT element from leaf node at (idxX, idxY, idxZ). It returns false if leaf node does not exist.

+        #  *  \param idxX_arg: index of leaf node in the X axis.

+        #  *  \param idxY_arg: index of leaf node in the Y axis.

+        #  *  \param idxZ_arg: index of leaf node in the Z axis.

+        #  *  \param data_arg: reference to DataT object that contains content of leaf node if search was successful.

+        #  *  \return "true" if leaf node search is successful, otherwise it returns "false".

+        #  */

+        # bool getData (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, DataT& data_arg) const;

+        bool getData (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, DataT& data_arg)

+        

+        # /** \brief Check for the existence of leaf node at (idxX, idxY, idxZ).

+        #  *  \param idxX_arg: index of leaf node in the X axis.

+        #  *  \param idxY_arg: index of leaf node in the Y axis.

+        #  *  \param idxZ_arg: index of leaf node in the Z axis.

+        #  *  \return "true" if leaf node search is successful, otherwise it returns "false".

+        #  */

+        # bool existLeaf (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg) const;

+        bool existLeaf (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg) const

+        

+        # /** \brief Remove leaf node at (idxX_arg, idxY_arg, idxZ_arg).

+        #  *  \param idxX_arg: index of leaf node in the X axis.

+        #  *  \param idxY_arg: index of leaf node in the Y axis.

+        #  *  \param idxZ_arg: index of leaf node in the Z axis.

+        #  */

+        # void removeLeaf (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg);

+        void removeLeaf (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg)

+        

+        # /** \brief Return the amount of existing leafs in the octree.

+        #  *  \return amount of registered leaf nodes.

+        #  */

+        # inline unsigned int getLeafCount () const

+        unsigned int getLeafCount ()

+        

+        # /** \brief Return the amount of existing branches in the octree.

+        #  *  \return amount of branch nodes.

+        #  */

+        # inline unsigned int getBranchCount () const

+        unsigned int getBranchCount ()

+        

+        # /** \brief Delete the octree structure and its leaf nodes.

+        #  *  \param freeMemory_arg: if "true", allocated octree nodes are deleted, otherwise they are pushed to the octree node pool

+        #  */

+        # void deleteTree (bool freeMemory_arg = false);

+        void deleteTree (bool freeMemory_arg)

+        

+        # /** \brief Delete octree structure of previous buffer. */

+        # inline void deletePreviousBuffer ()

+        void deletePreviousBuffer ()

+        

+        # /** \brief Delete the octree structure in the current buffer. */

+        # inline void deleteCurrentBuffer ()

+        void deleteCurrentBuffer ()

+        

+        # /** \brief Switch buffers and reset current octree structure. */

+        # void switchBuffers ();

+        void switchBuffers ()

+        

+        # /** \brief Serialize octree into a binary output vector describing its branch node structure.

+        #  *  \param binaryTreeOut_arg: reference to output vector for writing binary tree structure.

+        #  *  \param doXOREncoding_arg: select if binary tree structure should be generated based on current octree (false) of based on a XOR comparison between current and previous octree

+        #  */

+        # void serializeTree (std::vector<char>& binaryTreeOut_arg, bool doXOREncoding_arg = false);

+        void serializeTree (vector[char]& binaryTreeOut_arg, bool doXOREncoding_arg)

+        

+        # /** \brief Serialize octree into a binary output vector describing its branch node structure and and push all DataT elements stored in the octree to a vector.

+        #  * \param binaryTreeOut_arg: reference to output vector for writing binary tree structure.

+        #  * \param dataVector_arg: reference of DataT vector that receives a copy of all DataT objects in the octree

+        #  * \param doXOREncoding_arg: select if binary tree structure should be generated based on current octree (false) of based on a XOR comparison between current and previous octree

+        #  */

+        # void serializeTree (std::vector<char>& binaryTreeOut_arg, std::vector<DataT>& dataVector_arg, bool doXOREncoding_arg = false);

+        void serializeTree (vector[char]& binaryTreeOut_arg, vector[DataT]& dataVector_arg, bool doXOREncoding_arg)

+        

+        # /** \brief Outputs a vector of all DataT elements that are stored within the octree leaf nodes.

+        #  *  \param dataVector_arg: reference to DataT vector that receives a copy of all DataT objects in the octree.

+        #  */

+        # void serializeLeafs (std::vector<DataT>& dataVector_arg);

+        void serializeLeafs (vector[DataT]& dataVector_arg)

+        

+        # /** \brief Outputs a vector of all DataT elements from leaf nodes, that do not exist in the previous octree buffer.

+        #  *  \param dataVector_arg: reference to DataT vector that receives a copy of all DataT objects in the octree.

+        #  *  \param minPointsPerLeaf_arg: minimum amount of points required within leaf node to become serialized.

+        #  */

+        # void serializeNewLeafs (std::vector<DataT>& dataVector_arg, const int minPointsPerLeaf_arg = 0);

+        void serializeNewLeafs (vector[DataT]& dataVector_arg, const int minPointsPerLeaf_arg)

+        

+        # /** \brief Deserialize a binary octree description vector and create a corresponding octree structure. Leaf nodes are initialized with getDataTByKey(..).

+        #  *  \param binaryTreeIn_arg: reference to input vector for reading binary tree structure.

+        #  *  \param doXORDecoding_arg: select if binary tree structure is based on current octree (false) of based on a XOR comparison between current and previous octree

+        #  */

+        void deserializeTree (vector[char]& binaryTreeIn_arg, bool doXORDecoding_arg)

+        

+        # /** \brief Deserialize a binary octree description and create a corresponding octree structure. Leaf nodes are initialized with DataT elements from the dataVector.

+        #  *  \param binaryTreeIn_arg: reference to inpvectoream for reading binary tree structure.

+        #  *  \param dataVector_arg: reference to DataT vector that provides DataT objects for initializing leaf nodes.

+        #  *  \param doXORDecoding_arg: select if binary tree structure is based on current octree (false) of based on a XOR comparison between current and previous octree

+        #  */

+        # void deserializeTree (std::vector<char>& binaryTreeIn_arg, std::vector<DataT>& dataVector_arg, bool doXORDecoding_arg = false);

+        void deserializeTree (vector[char]& binaryTreeIn_arg, vector[DataT]& dataVector_arg, bool doXORDecoding_arg)

+

+

+ctypedef Octree2BufBase[int] Octree2BufBase_t

+# ctypedef shared_ptr[Octree2BufBase[int]] Octree2BufBasePtr_t

+###

+

+# octree_container.h

+# namespace pcl

+# namespace octree

+# template<typename DataT>

+# class OctreeContainerEmpty

+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":

+    cdef cppclass OctreeContainerEmpty[DataT]:

+        OctreeContainerEmpty()

+        # OctreeContainerEmpty (const OctreeContainerEmpty&)

+        # public:

+        # /** \brief Octree deep copy method */

+        # virtual OctreeContainerEmpty *deepCopy () const

+        # /** \brief Empty setData data implementation. This leaf node does not store any data.

+        # void setData (const DataT&)

+        # /** \brief Empty getData data vector implementation as this leaf node does not store any data.

+        # void getData (DataT&) const

+        # /** \brief Empty getData data vector implementation as this leaf node does not store any data. \

+        # * \param[in] dataVector_arg reference to dummy DataT vector that is extended with leaf node DataT elements.

+        # void getData (std::vector<DataT>&) const

+        # /** \brief Get size of container (number of DataT objects)

+        #  * \return number of DataT elements in leaf node container.

+        # size_t getSize () const

+        # /** \brief Empty reset leaf node implementation as this leaf node does not store any data. */

+        # void reset ()

+

+

+ctypedef OctreeContainerEmpty[int] OctreeContainerEmpty_t

+# ctypedef shared_ptr[OctreeContainerEmpty[int]] OctreeContainerEmptyPtr_t

+###

+

+# template<typename DataT>

+# class OctreeContainerDataT

+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":

+    cdef cppclass OctreeContainerDataT[DataT]:

+        OctreeContainerDataT()

+        # OctreeContainerDataT (const OctreeContainerDataT& source) :

+        # public:

+        # /** \brief Octree deep copy method */

+        # virtual OctreeContainerDataT* deepCopy () const

+        # /** \brief Copies a DataT element to leaf node memorye.

+        #  * \param[in] data_arg reference to DataT element to be stored within leaf node.

+        # void setData (const DataT& data_arg)

+        # /** \brief Adds leaf node DataT element to dataVector vector of type DataT.

+        #  * \param[in] dataVector_arg: reference to DataT type to obtain the most recently added leaf node DataT element.

+        # void getData (DataT& dataVector_arg) const

+        # /** \brief Adds leaf node DataT element to dataVector vector of type DataT.

+        #  * \param[in] dataVector_arg: reference to DataT vector that is to be extended with leaf node DataT elements.

+        # void getData (vector<DataT>& dataVector_arg) const

+        # /** \brief Get size of container (number of DataT objects)

+        #  * \return number of DataT elements in leaf node container.

+        # size_t getSize () const

+        # /** \brief Reset leaf node memory to zero. */

+        # void reset ()

+        # protected:

+        # /** \brief Leaf node DataT storage. */

+        # DataT data_;

+        # /** \brief Bool indicating if leaf node is empty or not. */

+        # bool isEmpty_;

+

+

+ctypedef OctreeContainerDataT[int] OctreeContainerDataT_t

+# ctypedef shared_ptr[OctreeContainerDataT[int]] OctreeContainerDataTPtr_t

+###

+

+# template<typename DataT>

+# class OctreeContainerDataTVector

+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":

+    cdef cppclass OctreeContainerDataTVector[DataT]:

+        OctreeContainerDataTVector()

+        # OctreeContainerDataTVector (const OctreeContainerDataTVector& source) :

+        # public:

+        # /** \brief Octree deep copy method */

+        # virtual OctreeContainerDataTVector *deepCopy () const

+        # /** \brief Pushes a DataT element to internal DataT vector.

+        #  * \param[in] data_arg reference to DataT element to be stored within leaf node.

+        #  */

+        # void setData (const DataT& data_arg)

+        # /** \brief Receive the most recent DataT element that was pushed to the internal DataT vector.

+        #  * \param[in] data_arg reference to DataT type to obtain the most recently added leaf node DataT element.

+        #  */

+        # void getData (DataT& data_arg) const

+        # /** \brief Concatenate the internal DataT vector to vector argument dataVector_arg.

+        #  * \param[in] dataVector_arg: reference to DataT vector that is to be extended with leaf node DataT elements.

+        #  */

+        # void getData (vector[DataT]& dataVector_arg) const

+        # /** \brief Return const reference to internal DataT vector

+        #  * \return  const reference to internal DataT vector

+        # const vector[DataT]& getDataTVector () const

+        # /** \brief Get size of container (number of DataT objects)

+        #  * \return number of DataT elements in leaf node container.

+        # size_t getSize () const

+        # /** \brief Reset leaf node. Clear DataT vector.*/

+        void reset ()

+

+

+ctypedef OctreeContainerDataTVector[int] OctreeContainerDataTVector_t

+# ctypedef shared_ptr[OctreeContainerDataTVector[int]] OctreeContainerDataTVectorPtr_t

+###

+

+# octree_impl.h

+# impl header include

+###

+

+

+# octree_iterator.h

+# namespace pcl

+# namespace octree

+#   template<typename DataT, typename OctreeT>

+#       class OctreeIteratorBase : public std::iterator<std::forward_iterator_tag, const OctreeNode, void, const OctreeNode*, const OctreeNode&>

+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":

+    cdef cppclass OctreeIteratorBase[DataT, OctreeT]:

+        OctreeIteratorBase()

+        # explicit OctreeIteratorBase (OctreeT& octree_arg)

+        # OctreeIteratorBase (const OctreeIteratorBase& src) :

+        # inline OctreeIteratorBase& operator = (const OctreeIteratorBase& src)

+        # public:

+        # typedef typename OctreeT::LeafNode LeafNode;

+        # typedef typename OctreeT::BranchNode BranchNode;

+        # /** \brief initialize iterator globals */

+        # inline void reset ()

+        # /** \brief Get octree key for the current iterator octree node

+        #  * \return octree key of current node

+        # inline const OctreeKey& getCurrentOctreeKey () const

+        # /** \brief Get the current depth level of octree

+        #  * \return depth level

+        # inline unsigned int getCurrentOctreeDepth () const

+        # /** \brief Get the current octree node

+        #  * \return pointer to current octree node

+        # inline OctreeNode* getCurrentOctreeNode () const

+        # /** \brief *operator.

+        #  * \return pointer to the current octree node

+        # inline OctreeNode* operator* () const

+        # /** \brief check if current node is a branch node

+        #  * \return true if current node is a branch node, false otherwise

+        # inline bool isBranchNode () const

+        # /** \brief check if current node is a branch node

+        #  * \return true if current node is a branch node, false otherwise

+        # inline bool isLeafNode () const

+        # /** \brief Get bit pattern of children configuration of current node

+        #  * \return bit pattern (byte) describing the existence of 8 children of the current node

+        # inline char getNodeConfiguration () const

+        # /** \brief Method for retrieving a single DataT element from the octree leaf node

+        #  * \param[in] data_arg reference to return pointer of leaf node DataT element.

+        # virtual void getData (DataT& data_arg) const

+        # /** \brief Method for retrieving a vector of DataT elements from the octree laef node

+        #  * \param[in] dataVector_arg reference to DataT vector that is extended with leaf node DataT elements.

+        # virtual void getData (std::vector<DataT>& dataVector_arg) const

+        # /** \brief Method for retrieving the size of the DataT vector from the octree laef node

+        # virtual std::size_t getSize () const

+        # /** \brief get a integer identifier for current node (note: identifier depends on tree depth).

+        #  * \return node id.

+        # virtual unsigned long getNodeID () const

+

+

+###

+

+# template<typename DataT, typename OctreeT>

+# class OctreeDepthFirstIterator : public OctreeIteratorBase<DataT, OctreeT>

+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":

+    cdef cppclass OctreeDepthFirstIterator[DataT, OctreeT](OctreeIteratorBase[DataT, OctreeT]):

+        OctreeDepthFirstIterator()

+        # explicit OctreeDepthFirstIterator (OctreeT& octree_arg)

+        # public:

+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::LeafNode LeafNode;

+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::BranchNode BranchNode;

+        # /** \brief Reset the iterator to the root node of the octree

+        # virtual void reset ();

+        # /** \brief Preincrement operator.

+        #  * \note recursively step to next octree node

+        # OctreeDepthFirstIterator& operator++ ();

+        # /** \brief postincrement operator.

+        #  * \note recursively step to next octree node

+        # inline OctreeDepthFirstIterator operator++ (int)

+        # /** \brief Skip all child voxels of current node and return to parent node.

+        # void skipChildVoxels ();

+        # protected:

+        # /** Child index at current octree node. */

+        # unsigned char currentChildIdx_;

+        # /** Stack structure. */

+        # std::vector<std::pair<OctreeNode*, unsigned char> > stack_;

+

+

+###

+

+

+# template<typename DataT, typename OctreeT>

+# class OctreeBreadthFirstIterator : public OctreeIteratorBase<DataT, OctreeT>

+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":

+    cdef cppclass OctreeBreadthFirstIterator[DataT, OctreeT](OctreeIteratorBase[DataT, OctreeT]):

+        OctreeDepthFirstIterator()

+        # explicit OctreeBreadthFirstIterator (OctreeT& octree_arg);

+        # // public typedefs

+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::BranchNode BranchNode;

+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::LeafNode LeafNode;

+        # struct FIFOElement

+        # {

+        #   OctreeNode* node;

+        #   OctreeKey key;

+        #   unsigned int depth;

+        # };

+        # public:

+        # /** \brief Reset the iterator to the root node of the octree

+        # void reset ();

+        # /** \brief Preincrement operator.

+        #  * \note step to next octree node

+        # OctreeBreadthFirstIterator& operator++ ();

+        # /** \brief postincrement operator.

+        #  * \note step to next octree node

+        # inline OctreeBreadthFirstIterator operator++ (int)

+        # protected:

+        # /** \brief Add children of node to FIFO

+        #  * \param[in] node: node with children to be added to FIFO

+        # void addChildNodesToFIFO (const OctreeNode* node);

+        # /** FIFO list */

+        # std::deque<FIFOElement> FIFO_;

+###

+

+# template<typename DataT, typename OctreeT>

+# class OctreeLeafNodeIterator : public OctreeDepthFirstIterator<DataT, OctreeT>

+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":

+    cdef cppclass OctreeLeafNodeIterator[DataT, OctreeT](OctreeDepthFirstIterator[DataT, OctreeT]):

+        OctreeLeafNodeIterator()

+        # explicit OctreeLeafNodeIterator (OctreeT& octree_arg)

+        # typedef typename OctreeDepthFirstIterator<DataT, OctreeT>::BranchNode BranchNode;

+        # typedef typename OctreeDepthFirstIterator<DataT, OctreeT>::LeafNode LeafNode;

+        # public:

+        # /** \brief Constructor.

+        #  * \param[in] octree_arg Octree to be iterated. Initially the iterator is set to its root node.

+        # /** \brief Reset the iterator to the root node of the octree

+        # inline void reset ()

+        # /** \brief Preincrement operator.

+        #  * \note recursively step to next octree leaf node

+        # inline OctreeLeafNodeIterator& operator++ ()

+        # /** \brief postincrement operator.

+        #  * \note step to next octree node

+        # inline OctreeLeafNodeIterator operator++ (int)

+        # /** \brief *operator.

+        #  * \return pointer to the current octree leaf node

+        # OctreeNode* operator* () const

+###

+

+# octree_key.h

+# namespace pcl

+# namespace octree

+# class OctreeKey

+cdef extern from "pcl/octree/octree_key.h" namespace "pcl::octree":

+    cdef cppclass OctreeKey:

+        OctreeKey()

+        # OctreeKey (unsigned int keyX, unsigned int keyY, unsigned int keyZ) :

+        # OctreeKey (const OctreeKey& source) :

+        # public:

+        # /** \brief Operator== for comparing octree keys with each other.

+        # *  \return "true" if leaf node indices are identical; "false" otherwise.

+        # bool operator == (const OctreeKey& b) const

+        # /** \brief Operator<= for comparing octree keys with each other.

+        # *  \return "true" if key indices are not greater than the key indices of b  ; "false" otherwise.

+        # bool operator <= (const OctreeKey& b) const

+        # /** \brief Operator>= for comparing octree keys with each other.

+        # *  \return "true" if key indices are not smaller than the key indices of b  ; "false" otherwise.

+        # bool operator >= (const OctreeKey& b) const

+        # /** \brief push a child node to the octree key

+        # *  \param[in] childIndex index of child node to be added (0-7)

+        # */

+        # inline void pushBranch (unsigned char childIndex)

+        # /** \brief pop child node from octree key

+        # inline void popBranch ()

+        # /** \brief get child node index using depthMask

+        # *  \param[in] depthMask bit mask with single bit set at query depth

+        # *  \return child node index

+        # * */

+        # inline unsigned char getChildIdxWithDepthMask (unsigned int depthMask) const

+        # // Indices addressing a voxel at (X, Y, Z)

+        # unsigned int x;

+        # unsigned int y;

+        # unsigned int z;

+###

+

+# pcl 1.8.0 nothing

+# octree_node_pool.h

+# namespace pcl

+# namespace octree

+# template<typename NodeT>

+# class OctreeNodePool

+cdef extern from "pcl/octree/octree_node_pool.h" namespace "pcl::octree":

+    cdef cppclass OctreeNodePool[NodeT]:

+        OctreeNodePool()

+        # public:

+        # /** \brief Push node to pool

+        # *  \param childIdx_arg: pointer of noe

+        # inline void pushNode (NodeT* node_arg)

+        # /** \brief Pop node from pool - Allocates new nodes if pool is empty

+        # *  \return Pointer to octree node

+        # inline NodeT* popNode ()

+        # /** \brief Delete all nodes in pool

+        # */

+        # void deletePool ()

+        # protected:

+        # vector<NodeT*> nodePool_;

+###

+

+# NG

+# octree_nodes.h

+# namespace pcl

+# namespace octree

+#     // enum of node types within the octree

+#     enum node_type_t

+#     {

+#       BRANCH_NODE, LEAF_NODE

+#     };

+##

+# namespace pcl

+# namespace octree

+# class PCL_EXPORTS OctreeNode

+#       public:

+#       OctreeNode ()

+#       /** \brief Pure virtual method for receiving the type of octree node (branch or leaf)  */

+#       virtual node_type_t getNodeType () const = 0;

+#       /** \brief Pure virtual method to perform a deep copy of the octree */

+#       virtual OctreeNode* deepCopy () const = 0;

+##

+# template<typename ContainerT>

+# class OctreeLeafNode : public OctreeNode, public ContainerT

+# cdef cppclass OctreeLeafNode[ContainerT](OctreeNode)(ContainerT):

+# cdef extern from "pcl/octree/octree_nodes.h" namespace "pcl::octree":

+#     cdef cppclass OctreeLeafNode[ContainerT]:

+#         OctreeLeafNode()

+#         # OctreeLeafNode (const OctreeLeafNode& source) :

+#         # public:

+#         # using ContainerT::getSize;

+#         # using ContainerT::getData;

+#         # using ContainerT::setData;

+#         # /** \brief Method to perform a deep copy of the octree */

+#         # virtual OctreeLeafNode<ContainerT>* deepCopy () const

+#         # /** \brief Get the type of octree node. Returns LEAVE_NODE type */

+#         # virtual node_type_t getNodeType () const

+#         # /** \brief Reset node */

+#         # inline void reset ()

+###

+# # template<typename ContainerT>

+# # class OctreeBranchNode : public OctreeNode, ContainerT

+# # cdef extern from "pcl/octree/octree_nodes.h" namespace "pcl::octree":

+# #     cdef cppclass OctreeBranchNode[ContainerT]:

+# #         OctreeBranchNode()

+#         # OctreeBranchNode (const OctreeBranchNode& source)

+#         # inline OctreeBranchNode& operator = (const OctreeBranchNode &source)

+#         # public:

+#         # using ContainerT::getSize;

+#         # using ContainerT::getData;

+#         # using ContainerT::setData;

+#         # /** \brief Octree deep copy method */

+#         # virtual OctreeBranchNode* deepCopy () const

+#         # inline void reset ()

+#         # /** \brief Access operator.

+#         #  *  \param childIdx_arg: index to child node

+#         #  *  \return OctreeNode pointer

+#         #  * */

+#         # inline OctreeNode*& operator[] (unsigned char childIdx_arg)

+#         # /** \brief Get pointer to child

+#         #  *  \param childIdx_arg: index to child node

+#         #  *  \return OctreeNode pointer

+#         #  * */

+#         # inline OctreeNode* getChildPtr (unsigned char childIdx_arg) const

+#         # /** \brief Get pointer to child

+#         #  *  \return OctreeNode pointer

+#         #  * */

+#         # inline void setChildPtr (OctreeNode* child, unsigned char index)

+#         # /** \brief Check if branch is pointing to a particular child node

+#         #  *  \param childIdx_arg: index to child node

+#         #  *  \return "true" if pointer to child node exists; "false" otherwise

+#         #  * */

+#         # inline bool hasChild (unsigned char childIdx_arg) const

+#         # /** \brief Get the type of octree node. Returns LEAVE_NODE type */

+#         # virtual node_type_t getNodeType () const

+#         # protected:

+#         # OctreeNode* childNodeArray_[8];

+###

+

+# octree_pointcloud.h

+# namespace pcl

+# namespace octree

+# template<typename PointT, typename LeafT = OctreeContainerDataTVector<int>,

+#       typename BranchT = OctreeContainerEmpty<int>,

+#       typename OctreeT = OctreeBase<int, LeafT, BranchT> >

+# class OctreePointCloud : public OctreeT

+cdef extern from "pcl/octree/octree_pointcloud.h" namespace "pcl::octree":

+    # cdef cppclass OctreePointCloud[PointT]:

+    # cdef cppclass OctreePointCloud[PointT, LeafT, BranchT, OctreeT](OctreeBase[int, LeafT, BranchT]):

+    # cdef cppclass OctreePointCloud[PointT](OctreeBase[int]):

+    # cdef cppclass OctreePointCloud[PointT](Octree2BufBase[int]):

+    # (cpp build LINK2019)

+    # cdef cppclass OctreePointCloud[PointT, LeafT, BranchT, OctreeT]:

+    cdef cppclass OctreePointCloud[PointT, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, OctreeT]:

+        OctreePointCloud(const double resolution_arg)

+        # OctreePointCloud(double resolution_arg)

+        

+        # // iterators are friends

+        # friend class OctreeIteratorBase<int, OctreeT> ;

+        # friend class OctreeDepthFirstIterator<int, OctreeT> ;

+        # friend class OctreeBreadthFirstIterator<int, OctreeT> ;

+        # friend class OctreeLeafNodeIterator<int, OctreeT> ;

+        # public:

+        # typedef OctreeT Base;

+        # typedef typename OctreeT::LeafNode LeafNode;

+        # typedef typename OctreeT::BranchNode BranchNode;

+        # // Octree iterators

+        # typedef OctreeDepthFirstIterator<int, OctreeT> Iterator;

+        # typedef const OctreeDepthFirstIterator<int, OctreeT> ConstIterator;

+        # typedef OctreeLeafNodeIterator<int, OctreeT> LeafNodeIterator;

+        # typedef const OctreeLeafNodeIterator<int, OctreeT> ConstLeafNodeIterator;

+        # typedef OctreeDepthFirstIterator<int, OctreeT> DepthFirstIterator;

+        # typedef const OctreeDepthFirstIterator<int, OctreeT> ConstDepthFirstIterator;

+        # typedef OctreeBreadthFirstIterator<int, OctreeT> BreadthFirstIterator;

+        # typedef const OctreeBreadthFirstIterator<int, OctreeT> ConstBreadthFirstIterator;

+        # /** \brief Octree pointcloud constructor.

+        #  * \param[in] resolution_arg octree resolution at lowest octree level

+        # // public typedefs

+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;

+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;

+        # typedef pcl::PointCloud<PointT> PointCloud;

+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;

+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;

+        # // public typedefs for single/double buffering

+        # typedef OctreePointCloud<PointT, LeafT, OctreeBase<int, LeafT> > SingleBuffer;

+        # typedef OctreePointCloud<PointT, LeafT, Octree2BufBase<int, LeafT> > DoubleBuffer;

+        # // Boost shared pointers

+        # typedef boost::shared_ptr<OctreePointCloud<PointT, LeafT, OctreeT> > Ptr;

+        # typedef boost::shared_ptr<const OctreePointCloud<PointT, LeafT, OctreeT> > ConstPtr;

+        # // Eigen aligned allocator

+        # typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;

+        # 

+        # /** \brief Provide a pointer to the input data set.

+        #  * \param[in] cloud_arg the const boost shared pointer to a PointCloud message

+        #  * \param[in] indices_arg the point indices subset that is to be used from \a cloud - if 0 the whole point cloud is used

+        #  */

+        # inline void setInputCloud (const PointCloudConstPtr &cloud_arg, const IndicesConstPtr &indices_arg = IndicesConstPtr ())

+        void setInputCloud (shared_ptr[cpp.PointCloud[PointT]] &cloud_arg)

+        # void setInputCloud (const shared_ptr[cpp.PointCloud] &cloud_arg, const shared_ptr[const vector[int]] &indices_ar)

+        

+        # /** \brief Get a pointer to the vector of indices used.

+        #  * \return pointer to vector of indices used.

+        #  */

+        # inline IndicesConstPtr const getIndices () const

+        const shared_ptr[const vector[int]] getIndices ()

+        

+        # /** \brief Get a pointer to the input point cloud dataset.

+        #  * \return pointer to pointcloud input class.

+        #  */

+        # inline PointCloudConstPtr getInputCloud () const

+        # PointCloudConstPtr getInputCloud () const

+        shared_ptr[const cpp.PointCloud[PointT]] getInputCloud ()

+        

+        # /** \brief Set the search epsilon precision (error bound) for nearest neighbors searches.

+        #  * \param[in] eps precision (error bound) for nearest neighbors searches

+        #  */

+        # inline void setEpsilon (double eps)

+        void setEpsilon (double eps)

+        

+        # /** \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */

+        # inline double getEpsilon () const

+        double getEpsilon () const

+        

+        # /** \brief Set/change the octree voxel resolution

+        #  * \param[in] resolution_arg side length of voxels at lowest tree level

+        #  */

+        # inline void setResolution (double resolution_arg)

+        void setResolution (double resolution_arg)

+        

+        # /** \brief Get octree voxel resolution

+        #  * \return voxel resolution at lowest tree level

+        #  */

+        # inline double getResolution () const

+        double getResolution () const

+        

+        # \brief Get the maximum depth of the octree.

+        # \return depth_arg: maximum depth of octree

+        # inline unsigned int getTreeDepth () const

+        unsigned int getTreeDepth ()

+        

+        # brief Add points from input point cloud to octree.

+        # void addPointsFromInputCloud ();

+        void addPointsFromInputCloud ()

+        

+        # \brief Add point at given index from input point cloud to octree. Index will be also added to indices vector.

+        # \param[in] pointIdx_arg index of point to be added

+        # \param[in] indices_arg pointer to indices vector of the dataset (given by \a setInputCloud)

+        # void addPointFromCloud (const int pointIdx_arg, IndicesPtr indices_arg);

+        void addPointFromCloud (const int pointIdx_arg, shared_ptr[vector[int]] indices_arg)

+        

+        # \brief Add point simultaneously to octree and input point cloud.

+        # \param[in] point_arg point to be added

+        # \param[in] cloud_arg pointer to input point cloud dataset (given by \a setInputCloud)

+        # void addPointToCloud (const PointT& point_arg, PointCloudPtr cloud_arg);

+        void addPointToCloud (const PointT& point_arg, shared_ptr[cpp.PointCloud[PointT]] cloud_arg)

+        

+        # \brief Add point simultaneously to octree and input point cloud. A corresponding index will be added to the indices vector.

+        # \param[in] point_arg point to be added

+        # \param[in] cloud_arg pointer to input point cloud dataset (given by \a setInputCloud)

+        # \param[in] indices_arg pointer to indices vector of the dataset (given by \a setInputCloud)

+        # void addPointToCloud (const PointT& point_arg, PointCloudPtr cloud_arg, IndicesPtr indices_arg);

+        void addPointToCloud (const PointT& point_arg, shared_ptr[cpp.PointCloud[PointT]] cloud_arg, shared_ptr[vector[int]] indices_arg)

+        

+        # \brief Check if voxel at given point exist.

+        # \param[in] point_arg point to be checked

+        # \return "true" if voxel exist; "false" otherwise

+        # bool isVoxelOccupiedAtPoint (const PointT& point_arg) const;

+        # bool isVoxelOccupiedAtPoint (const PointT& point_arg)

+        

+        # \brief Delete the octree structure and its leaf nodes.

+        # \param freeMemory_arg: if "true", allocated octree nodes are deleted, otherwise they are pushed to the octree node pool

+        # void deleteTree (bool freeMemory_arg = false)

+        void deleteTree()

+        # void deleteTree (bool freeMemory_arg)

+        

+        # \brief Check if voxel at given point coordinates exist.

+        # \param[in] pointX_arg X coordinate of point to be checked

+        # \param[in] pointY_arg Y coordinate of point to be checked

+        # \param[in] pointZ_arg Z coordinate of point to be checked

+        # \return "true" if voxel exist; "false" otherwise

+        # bool isVoxelOccupiedAtPoint (const double pointX_arg, const double pointY_arg, const double pointZ_arg) const;

+        # bool isVoxelOccupiedAtPoint(double, double, double)

+        bool isVoxelOccupiedAtPoint (const double pointX_arg, const double pointY_arg, const double pointZ_arg)

+        

+        # \brief Check if voxel at given point from input cloud exist.

+        # \param[in] pointIdx_arg point to be checked

+        # \return "true" if voxel exist; "false" otherwise

+        # bool isVoxelOccupiedAtPoint (const int& pointIdx_arg) const;

+        # bool isVoxelOccupiedAtPoint (const int& pointIdx_arg)

+        

+        # \brief Get a T vector of centers of all occupied voxels.

+        # \param[out] voxelCenterList_arg results are written to this vector of T elements

+        # \return number of occupied voxels

+        # int getOccupiedVoxelCenters (vector2[PointT, eig.aligned_allocator[PointT]] &voxelCenterList_arg) const;

+        # int getOccupiedVoxelCenters(vector2[PointT, eig.aligned_allocator[PointT]])

+        int getOccupiedVoxelCenters (vector2[PointT, eig.aligned_allocator[PointT]] &voxelCenterList_arg)

+        

+        # \brief Get a T vector of centers of voxels intersected by a line segment.

+        #  This returns a approximation of the actual intersected voxels by walking

+        #  along the line with small steps. Voxels are ordered, from closest to

+        #  furthest w.r.t. the origin.

+        # \param[in] origin origin of the line segment

+        # \param[in] end end of the line segment

+        # \param[out] voxel_center_list results are written to this vector of T elements

+        # \param[in] precision determines the size of the steps: step_size = octree_resolution x precision

+        # \return number of intersected voxels

+        # int getApproxIntersectedVoxelCentersBySegment (const Eigen::Vector3f& origin, const Eigen::Vector3f& end, AlignedPointTVector &voxel_center_list, float precision = 0.2);

+        int getApproxIntersectedVoxelCentersBySegment (const eig.Vector3f& origin, const eig.Vector3f& end, vector2[PointT, eig.aligned_allocator[PointT]] &voxel_center_list, float precision)

+        

+        # \brief Delete leaf node / voxel at given point

+        # \param[in] point_arg point addressing the voxel to be deleted.

+        # void deleteVoxelAtPoint(const PointT& point_arg);

+        # void deleteVoxelAtPoint(PointT point)

+        void deleteVoxelAtPoint (const PointT& point_arg)

+        

+        # \brief Delete leaf node / voxel at given point from input cloud

+        # \param[in] pointIdx_arg index of point addressing the voxel to be deleted.

+        # void deleteVoxelAtPoint (const int& pointIdx_arg);

+        void deleteVoxelAtPoint (const int& pointIdx_arg)

+        

+        # Bounding box methods

+        # \brief Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. */

+        # void defineBoundingBox ();

+        void defineBoundingBox ()

+        

+        # \brief Define bounding box for octree

+        # \note Bounding box cannot be changed once the octree contains elements.

+        # \param[in] minX_arg X coordinate of lower bounding box corner

+        # \param[in] minY_arg Y coordinate of lower bounding box corner

+        # \param[in] minZ_arg Z coordinate of lower bounding box corner

+        # \param[in] maxX_arg X coordinate of upper bounding box corner

+        # \param[in] maxY_arg Y coordinate of upper bounding box corner

+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner

+        # void defineBoundingBox (const double minX_arg, const double minY_arg, const double minZ_arg, const double maxX_arg, const double maxY_arg, const double maxZ_arg);

+        # void defineBoundingBox(double, double, double, double, double, double)

+        void defineBoundingBox (const double minX_arg, const double minY_arg, const double minZ_arg, const double maxX_arg, const double maxY_arg, const double maxZ_arg)

+        

+        # \brief Define bounding box for octree

+        # \note Lower bounding box point is set to (0, 0, 0)

+        # \note Bounding box cannot be changed once the octree contains elements.

+        # \param[in] maxX_arg X coordinate of upper bounding box corner

+        # \param[in] maxY_arg Y coordinate of upper bounding box corner

+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner

+        # void defineBoundingBox (const double maxX_arg, const double maxY_arg, const double maxZ_arg);

+        # void defineBoundingBox (const double maxX_arg, const double maxY_arg, const double maxZ_arg)

+        

+        # \brief Define bounding box cube for octree

+        # \note Lower bounding box corner is set to (0, 0, 0)

+        # \note Bounding box cannot be changed once the octree contains elements.

+        # \param[in] cubeLen_arg side length of bounding box cube.

+        # void defineBoundingBox (const double cubeLen_arg);

+        # void defineBoundingBox (const double cubeLen_arg)

+        

+        # \brief Get bounding box for octree

+        # \note Bounding box cannot be changed once the octree contains elements.

+        # \param[in] minX_arg X coordinate of lower bounding box corner

+        # \param[in] minY_arg Y coordinate of lower bounding box corner

+        # \param[in] minZ_arg Z coordinate of lower bounding box corner

+        # \param[in] maxX_arg X coordinate of upper bounding box corner

+        # \param[in] maxY_arg Y coordinate of upper bounding box corner

+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner

+        # void getBoundingBox (double& minX_arg, double& minY_arg, double& minZ_arg, double& maxX_arg, double& maxY_arg, double& maxZ_arg) const;

+        void getBoundingBox (double& minX_arg, double& minY_arg, double& minZ_arg, double& maxX_arg, double& maxY_arg, double& maxZ_arg)

+        

+        # \brief Calculates the squared diameter of a voxel at given tree depth

+        # \param[in] treeDepth_arg depth/level in octree

+        # \return squared diameter

+        # double getVoxelSquaredDiameter (unsigned int treeDepth_arg) const;

+        double getVoxelSquaredDiameter (unsigned int treeDepth_arg)

+        

+        # \brief Calculates the squared diameter of a voxel at leaf depth

+        # \return squared diameter

+        # inline double getVoxelSquaredDiameter () const

+        double getVoxelSquaredDiameter ()

+        

+        # \brief Calculates the squared voxel cube side length at given tree depth

+        # \param[in] treeDepth_arg depth/level in octree

+        # \return squared voxel cube side length

+        # double getVoxelSquaredSideLen (unsigned int treeDepth_arg) const;

+        double getVoxelSquaredSideLen (unsigned int treeDepth_arg)

+        

+        # \brief Calculates the squared voxel cube side length at leaf level

+        # \return squared voxel cube side length

+        # inline double getVoxelSquaredSideLen () const

+        double getVoxelSquaredSideLen ()

+        

+        # \brief Generate bounds of the current voxel of an octree iterator

+        # \param[in] iterator: octree iterator

+        # \param[out] min_pt lower bound of voxel

+        # \param[out] max_pt upper bound of voxel

+        # inline void getVoxelBounds (OctreeIteratorBase<int, OctreeT>& iterator, Eigen::Vector3f &min_pt, Eigen::Vector3f &max_pt)

+        void getVoxelBounds (OctreeIteratorBase[int, OctreeT]& iterator, eig.Vector3f &min_pt, eig.Vector3f &max_pt)

+

+

+# ctypedef OctreePointCloud[cpp.PointXYZ] OctreePointCloud_t

+# ctypedef OctreePointCloud[cpp.PointXYZI] OctreePointCloud_PointXYZI_t

+# ctypedef OctreePointCloud[cpp.PointXYZRGB] OctreePointCloud_PointXYZRGB_t

+# ctypedef OctreePointCloud[cpp.PointXYZRGBA] OctreePointCloud_PointXYZRGBA_t

+ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, OctreeBase_t] OctreePointCloud_t

+ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, OctreeBase_t] OctreePointCloud_PointXYZI_t

+ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, OctreeBase_t] OctreePointCloud_PointXYZRGB_t

+ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, OctreeBase_t] OctreePointCloud_PointXYZRGBA_t

+ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, Octree2BufBase_t] OctreePointCloud2Buf_t

+ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, Octree2BufBase_t] OctreePointCloud2Buf_PointXYZI_t

+ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, Octree2BufBase_t] OctreePointCloud2Buf_PointXYZRGB_t

+ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, Octree2BufBase_t] OctreePointCloud2Buf_PointXYZRGBA_t

+###

+

+

+# Version 1.7.2, 1.8.0 NG(use octree_pointcloud.h)

+# namespace pcl

+# namespace octree

+# template<typename PointT, typename LeafT = OctreeContainerDataTVector<int>,

+# typename BranchT = OctreeContainerEmpty<int> >

+#     class OctreePointCloudChangeDetector : public OctreePointCloud<PointT, LeafT, BranchT, Octree2BufBase<int, LeafT, BranchT> >

+cdef extern from "pcl/octree/octree_pointcloud_changedetector.h" namespace "pcl::octree":

+    # cdef cppclass OctreePointCloudChangeDetector[PointT](OctreePointCloud[PointT]):

+    # cdef cppclass OctreePointCloudChangeDetector[PointT, LeafT, BranchT](OctreePointCloud[PointT, LeafT, BranchT, Octree2BufBase[int, LeafT, BranchT]]):

+    # cdef cppclass OctreePointCloudChangeDetector[PointT](OctreePointCloud[PointT](Octree2BufBase[int])):

+    # cdef cppclass OctreePointCloudChangeDetector[PointT](OctreePointCloud[PointT, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, Octree2BufBase_t]):

+    cdef cppclass OctreePointCloudChangeDetector[PointT](OctreePointCloud[PointT, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, Octree2BufBase_t]):

+        OctreePointCloudChangeDetector (const double resolution_arg)

+        # public:

+        # /** \brief Get a indices from all leaf nodes that did not exist in previous buffer.

+        # * \param indicesVector_arg: results are written to this vector of int indices

+        # * \param minPointsPerLeaf_arg: minimum amount of points required within leaf node to become serialized.

+        # * \return number of point indices

+        # int getPointIndicesFromNewVoxels (std::vector<int> &indicesVector_arg, const int minPointsPerLeaf_arg = 0)

+        int getPointIndicesFromNewVoxels (vector[int] &indicesVector_arg, const int minPointsPerLeaf_arg)

+

+

+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZ] OctreePointCloudChangeDetector_t

+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZI] OctreePointCloudChangeDetector_PointXYZI_t

+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t

+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t

+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t

+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t

+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGB]] OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t

+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGBA]] OctreePointCloudChangeDetector_PointXYZRGBA_Ptr_t

+###

+

+# octree_pointcloud_density.h

+# namespace pcl

+# namespace octree

+# template<typename DataT>

+# class OctreePointCloudDensityContainer

+cdef extern from "pcl/octree/octree_pointcloud_density.h" namespace "pcl::octree":

+    cdef cppclass OctreePointCloudDensityContainer[DataT]:

+        OctreePointCloudDensityContainer ()

+        # /** \brief deep copy function */

+        # virtual OctreePointCloudDensityContainer * deepCopy () const

+        

+        # /** \brief Get size of container (number of DataT objects)

+        #  * \return number of DataT elements in leaf node container.

+        # size_t getSize () const

+        

+        # /** \brief Read input data. Only an internal counter is increased.

+        # void setData (const DataT&)

+        

+        # /** \brief Returns a null pointer as this leaf node does not store any data.

+        #   * \param[out] data_arg: reference to return pointer of leaf node DataT element (will be set to 0).

+        # void getData (const DataT*& data_arg) const

+        

+        # /** \brief Empty getData data vector implementation as this leaf node does not store any data. \

+        # void getData (std::vector<DataT>&) const

+        

+        # /** \brief Return point counter.

+        #   * \return Amaount of points

+        # unsigned int getPointCounter ()

+        

+        # /** \brief Empty reset leaf node implementation as this leaf node does not store any data. */

+        void reset ()

+

+

+ctypedef OctreePointCloudDensityContainer[int] OctreePointCloudDensityContainer_t

+ctypedef shared_ptr[OctreePointCloudDensityContainer[int]] OctreePointCloudDensityContainerPtr_t

+###

+

+# template<typename PointT, typename LeafT = OctreePointCloudDensityContainer<int> , typename BranchT = OctreeContainerEmpty<int> >

+# class OctreePointCloudDensity : public OctreePointCloud<PointT, LeafT, BranchT>

+cdef extern from "pcl/octree/octree_pointcloud_density.h" namespace "pcl::octree":

+    # cdef cppclass OctreePointCloudDensity[PointT, LeafT, BranchT](OctreePointCloud[PointT, LeafT, BranchT]):

+    cdef cppclass OctreePointCloudDensity[PointT](OctreePointCloud[PointT, OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t, OctreeBase_t]):

+        OctreePointCloudDensity (const double resolution_arg)

+        # \brief Get the amount of points within a leaf node voxel which is addressed by a point

+        # \param[in] point_arg: a point addressing a voxel

+        # \return amount of points that fall within leaf node voxel

+        # unsigned int getVoxelDensityAtPoint (const PointT& point_arg) const

+

+

+ctypedef OctreePointCloudDensity[cpp.PointXYZ] OctreePointCloudDensity_t

+ctypedef OctreePointCloudDensity[cpp.PointXYZI] OctreePointCloudDensity_PointXYZI_t

+ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t

+ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t

+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t

+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t

+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGB]] OctreePointCloudDensity_PointXYZRGB_Ptr_t

+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGBA]] OctreePointCloudDensity_PointXYZRGBA_Ptr_t

+###

+

+# octree_pointcloud_occupancy.h

+###

+# octree_pointcloud_pointvector.h

+###

+# octree_pointcloud_singlepoint.h

+###

+# octree_pointcloud_voxelcentroid.h

+###

+

+# octree_search.h

+cdef extern from "pcl/octree/octree_search.h" namespace "pcl::octree":

+    cdef cppclass OctreePointCloudSearch[PointT](OctreePointCloud[PointT, OctreeContainerDataTVector_t, OctreeContainerEmpty_t, OctreeBase_t]):

+        OctreePointCloudSearch (const double resolution_arg)

+        

+        int radiusSearch (cpp.PointXYZ, double, vector[int], vector[float], unsigned int)

+        int radiusSearch (cpp.PointXYZI, double, vector[int], vector[float], unsigned int)

+        int radiusSearch (cpp.PointXYZRGB, double, vector[int], vector[float], unsigned int)

+        int radiusSearch (cpp.PointXYZRGBA, double, vector[int], vector[float], unsigned int)

+        # PointT

+        # int radiusSearch (PointT, double, vector[int], vector[float], unsigned int)

+        

+        # Add index(inline?)

+        int radiusSearch (cpp.PointCloud[PointT], int, double, vector[int], vector[float], unsigned int)

+        

+        # inline define

+        # int nearestKSearch (cpp.PointCloud[PointT], int, int, vector[int], vector[float])

+        int nearestKSearch (cpp.PointCloud[PointT], int, int, vector[int], vector[float])

+        

+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;

+        # int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)

+        

+        ## Functions

+        # brief Search for neighbors within a voxel at given point

+        # param[in] point point addressing a leaf node voxel

+        # param[out] point_idx_data the resultant indices of the neighboring voxel points

+        # return "true" if leaf node exist; "false" otherwise

+        # bool voxelSearch (const PointT& point, std::vector<int>& point_idx_data);

+        bool voxelSearch (const PointT& point, vector[int] point_idx_data)

+        

+        # brief Search for neighbors within a voxel at given point referenced by a point index

+        # param[in] index the index in input cloud defining the query point

+        # param[out] point_idx_data the resultant indices of the neighboring voxel points

+        # return "true" if leaf node exist; "false" otherwise

+        # bool voxelSearch (const int index, std::vector<int>& point_idx_data);

+        bool voxelSearch (const int index, vector[int] point_idx_data)

+        

+        # brief Search for approx. nearest neighbor at the query point.

+        # param[in] cloud the point cloud data

+        # param[in] query_index the index in \a cloud representing the query point

+        # param[out] result_index the resultant index of the neighbor point

+        # param[out] sqr_distance the resultant squared distance to the neighboring point

+        # return number of neighbors found

+        # 

+        # inline void approxNearestSearch (const PointCloud &cloud, int query_index, int &result_index, float &sqr_distance)

+        approxNearestSearch (const cpp.PointCloud[PointT] &cloud, int query_index, int &result_index, float &sqr_distance)

+        

+        # /** \brief Search for approx. nearest neighbor at the query point.

+        #   * \param[in] p_q the given query point

+        #   * \param[out] result_index the resultant index of the neighbor point

+        #   * \param[out] sqr_distance the resultant squared distance to the neighboring point

+        #   */

+        # void approxNearestSearch (const PointT &p_q, int &result_index, float &sqr_distance);

+        void approxNearestSearch (const PointT &p_q, int &result_index, float &sqr_distance)

+        

+        # /** \brief Search for approx. nearest neighbor at the query point.

+        #   * \param[in] query_index index representing the query point in the dataset given by \a setInputCloud.

+        #   *        If indices were given in setInputCloud, index will be the position in the indices vector.

+        #   * \param[out] result_index the resultant index of the neighbor point

+        #   * \param[out] sqr_distance the resultant squared distance to the neighboring point

+        #   * \return number of neighbors found

+        #   */

+        # void approxNearestSearch (int query_index, int &result_index, float &sqr_distance);

+        void approxNearestSearch (int query_index, int &result_index, float &sqr_distance)

+        

+        # /** \brief Get a PointT vector of centers of all voxels that intersected by a ray (origin, direction).

+        #   * \param[in] origin ray origin

+        #   * \param[in] direction ray direction vector

+        #   * \param[out] voxel_center_list results are written to this vector of PointT elements

+        #   * \param[in] max_voxel_count stop raycasting when this many voxels intersected (0: disable)

+        #   * \return number of intersected voxels

+        #  */

+        # int getIntersectedVoxelCenters (Eigen::Vector3f origin, Eigen::Vector3f direction, AlignedPointTVector &voxel_center_list, int max_voxel_count = 0) const;

+        # int getIntersectedVoxelCenters (eig.Vector3f origin, eig.Vector3f direction, AlignedPointTVector &voxel_center_list, int max_voxel_count = 0) const;

+        

+        # /** \brief Get indices of all voxels that are intersected by a ray (origin, direction).

+        #   * \param[in] origin ray origin

+        #   * \param[in] direction ray direction vector

+        #   * \param[out] k_indices resulting point indices from intersected voxels

+        #   * \param[in] max_voxel_count stop raycasting when this many voxels intersected (0: disable)

+        #  * \return number of intersected voxels

+        #  */

+        # int getIntersectedVoxelIndices (Eigen::Vector3f origin, Eigen::Vector3f direction, std::vector<int> &k_indices, int max_voxel_count = 0) const; 

+        int getIntersectedVoxelIndices (eig.Vector3f origin, eig.Vector3f direction, vector[int] &k_indices, int max_voxel_count)

+        

+        # /** \brief Search for points within rectangular search area

+        #  * \param[in] min_pt lower corner of search area

+        #  * \param[in] max_pt upper corner of search area

+        #  * \param[out] k_indices the resultant point indices

+        #  * \return number of points found within search area

+        #  */

+        # int boxSearch (const Eigen::Vector3f &min_pt, const Eigen::Vector3f &max_pt, std::vector<int> &k_indices) const;

+        int boxSearch (const eig.Vector3f &min_pt, const eig.Vector3f &max_pt, vector[int] &k_indices)

+

+

+ctypedef OctreePointCloudSearch[cpp.PointXYZ] OctreePointCloudSearch_t

+ctypedef OctreePointCloudSearch[cpp.PointXYZI] OctreePointCloudSearch_PointXYZI_t

+ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t

+ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t

+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t

+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t

+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGB]] OctreePointCloudSearch_PointXYZRGB_Ptr_t

+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGBA]] OctreePointCloudSearch_PointXYZRGBA_Ptr_t

+###

+

+###############################################################################

+# Enum

+###############################################################################

+

+###############################################################################

+# Activation

+###############################################################################

+

+

diff --git a/pcl/pcl_octree_172.pxd b/pcl/pcl_octree_172.pxd
new file mode 100644
index 0000000..9223fb9
--- /dev/null
+++ b/pcl/pcl_octree_172.pxd
@@ -0,0 +1,1458 @@
+# -*- coding: utf-8 -*-
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eig
+from vector cimport vector as vector2
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# octree_container.h
+# namespace pcl
+# namespace octree
+# \brief @b Octree container class that can serve as a base to construct own leaf node container classes.
+# \author Julius Kammerl (julius@kammerl.de)
+# class OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerBase:
+        OctreeContainerBase ()
+        # \brief Empty constructor.
+        
+        # \brief Empty constructor.
+        # OctreeContainerBase (const OctreeContainerBase&)
+        
+        # \brief Empty deconstructor.
+        # virtual ~OctreeContainerBase ()
+        
+        # \brief Equal comparison operator
+        # virtual bool operator== (const OctreeContainerBase&) const
+        
+        # \brief Inequal comparison operator
+        # \param[in] other OctreeContainerBase to compare with
+        # bool operator!= (const OctreeContainerBase& other) const
+        
+        # \brief Pure abstract method to get size of container (number of indices)
+        # \return number of points/indices stored in leaf node container.
+        # virtual size_t getSize () const
+        
+        # \brief Pure abstract reset leaf node implementation. */
+        # virtual void reset () = 0;
+        
+        # \brief Empty addPointIndex implementation. This leaf node does not store any point indices.
+        void addPointIndex (const int&)
+        
+        # \brief Empty getPointIndex implementation as this leaf node does not store any point indices.
+        # void getPointIndex (int&) const
+        
+        # \brief Empty getPointIndices implementation as this leaf node does not store any data.
+        # void getPointIndices (std::vector<int>&) const
+
+
+##
+
+# octree_container.h
+# namespace pcl
+# namespace octree
+# class OctreeContainerEmpty : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerEmpty(OctreeContainerBase):
+        OctreeContainerEmpty()
+        # OctreeContainerEmpty (const OctreeContainerEmpty&)
+        # public:
+        # /** \brief Octree deep copy method */
+        # virtual OctreeContainerEmpty *deepCopy () const
+        # /** \brief Octree deep copy method */
+        # virtual OctreeContainerEmpty *deepCopy () const
+        # 
+        # /** \brief Abstract get size of container (number of DataT objects)
+        # * \return number of DataT elements in leaf node container.
+        # */
+        # virtual size_t getSize () const
+        # 
+        # /** \brief Abstract reset leaf node implementation. */
+        # virtual void reset ()
+        # 
+        # /** \brief Empty addPointIndex implementation. This leaf node does not store any point indices.
+        # */
+        # void addPointIndex (int)
+        # 
+        # /** \brief Empty getPointIndex implementation as this leaf node does not store any point indices.
+        # */
+        # int getPointIndex () const
+        # 
+        # /** \brief Empty getPointIndices implementation as this leaf node does not store any data. \
+        # */
+        # void getPointIndices (std::vector<int>&) const
+
+
+ctypedef OctreeContainerEmpty OctreeContainerEmpty_t
+ctypedef shared_ptr[OctreeContainerEmpty] OctreeContainerEmptyPtr_t
+###
+
+
+# octree_container.h
+# namespace pcl
+# namespace octree
+# \brief @b Octree container class that does store a vector of point indices.
+# \note Enables the octree to store multiple DataT elements within its leaf nodes.
+# \author Julius Kammerl (julius@kammerl.de)
+# class OctreeContainerPointIndices : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerPointIndices(OctreeContainerBase):
+        OctreeContainerPointIndices()
+        #   /** \brief Empty constructor. */
+        #   OctreeContainerPointIndices () :
+        #     OctreeContainerBase (), leafDataTVector_ ()
+        # 
+        #   /** \brief Empty constructor. */
+        #   OctreeContainerPointIndices (const OctreeContainerPointIndices& source) :
+        #       OctreeContainerBase (), leafDataTVector_ (source.leafDataTVector_)
+        # 
+        #   /** \brief Empty deconstructor. */
+        #   virtual
+        #   ~OctreeContainerPointIndices ()
+        # 
+        #   /** \brief Octree deep copy method */
+        #   virtual OctreeContainerPointIndices *deepCopy () const
+        # 
+        #   /** \brief Equal comparison operator
+        #    * \param[in] other OctreeContainerDataTVector to compare with
+        #    */
+        #   virtual bool
+        #   operator== (const OctreeContainerBase& other) const
+        # 
+        #   /** \brief Add point index to container memory. This container stores a vector of point indices.
+        #    * \param[in] data_arg index to be stored within leaf node.
+        #    */
+        #   void addPointIndex (int data_arg)
+        # 
+        #   /** \brief Retrieve point index from container. This container stores a vector of point indices.
+        #    * \return index stored within container.
+        #    */
+        #   int getPointIndex ( ) const
+        # 
+        #   /** \brief Retrieve point indices from container. This container stores a vector of point indices.
+        #    * \param[out] data_vector_arg vector of point indices to be stored within data vector
+        #    */
+        #   void getPointIndices (std::vector<int>& data_vector_arg) const
+        # 
+        #   /** \brief Retrieve reference to point indices vector. This container stores a vector of point indices.
+        #    * \return reference to vector of point indices to be stored within data vector
+        #    */
+        #   std::vector<int>& getPointIndicesVector ()
+        # 
+        #   /** \brief Get size of container (number of indices)
+        #    * \return number of point indices in container.
+        #    */
+        #   size_t getSize () const
+        # 
+        #   /** \brief Reset leaf node. Clear DataT vector.*/
+        #   virtual void reset ()
+
+
+ctypedef OctreeContainerPointIndices OctreeContainerPointIndices_t
+# ctypedef shared_ptr[OctreeContainerPointIndices] OctreeContainerPointIndicesPtr_t
+###
+
+# octree_pointcloud_density.h
+# namespace pcl
+# namespace octree
+# class OctreePointCloudDensityContainer : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_pointcloud_density.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloudDensityContainer(OctreeContainerBase):
+        OctreePointCloudDensityContainer ()
+        # /** \brief deep copy function */
+        # virtual OctreePointCloudDensityContainer * deepCopy () const
+        
+        # /** \brief Equal comparison operator
+        #  * \param[in] other OctreePointCloudDensityContainer to compare with
+        #  */
+        # virtual bool operator==(const OctreeContainerBase& other) const
+        
+        # /** \brief Read input data. Only an internal counter is increased.
+        #   */
+        # void addPointIndex (int)
+        
+        # /** \brief Return point counter.
+        #   * \return Amount of points
+        #   */
+        # unsigned int getPointCounter ()
+        
+        # /** \brief Reset leaf node. */
+        # virtual void reset ()
+
+
+ctypedef OctreePointCloudDensityContainer OctreePointCloudDensityContainer_t
+ctypedef shared_ptr[OctreePointCloudDensityContainer] OctreePointCloudDensityContainerPtr_t
+###
+
+# octree_base.h
+# namespace pcl
+# namespace octree
+# pcl 1.7.2
+# template<typename LeafContainerT = int, typename BranchContainerT = OctreeContainerEmpty >
+# class OctreeBase
+cdef extern from "pcl/octree/octree_base.h" namespace "pcl::octree":
+     # cdef cppclass OctreeBase:
+     cdef cppclass OctreeBase[LeafContainerT, BranchContainerT]:
+        OctreeBase()
+        # OctreeBase (const OctreeBase& source) :
+        # inline OctreeBase& operator = (const OctreeBase &source)
+        # public:
+        # typedef OctreeBase<LeafContainerT, BranchContainerT> OctreeT;
+        # typedef OctreeBranchNode<BranchContainerT> BranchNode;
+        # typedef OctreeLeafNode<LeafContainerT> LeafNode;
+        # typedef BranchContainerT BranchContainer;
+        # typedef LeafContainerT LeafContainer;
+        # // iterators are friends
+        # friend class OctreeIteratorBase<OctreeT> ;
+        # friend class OctreeDepthFirstIterator<OctreeT> ;
+        # friend class OctreeBreadthFirstIterator<OctreeT> ;
+        # friend class OctreeLeafNodeIterator<OctreeT> ;
+        # 
+        # // Octree default iterators
+        # typedef OctreeDepthFirstIterator<OctreeT> Iterator;
+        # typedef const OctreeDepthFirstIterator<OctreeT> ConstIterator;
+        # Iterator begin(unsigned int max_depth_arg = 0) {return Iterator(this, max_depth_arg);};
+        # const Iterator end() {return Iterator();};
+        # 
+        # // Octree leaf node iterators
+        # typedef OctreeLeafNodeIterator<OctreeT> LeafNodeIterator;
+        # typedef const OctreeLeafNodeIterator<OctreeT> ConstLeafNodeIterator;
+        # LeafNodeIterator leaf_begin(unsigned int max_depth_arg = 0) {return LeafNodeIterator(this, max_depth_arg);};
+        # const LeafNodeIterator leaf_end() {return LeafNodeIterator();};
+        # 
+        # // Octree depth-first iterators
+        # typedef OctreeDepthFirstIterator<OctreeT> DepthFirstIterator;
+        # typedef const OctreeDepthFirstIterator<OctreeT> ConstDepthFirstIterator;
+        # DepthFirstIterator depth_begin(unsigned int max_depth_arg = 0) {return DepthFirstIterator(this, max_depth_arg);};
+        # const DepthFirstIterator depth_end() {return DepthFirstIterator();};
+        # 
+        # // Octree breadth-first iterators
+        # typedef OctreeBreadthFirstIterator<OctreeT> BreadthFirstIterator;
+        # typedef const OctreeBreadthFirstIterator<OctreeT> ConstBreadthFirstIterator;
+        # BreadthFirstIterator breadth_begin(unsigned int max_depth_arg = 0) {return BreadthFirstIterator(this, max_depth_arg);};
+        # const BreadthFirstIterator breadth_end() {return BreadthFirstIterator();};
+        # 
+        # /** \brief Empty constructor. */
+        # OctreeBase ();
+        # 
+        # /** \brief Empty deconstructor. */
+        # virtual ~OctreeBase ();
+        # 
+        # /** \brief Copy constructor. */
+        # OctreeBase (const OctreeBase& source)
+        # 
+        # /** \brief Copy operator. */
+        # OctreeBase& operator = (const OctreeBase &source)
+        # 
+        # /** \brief Set the maximum amount of voxels per dimension.
+        #   * \param[in] max_voxel_index_arg maximum amount of voxels per dimension
+        #   */
+        # void setMaxVoxelIndex (unsigned int max_voxel_index_arg);
+        void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg)
+        
+        # \brief Set the maximum depth of the octree.
+        # \param max_depth_arg: maximum depth of octree
+        # void setTreeDepth (unsigned int max_depth_arg);
+        void setTreeDepth (unsigned int max_depth_arg)
+        
+        # \brief Get the maximum depth of the octree.
+        # \return depth_arg: maximum depth of octree
+        # unsigned int getTreeDepth () const
+        unsigned int getTreeDepth ()
+
+        # /** \brief Create new leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to new leaf node container.
+        #  * */
+        # LeafContainerT* createLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief Find leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to leaf node container if found, null pointer otherwise.
+        #  * */
+        # LeafContainerT* findLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief idx_x_arg for the existence of leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return "true" if leaf node search is successful, otherwise it returns "false".
+        #  * */
+        # bool existLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg) const ;
+        # 
+        # /** \brief Remove leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  * */
+        # void removeLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # \brief Return the amount of existing leafs in the octree.
+        # \return amount of registered leaf nodes.
+        # std::size_t getLeafCount () const
+        size_t getLeafCount ()
+        
+        # \brief Return the amount of existing branches in the octree.
+        # \return amount of branch nodes.
+        # std::size_t getBranchCount () const
+        size_t getBranchCount ()
+        
+        # /** \brief Delete the octree structure and its leaf nodes.
+        #  * */
+        # void deleteTree ( );
+        void deleteTree ( )
+        
+        # \brief Serialize octree into a binary output vector describing its branch node structure.
+        # \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        # void serializeTree (vector[char]& binary_tree_out_arg)
+        void serializeTree (vector[char]& binary_tree_out_arg)
+        
+        # 
+        # /** \brief Serialize octree into a binary output vector describing its branch node structure and push all LeafContainerT elements stored in the octree to a vector.
+        #  * \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        #  * \param leaf_container_vector_arg: pointer to all LeafContainerT objects in the octree
+        #  * */
+        # void serializeTree (std::vector<char>& binary_tree_out_arg, std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # void serializeTree (vector[char]& binary_tree_out_arg, vector[LeafContainerT*]& leaf_container_vector_arg)
+        # 
+        # /** \brief Outputs a vector of all LeafContainerT elements that are stored within the octree leaf nodes.
+        #  *  \param leaf_container_vector_arg: pointers to LeafContainerT vector that receives a copy of all LeafContainerT objects in the octree.
+        #  * */
+        # void serializeLeafs (std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # void serializeLeafs (vector[LeafContainerT*]& leaf_container_vector_arg)
+        # 
+        # /** \brief Deserialize a binary octree description vector and create a corresponding octree structure. Leaf nodes are initialized with getDataTByKey(..).
+        #  *  \param binary_tree_input_arg: reference to input vector for reading binary tree structure.
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_input_arg);
+        # void deserializeTree (vector[char]& binary_tree_input_arg)
+        # 
+        # /** \brief Deserialize a binary octree description and create a corresponding octree structure. Leaf nodes are initialized with LeafContainerT elements from the dataVector.
+        #  *  \param binary_tree_input_arg: reference to input vector for reading binary tree structure.
+        #  *  \param leaf_container_vector_arg: pointer to container vector.
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_input_arg, std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # void deserializeTree (vector[char]& binary_tree_input_arg, vector[LeafContainerT*]& leaf_container_vector_arg)
+        # 
+        # typedef OctreeBranchNode<BranchT> BranchNode;
+        # typedef OctreeLeafNode<LeafT> LeafNode;
+        # // Octree iterators
+
+
+ctypedef OctreeBase[int, OctreeContainerEmpty_t] OctreeBase_t
+ctypedef shared_ptr[OctreeBase[int, OctreeContainerEmpty_t]] OctreeBasePtr_t
+# use OctreePointCloud
+ctypedef OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] OctreeBase_OctreeContainerPointIndices_t
+ctypedef shared_ptr[OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] OctreeBase_OctreeContainerPointIndicesPtr_t
+# use OctreePointCloudDensity
+ctypedef OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t] OctreeBase_OctreePointCloudDensity_t
+ctypedef shared_ptr[OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t]] OctreeBase_OctreePointCloudDensityPtr_t
+###
+
+### Inheritance class ###
+
+# octree.h
+# header include
+###
+
+# Version 1.7.2
+# octree2buf_base.h
+# namespace pcl
+# namespace octree
+    # template<typename ContainerT>
+    # class BufferedBranchNode : public OctreeNode, ContainerT
+    # {
+        # using ContainerT::getSize;
+        # using ContainerT::getData;
+        # using ContainerT::setData;
+        # 
+        # public:
+        # /** \brief Empty constructor. */
+        # BufferedBranchNode () : OctreeNode(), ContainerT(),  preBuf(0xFFFFFF), postBuf(0xFFFFFF)
+        # /** \brief Copy constructor. */
+        # BufferedBranchNode (const BufferedBranchNode& source) : ContainerT(source)
+        # /** \brief Copy operator. */
+        # inline BufferedBranchNode& operator = (const BufferedBranchNode &source_arg)
+        # /** \brief Empty constructor. */
+        # virtual ~BufferedBranchNode ()
+        # 
+        # /** \brief Method to perform a deep copy of the octree */
+        # virtual BufferedBranchNode* deepCopy () const
+        # 
+        # /** \brief Get child pointer in current branch node
+        #  *  \param buffer_arg: buffer selector
+        #  *  \param index_arg: index of child in node
+        #  *  \return pointer to child node
+        #  * */
+        # inline OctreeNode* getChildPtr (unsigned char buffer_arg, unsigned char index_arg) const
+        # 
+        # /** \brief Set child pointer in current branch node
+        #  *  \param buffer_arg: buffer selector
+        #  *  \param index_arg: index of child in node
+        #  *  \param newNode_arg: pointer to new child node
+        #  * */
+        # inline void setChildPtr (unsigned char buffer_arg, unsigned char index_arg, OctreeNode* newNode_arg)
+        # 
+        # /** \brief Check if branch is pointing to a particular child node
+        #  *  \param buffer_arg: buffer selector
+        #  *  \param index_arg: index of child in node
+        #  *  \return "true" if pointer to child node exists; "false" otherwise
+        #  * */
+        # inline bool hasChild (unsigned char buffer_arg, unsigned char index_arg) const
+        # 
+        # /** \brief Get the type of octree node. Returns LEAVE_NODE type */
+        # virtual node_type_t getNodeType () const
+        # 
+        # /** \brief Reset branch node container for every branch buffer. */
+        # inline void reset ()
+
+
+###
+
+# namespace pcl
+# namespace octree
+# /** \brief @b Octree double buffer class
+#  * \note This octree implementation keeps two separate octree structures
+#  * in memory. This enables to create octree structures at high rate due to
+#  * an advanced memory management.
+#  * \note Furthermore, it allows for detecting and differentially compare the adjacent octree structures.
+#  * \note The tree depth defines the maximum amount of octree voxels / leaf nodes (should be initially defined).
+#  * \note All leaf nodes are addressed by integer indices.
+#  * \note Note: The tree depth equates to the bit length of the voxel indices.
+#  * \ingroup octree
+#  * \author Julius Kammerl (julius@kammerl.de)
+#  */
+# template<typename LeafContainerT = int,
+# typename BranchContainerT = OctreeContainerEmpty >
+# class Octree2BufBase
+cdef extern from "pcl/octree/octree2buf_base.h" namespace "pcl::octree":
+    cdef cppclass Octree2BufBase[LeafContainerT, BranchContainerT]:
+        Octree2BufBase()
+        # public:
+        # typedef Octree2BufBase<DataT, LeafT, BranchT> OctreeT;
+        # // iterators are friends
+        # friend class OctreeIteratorBase<DataT, OctreeT> ;
+        # friend class OctreeDepthFirstIterator<DataT, OctreeT> ;
+        # friend class OctreeBreadthFirstIterator<DataT, OctreeT> ;
+        # friend class OctreeLeafNodeIterator<DataT, OctreeT> ;
+        # typedef BufferedBranchNode<BranchT> BranchNode;
+        # typedef OctreeLeafNode<LeafT> LeafNode;
+        # 
+        # // Octree iterators
+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> Iterator;
+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstIterator;
+        # typedef OctreeLeafNodeIterator<DataT, OctreeT> LeafNodeIterator;
+        # typedef const OctreeLeafNodeIterator<DataT, OctreeT> ConstLeafNodeIterator;
+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> DepthFirstIterator;
+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstDepthFirstIterator;
+        # typedef OctreeBreadthFirstIterator<DataT, OctreeT> BreadthFirstIterator;
+        # typedef const OctreeBreadthFirstIterator<DataT, OctreeT> ConstBreadthFirstIterator;
+        # 
+        # /** \brief Empty constructor. */
+        # Octree2BufBase ();
+        # 
+        # /** \brief Empty deconstructor. */
+        # virtual ~Octree2BufBase ();
+        # 
+        # /** \brief Copy constructor. */
+        # Octree2BufBase (const Octree2BufBase& source) :
+        #     leafCount_ (source.leafCount_), branchCount_ (source.branchCount_), objectCount_ (
+        #     source.objectCount_), rootNode_ (
+        #       new (BranchNode) (* (source.rootNode_))), depthMask_ (
+        #       source.depthMask_), maxKey_ (source.maxKey_), branchNodePool_ (), leafNodePool_ (), bufferSelector_ (
+        #         source.bufferSelector_), treeDirtyFlag_ (source.treeDirtyFlag_), octreeDepth_ (
+        #         source.octreeDepth_)
+        # 
+        # /** \brief Copy constructor. */
+        # inline Octree2BufBase& operator = (const Octree2BufBase& source)
+        # 
+        # /** \brief Set the maximum amount of voxels per dimension.
+        #   * \param[in] max_voxel_index_arg maximum amount of voxels per dimension
+        #   */
+        # void setMaxVoxelIndex (unsigned int max_voxel_index_arg);
+        void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg)
+        
+        # \brief Set the maximum depth of the octree.
+        # \param max_depth_arg: maximum depth of octree
+        # void setTreeDepth (unsigned int max_depth_arg);
+        void setTreeDepth (unsigned int max_depth_arg)
+        
+        # \brief Get the maximum depth of the octree.
+        # \return depth_arg: maximum depth of octree
+        # unsigned int getTreeDepth () const
+        unsigned int getTreeDepth ()
+
+        # /** \brief Create new leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to new leaf node container.
+        #  * */
+        # LeafContainerT* createLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief Find leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to leaf node container if found, null pointer otherwise.
+        #  * */
+        # LeafContainerT* findLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief idx_x_arg for the existence of leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return "true" if leaf node search is successful, otherwise it returns "false".
+        #  * */
+        # bool existLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg) const ;
+        # 
+        # /** \brief Remove leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  * */
+        # void removeLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # \brief Return the amount of existing leafs in the octree.
+        # \return amount of registered leaf nodes.
+        # std::size_t getLeafCount () const
+        size_t getLeafCount ()
+        
+        # \brief Return the amount of existing branches in the octree.
+        # \return amount of branch nodes.
+        # std::size_t getBranchCount () const
+        size_t getBranchCount ()
+        
+        # /** \brief Delete the octree structure and its leaf nodes.
+        #  * */
+        # void deleteTree ( );
+        void deleteTree ( )
+        
+        # /** \brief Delete octree structure of previous buffer. */
+        # inline void deletePreviousBuffer ()
+        
+        # /** \brief Delete the octree structure in the current buffer. */
+        # inline void deleteCurrentBuffer ()
+        
+        # /** \brief Switch buffers and reset current octree structure. */
+        void switchBuffers ()
+        
+        # \brief Serialize octree into a binary output vector describing its branch node structure.
+        # \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        # void serializeTree (vector[char]& binary_tree_out_arg)
+        # void serializeTree (vector[char]& binary_tree_out_arg)
+        # 
+        # /** \brief Serialize octree into a binary output vector describing its branch node structure.
+        #  *  \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        #  *  \param do_XOR_encoding_arg: select if binary tree structure should be generated based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void serializeTree (std::vector<char>& binary_tree_out_arg, bool do_XOR_encoding_arg = false);
+        # 
+        # /** \brief Serialize octree into a binary output vector describing its branch node structure and and push all DataT elements stored in the octree to a vector.
+        #  * \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        #  * \param leaf_container_vector_arg: pointer to all LeafContainerT objects in the octree
+        #  * \param do_XOR_encoding_arg: select if binary tree structure should be generated based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void serializeTree (std::vector<char>& binary_tree_out_arg,
+        #                std::vector<LeafContainerT*>& leaf_container_vector_arg,
+        #                bool do_XOR_encoding_arg = false);
+        # 
+        # /** \brief Outputs a vector of all DataT elements that are stored within the octree leaf nodes.
+        #  *  \param leaf_container_vector_arg: vector of pointers to all LeafContainerT objects in the octree
+        #  * */
+        # void serializeLeafs (std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # 
+        # /** \brief Outputs a vector of all DataT elements from leaf nodes, that do not exist in the previous octree buffer.
+        #  *  \param leaf_container_vector_arg: vector of pointers to all LeafContainerT objects in the octree
+        #  * */
+        # void serializeNewLeafs (std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # 
+        # /** \brief Deserialize a binary octree description vector and create a corresponding octree structure. Leaf nodes are initialized with getDataTByKey(..).
+        #  *  \param binary_tree_in_arg: reference to input vector for reading binary tree structure.
+        #  *  \param do_XOR_decoding_arg: select if binary tree structure is based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_in_arg, bool do_XOR_decoding_arg = false);
+        # 
+        # /** \brief Deserialize a binary octree description and create a corresponding octree structure. Leaf nodes are initialized with DataT elements from the dataVector.
+        #  *  \param binary_tree_in_arg: reference to inpvectoream for reading binary tree structure.
+        #  *  \param leaf_container_vector_arg: vector of pointers to all LeafContainerT objects in the octree
+        #  *  \param do_XOR_decoding_arg: select if binary tree structure is based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_in_arg,
+        #                  std::vector<LeafContainerT*>& leaf_container_vector_arg,
+        #                  bool do_XOR_decoding_arg = false);
+
+
+ctypedef Octree2BufBase[int, OctreeContainerEmpty_t] Octree2BufBase_t
+ctypedef shared_ptr[Octree2BufBase[int, OctreeContainerEmpty_t]] Octree2BufBasePtr_t
+ctypedef Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] Octree2BufBase_OctreeContainerPointIndices_t
+ctypedef shared_ptr[Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] Octree2BufBasePtr_OctreeContainerPointIndicesPtr_t
+###
+
+# nothing use PCL 1.7.2/1.8.0
+# template<typename DataT>
+# class OctreeContainerDataT
+# cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+#     cdef cppclass OctreeContainerDataT[DataT]:
+#         OctreeContainerDataT()
+#         # OctreeContainerDataT (const OctreeContainerDataT& source) :
+#         # public:
+#         # /** \brief Octree deep copy method */
+#         # virtual OctreeContainerDataT* deepCopy () const
+#         # /** \brief Copies a DataT element to leaf node memorye.
+#         #  * \param[in] data_arg reference to DataT element to be stored within leaf node.
+#         # void setData (const DataT& data_arg)
+#         # /** \brief Adds leaf node DataT element to dataVector vector of type DataT.
+#         #  * \param[in] dataVector_arg: reference to DataT type to obtain the most recently added leaf node DataT element.
+#         # void getData (DataT& dataVector_arg) const
+#         # /** \brief Adds leaf node DataT element to dataVector vector of type DataT.
+#         #  * \param[in] dataVector_arg: reference to DataT vector that is to be extended with leaf node DataT elements.
+#         # void getData (vector<DataT>& dataVector_arg) const
+#         # /** \brief Get size of container (number of DataT objects)
+#         #  * \return number of DataT elements in leaf node container.
+#         # size_t getSize () const
+#         # /** \brief Reset leaf node memory to zero. */
+#         # void reset ()
+#         # protected:
+#         # /** \brief Leaf node DataT storage. */
+#         # DataT data_;
+#         # /** \brief Bool indicating if leaf node is empty or not. */
+#         # bool isEmpty_;
+# 
+# 
+# ctypedef OctreeContainerDataT[int] OctreeContainerDataT_t
+# # ctypedef shared_ptr[OctreeContainerDataT[int]] OctreeContainerDataTPtr_t
+###
+
+# \brief @b Octree container class that does store a single point index.
+# \note Enables the octree to store a single DataT element within its leaf nodes.
+# \author Julius Kammerl (julius@kammerl.de)
+# class OctreeContainerPointIndex : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerPointIndex(OctreeContainerBase):
+        OctreeContainerPointIndex()
+        # \brief Empty constructor.
+        # OctreeContainerPointIndex (const OctreeContainerPointIndex& source)
+        # 
+        # /** \brief Empty deconstructor. */
+        # virtual ~OctreeContainerPointIndex ()
+        # 
+        # /** \brief Octree deep copy method */
+        # virtual OctreeContainerPointIndex* deepCopy () const
+        # 
+        # /** \brief Equal comparison operator
+        #  * \param[in] other OctreeContainerBase to compare with
+        # virtual bool operator== (const OctreeContainerBase& other) const
+        # 
+        # /** \brief Add point index to container memory. This container stores a only a single point index.
+        #  * \param[in] data_arg index to be stored within leaf node.
+        # void addPointIndex (int data_arg)
+        # 
+        # /** \brief Retrieve point index from container. This container stores a only a single point index
+        #  * \return index stored within container.
+        # int getPointIndex () const
+        # 
+        # /** \brief Retrieve point indices from container. This container stores only a single point index
+        #  * \param[out] data_vector_arg vector of point indices to be stored within data vector
+        # void getPointIndices (std::vector<int>& data_vector_arg) const
+        # 
+        # \brief Get size of container (number of DataT objects)
+        # \return number of DataT elements in leaf node container.
+        # size_t getSize () const
+        # 
+        # /** \brief Reset leaf node memory to zero. */
+        # virtual void reset ()
+
+
+###
+
+# no use pcl 1.8.0
+# replace : OctreeContainerPointIndices
+# template<typename DataT>
+# class OctreeContainerDataTVector
+# cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+#     cdef cppclass OctreeContainerDataTVector[DataT]:
+#         OctreeContainerDataTVector()
+#         # OctreeContainerDataTVector (const OctreeContainerDataTVector& source) :
+#         # public:
+#         # /** \brief Octree deep copy method */
+#         # virtual OctreeContainerDataTVector *deepCopy () const
+#         # /** \brief Pushes a DataT element to internal DataT vector.
+#         #  * \param[in] data_arg reference to DataT element to be stored within leaf node.
+#         #  */
+#         # void setData (const DataT& data_arg)
+#         # /** \brief Receive the most recent DataT element that was pushed to the internal DataT vector.
+#         #  * \param[in] data_arg reference to DataT type to obtain the most recently added leaf node DataT element.
+#         #  */
+#         # void getData (DataT& data_arg) const
+#         # /** \brief Concatenate the internal DataT vector to vector argument dataVector_arg.
+#         #  * \param[in] dataVector_arg: reference to DataT vector that is to be extended with leaf node DataT elements.
+#         #  */
+#         # void getData (vector[DataT]& dataVector_arg) const
+#         # /** \brief Return const reference to internal DataT vector
+#         #  * \return  const reference to internal DataT vector
+#         # const vector[DataT]& getDataTVector () const
+#         # /** \brief Get size of container (number of DataT objects)
+#         #  * \return number of DataT elements in leaf node container.
+#         # size_t getSize () const
+#         # /** \brief Reset leaf node. Clear DataT vector.*/
+#         void reset ()
+# 
+# 
+# ctypedef OctreeContainerDataTVector[int] OctreeContainerDataTVector_t
+# # ctypedef shared_ptr[OctreeContainerDataTVector[int]] OctreeContainerDataTVectorPtr_t
+###
+
+# octree_impl.h
+# impl header include
+###
+
+
+# octree_iterator.h
+# namespace pcl
+# namespace octree
+#   template<typename DataT, typename OctreeT>
+#       class OctreeIteratorBase : public std::iterator<std::forward_iterator_tag, const OctreeNode, void, const OctreeNode*, const OctreeNode&>
+# pcl 1.8.0
+# template<typename OctreeT>
+# class OctreeIteratorBase : public std::iterator<std::forward_iterator_tag, const OctreeNode, void,
+# const OctreeNode*, const OctreeNode&>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeIteratorBase[OctreeT]:
+        OctreeIteratorBase()
+        # explicit OctreeIteratorBase (OctreeT& octree_arg)
+        # OctreeIteratorBase (const OctreeIteratorBase& src) :
+        # inline OctreeIteratorBase& operator = (const OctreeIteratorBase& src)
+        # public:
+        # typedef typename OctreeT::LeafNode LeafNode;
+        # typedef typename OctreeT::BranchNode BranchNode;
+        # /** \brief initialize iterator globals */
+        # inline void reset ()
+        # /** \brief Get octree key for the current iterator octree node
+        #  * \return octree key of current node
+        # inline const OctreeKey& getCurrentOctreeKey () const
+        # /** \brief Get the current depth level of octree
+        #  * \return depth level
+        # inline unsigned int getCurrentOctreeDepth () const
+        # /** \brief Get the current octree node
+        #  * \return pointer to current octree node
+        # inline OctreeNode* getCurrentOctreeNode () const
+        # /** \brief *operator.
+        #  * \return pointer to the current octree node
+        # inline OctreeNode* operator* () const
+        # /** \brief check if current node is a branch node
+        #  * \return true if current node is a branch node, false otherwise
+        # inline bool isBranchNode () const
+        # /** \brief check if current node is a branch node
+        #  * \return true if current node is a branch node, false otherwise
+        # inline bool isLeafNode () const
+        # /** \brief Get bit pattern of children configuration of current node
+        #  * \return bit pattern (byte) describing the existence of 8 children of the current node
+        # inline char getNodeConfiguration () const
+        # /** \brief Method for retrieving a single DataT element from the octree leaf node
+        #  * \param[in] data_arg reference to return pointer of leaf node DataT element.
+        # virtual void getData (DataT& data_arg) const
+        # /** \brief Method for retrieving a vector of DataT elements from the octree laef node
+        #  * \param[in] dataVector_arg reference to DataT vector that is extended with leaf node DataT elements.
+        # virtual void getData (std::vector<DataT>& dataVector_arg) const
+        # /** \brief Method for retrieving the size of the DataT vector from the octree laef node
+        # virtual std::size_t getSize () const
+        # /** \brief get a integer identifier for current node (note: identifier depends on tree depth).
+        #  * \return node id.
+        # virtual unsigned long getNodeID () const
+
+
+###
+
+# pcl 1.7.2
+# template<typename DataT, typename OctreeT>
+# class OctreeDepthFirstIterator : public OctreeIteratorBase<DataT, OctreeT>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeDepthFirstIterator[OctreeT](OctreeIteratorBase[OctreeT]):
+        OctreeDepthFirstIterator()
+        # explicit OctreeDepthFirstIterator (OctreeT& octree_arg)
+        # public:
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::LeafNode LeafNode;
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::BranchNode BranchNode;
+        # /** \brief Reset the iterator to the root node of the octree
+        # virtual void reset ();
+        # /** \brief Preincrement operator.
+        #  * \note recursively step to next octree node
+        # OctreeDepthFirstIterator& operator++ ();
+        # /** \brief postincrement operator.
+        #  * \note recursively step to next octree node
+        # inline OctreeDepthFirstIterator operator++ (int)
+        # /** \brief Skip all child voxels of current node and return to parent node.
+        # void skipChildVoxels ();
+        # protected:
+        # /** Child index at current octree node. */
+        # unsigned char currentChildIdx_;
+        # /** Stack structure. */
+        # std::vector<std::pair<OctreeNode*, unsigned char> > stack_;
+
+
+###
+
+# pcl 1.7.2
+# template<typename DataT, typename OctreeT>
+# class OctreeBreadthFirstIterator : public OctreeIteratorBase<DataT, OctreeT>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeBreadthFirstIterator[OctreeT](OctreeIteratorBase[OctreeT]):
+        OctreeDepthFirstIterator()
+        # explicit OctreeBreadthFirstIterator (OctreeT& octree_arg);
+        # // public typedefs
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::BranchNode BranchNode;
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::LeafNode LeafNode;
+        # struct FIFOElement
+        # {
+        #   OctreeNode* node;
+        #   OctreeKey key;
+        #   unsigned int depth;
+        # };
+        # public:
+        # /** \brief Reset the iterator to the root node of the octree
+        # void reset ();
+        # /** \brief Preincrement operator.
+        #  * \note step to next octree node
+        # OctreeBreadthFirstIterator& operator++ ();
+        # /** \brief postincrement operator.
+        #  * \note step to next octree node
+        # inline OctreeBreadthFirstIterator operator++ (int)
+        # protected:
+        # /** \brief Add children of node to FIFO
+        #  * \param[in] node: node with children to be added to FIFO
+        # void addChildNodesToFIFO (const OctreeNode* node);
+        # /** FIFO list */
+        # std::deque<FIFOElement> FIFO_;
+
+
+###
+
+# template<typename DataT, typename OctreeT>
+# class OctreeLeafNodeIterator : public OctreeDepthFirstIterator<DataT, OctreeT>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeLeafNodeIterator[OctreeT](OctreeDepthFirstIterator[OctreeT]):
+        OctreeLeafNodeIterator()
+        # explicit OctreeLeafNodeIterator (OctreeT& octree_arg)
+        # typedef typename OctreeDepthFirstIterator<DataT, OctreeT>::BranchNode BranchNode;
+        # typedef typename OctreeDepthFirstIterator<DataT, OctreeT>::LeafNode LeafNode;
+        # public:
+        # /** \brief Constructor.
+        #  * \param[in] octree_arg Octree to be iterated. Initially the iterator is set to its root node.
+        # /** \brief Reset the iterator to the root node of the octree
+        # inline void reset ()
+        # /** \brief Preincrement operator.
+        #  * \note recursively step to next octree leaf node
+        # inline OctreeLeafNodeIterator& operator++ ()
+        # /** \brief postincrement operator.
+        #  * \note step to next octree node
+        # inline OctreeLeafNodeIterator operator++ (int)
+        # /** \brief *operator.
+        #  * \return pointer to the current octree leaf node
+        # OctreeNode* operator* () const
+
+
+###
+
+# octree_key.h
+# namespace pcl
+# namespace octree
+# class OctreeKey
+cdef extern from "pcl/octree/octree_key.h" namespace "pcl::octree":
+    cdef cppclass OctreeKey:
+        OctreeKey()
+        # OctreeKey (unsigned int keyX, unsigned int keyY, unsigned int keyZ) :
+        # OctreeKey (const OctreeKey& source) :
+        # public:
+        # /** \brief Operator== for comparing octree keys with each other.
+        # *  \return "true" if leaf node indices are identical; "false" otherwise.
+        # bool operator == (const OctreeKey& b) const
+        # /** \brief Operator<= for comparing octree keys with each other.
+        # *  \return "true" if key indices are not greater than the key indices of b  ; "false" otherwise.
+        # bool operator <= (const OctreeKey& b) const
+        # /** \brief Operator>= for comparing octree keys with each other.
+        # *  \return "true" if key indices are not smaller than the key indices of b  ; "false" otherwise.
+        # bool operator >= (const OctreeKey& b) const
+        # /** \brief push a child node to the octree key
+        # *  \param[in] childIndex index of child node to be added (0-7)
+        # */
+        # inline void pushBranch (unsigned char childIndex)
+        # /** \brief pop child node from octree key
+        # inline void popBranch ()
+        # /** \brief get child node index using depthMask
+        # *  \param[in] depthMask bit mask with single bit set at query depth
+        # *  \return child node index
+        # * */
+        # inline unsigned char getChildIdxWithDepthMask (unsigned int depthMask) const
+        # // Indices addressing a voxel at (X, Y, Z)
+        # unsigned int x;
+        # unsigned int y;
+        # unsigned int z;
+###
+
+# pcl 1.7.2/1.8.0 nothing
+# octree_node_pool.h
+# namespace pcl
+# namespace octree
+# template<typename NodeT>
+# class OctreeNodePool
+# cdef extern from "pcl/octree/octree_node_pool.h" namespace "pcl::octree":
+#     cdef cppclass OctreeNodePool[NodeT]:
+#         OctreeNodePool()
+#         # public:
+#         # /** \brief Push node to pool
+#         # *  \param childIdx_arg: pointer of noe
+#         # inline void pushNode (NodeT* node_arg)
+#         # /** \brief Pop node from pool - Allocates new nodes if pool is empty
+#         # *  \return Pointer to octree node
+#         # inline NodeT* popNode ()
+#         # /** \brief Delete all nodes in pool
+#         # */
+#         # void deletePool ()
+#         # protected:
+#         # vector<NodeT*> nodePool_;
+###
+
+# NG
+# octree_nodes.h
+# namespace pcl
+# namespace octree
+#     // enum of node types within the octree
+#     enum node_type_t
+#     {
+#       BRANCH_NODE, LEAF_NODE
+#     };
+##
+# namespace pcl
+# namespace octree
+# class PCL_EXPORTS OctreeNode
+#       public:
+#       OctreeNode ()
+#       /** \brief Pure virtual method for receiving the type of octree node (branch or leaf)  */
+#       virtual node_type_t getNodeType () const = 0;
+#       /** \brief Pure virtual method to perform a deep copy of the octree */
+#       virtual OctreeNode* deepCopy () const = 0;
+##
+# template<typename ContainerT>
+# class OctreeLeafNode : public OctreeNode, public ContainerT
+# cdef cppclass OctreeLeafNode[ContainerT](OctreeNode)(ContainerT):
+# cdef extern from "pcl/octree/octree_nodes.h" namespace "pcl::octree":
+#     cdef cppclass OctreeLeafNode[ContainerT]:
+#         OctreeLeafNode()
+#         # OctreeLeafNode (const OctreeLeafNode& source) :
+#         # public:
+#         # using ContainerT::getSize;
+#         # using ContainerT::getData;
+#         # using ContainerT::setData;
+#         # /** \brief Method to perform a deep copy of the octree */
+#         # virtual OctreeLeafNode<ContainerT>* deepCopy () const
+#         # /** \brief Get the type of octree node. Returns LEAVE_NODE type */
+#         # virtual node_type_t getNodeType () const
+#         # /** \brief Reset node */
+#         # inline void reset ()
+###
+# # template<typename ContainerT>
+# # class OctreeBranchNode : public OctreeNode, ContainerT
+# # cdef extern from "pcl/octree/octree_nodes.h" namespace "pcl::octree":
+# #     cdef cppclass OctreeBranchNode[ContainerT]:
+# #         OctreeBranchNode()
+#         # OctreeBranchNode (const OctreeBranchNode& source)
+#         # inline OctreeBranchNode& operator = (const OctreeBranchNode &source)
+#         # public:
+#         # using ContainerT::getSize;
+#         # using ContainerT::getData;
+#         # using ContainerT::setData;
+#         # /** \brief Octree deep copy method */
+#         # virtual OctreeBranchNode* deepCopy () const
+#         # inline void reset ()
+#         # /** \brief Access operator.
+#         #  *  \param childIdx_arg: index to child node
+#         #  *  \return OctreeNode pointer
+#         #  * */
+#         # inline OctreeNode*& operator[] (unsigned char childIdx_arg)
+#         # /** \brief Get pointer to child
+#         #  *  \param childIdx_arg: index to child node
+#         #  *  \return OctreeNode pointer
+#         #  * */
+#         # inline OctreeNode* getChildPtr (unsigned char childIdx_arg) const
+#         # /** \brief Get pointer to child
+#         #  *  \return OctreeNode pointer
+#         #  * */
+#         # inline void setChildPtr (OctreeNode* child, unsigned char index)
+#         # /** \brief Check if branch is pointing to a particular child node
+#         #  *  \param childIdx_arg: index to child node
+#         #  *  \return "true" if pointer to child node exists; "false" otherwise
+#         #  * */
+#         # inline bool hasChild (unsigned char childIdx_arg) const
+#         # /** \brief Get the type of octree node. Returns LEAVE_NODE type */
+#         # virtual node_type_t getNodeType () const
+#         # protected:
+#         # OctreeNode* childNodeArray_[8];
+###
+
+# octree_pointcloud.h
+# namespace pcl
+# namespace octree
+# template<typename PointT, typename LeafT = OctreeContainerPointIndices,
+#       typename BranchT = OctreeContainerEmpty,
+#       typename OctreeT = OctreeBase<LeafT, BranchT> >
+# class OctreePointCloud : public OctreeT
+cdef extern from "pcl/octree/octree_pointcloud.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloud[PointT, LeafT, BranchT, OctreeT]:
+        OctreePointCloud(const double resolution_arg)
+        # OctreePointCloud(double resolution_arg)
+        
+        # // iterators are friends
+        # friend class OctreeIteratorBase<int, OctreeT> ;
+        # friend class OctreeDepthFirstIterator<int, OctreeT> ;
+        # friend class OctreeBreadthFirstIterator<int, OctreeT> ;
+        # friend class OctreeLeafNodeIterator<int, OctreeT> ;
+        # public:
+        # typedef OctreeT Base;
+        # typedef typename OctreeT::LeafNode LeafNode;
+        # typedef typename OctreeT::BranchNode BranchNode;
+        # // Octree iterators
+        # typedef OctreeDepthFirstIterator<int, OctreeT> Iterator;
+        # typedef const OctreeDepthFirstIterator<int, OctreeT> ConstIterator;
+        # typedef OctreeLeafNodeIterator<int, OctreeT> LeafNodeIterator;
+        # typedef const OctreeLeafNodeIterator<int, OctreeT> ConstLeafNodeIterator;
+        # typedef OctreeDepthFirstIterator<int, OctreeT> DepthFirstIterator;
+        # typedef const OctreeDepthFirstIterator<int, OctreeT> ConstDepthFirstIterator;
+        # typedef OctreeBreadthFirstIterator<int, OctreeT> BreadthFirstIterator;
+        # typedef const OctreeBreadthFirstIterator<int, OctreeT> ConstBreadthFirstIterator;
+        # /** \brief Octree pointcloud constructor.
+        #  * \param[in] resolution_arg octree resolution at lowest octree level
+        # // public typedefs
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # // public typedefs for single/double buffering
+        # typedef OctreePointCloud<PointT, LeafT, OctreeBase<int, LeafT> > SingleBuffer;
+        # typedef OctreePointCloud<PointT, LeafT, Octree2BufBase<int, LeafT> > DoubleBuffer;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<OctreePointCloud<PointT, LeafT, OctreeT> > Ptr;
+        # typedef boost::shared_ptr<const OctreePointCloud<PointT, LeafT, OctreeT> > ConstPtr;
+        # // Eigen aligned allocator
+        # typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        # 
+        # /** \brief Provide a pointer to the input data set.
+        #  * \param[in] cloud_arg the const boost shared pointer to a PointCloud message
+        #  * \param[in] indices_arg the point indices subset that is to be used from \a cloud - if 0 the whole point cloud is used
+        #  */
+        # inline void setInputCloud (const PointCloudConstPtr &cloud_arg, const IndicesConstPtr &indices_arg = IndicesConstPtr ())
+        void setInputCloud (shared_ptr[cpp.PointCloud[PointT]])
+        # void setInputCloud (const shared_ptr[cpp.PointCloud] &cloud_arg, const shared_ptr[const vector[int]] &indices_ar)
+        
+        # /** \brief Get a pointer to the vector of indices used.
+        #  * \return pointer to vector of indices used.
+        #  */
+        # inline IndicesConstPtr const getIndices () const
+        const shared_ptr[const vector[int]] getIndices ()
+        
+        # /** \brief Get a pointer to the input point cloud dataset.
+        #  * \return pointer to pointcloud input class.
+        #  */
+        # inline PointCloudConstPtr getInputCloud () const
+        # PointCloudConstPtr getInputCloud () const
+        shared_ptr[const cpp.PointCloud[PointT]] getInputCloud ()
+        
+        # /** \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        #  * \param[in] eps precision (error bound) for nearest neighbors searches
+        #  */
+        # inline void setEpsilon (double eps)
+        void setEpsilon (double eps)
+        
+        # /** \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+        # inline double getEpsilon () const
+        double getEpsilon () const
+        
+        # /** \brief Set/change the octree voxel resolution
+        #  * \param[in] resolution_arg side length of voxels at lowest tree level
+        #  */
+        # inline void setResolution (double resolution_arg)
+        void setResolution (double resolution_arg)
+        
+        # /** \brief Get octree voxel resolution
+        #  * \return voxel resolution at lowest tree level
+        #  */
+        # inline double getResolution () const
+        double getResolution () const
+        
+        # \brief Get the maximum depth of the octree.
+        # \return depth_arg: maximum depth of octree
+        # inline unsigned int getTreeDepth () const
+        unsigned int getTreeDepth ()
+        
+        # brief Add points from input point cloud to octree.
+        # void addPointsFromInputCloud ();
+        void addPointsFromInputCloud ()
+        
+        # \brief Add point at given index from input point cloud to octree. Index will be also added to indices vector.
+        # \param[in] pointIdx_arg index of point to be added
+        # \param[in] indices_arg pointer to indices vector of the dataset (given by \a setInputCloud)
+        # void addPointFromCloud (const int pointIdx_arg, IndicesPtr indices_arg);
+        void addPointFromCloud (const int pointIdx_arg, shared_ptr[vector[int]] indices_arg)
+        
+        # \brief Add point simultaneously to octree and input point cloud.
+        # \param[in] point_arg point to be added
+        # \param[in] cloud_arg pointer to input point cloud dataset (given by \a setInputCloud)
+        # void addPointToCloud (const PointT& point_arg, PointCloudPtr cloud_arg);
+        void addPointToCloud (const PointT& point_arg, shared_ptr[cpp.PointCloud[PointT]] cloud_arg)
+        
+        # \brief Add point simultaneously to octree and input point cloud. A corresponding index will be added to the indices vector.
+        # \param[in] point_arg point to be added
+        # \param[in] cloud_arg pointer to input point cloud dataset (given by \a setInputCloud)
+        # \param[in] indices_arg pointer to indices vector of the dataset (given by \a setInputCloud)
+        # void addPointToCloud (const PointT& point_arg, PointCloudPtr cloud_arg, IndicesPtr indices_arg);
+        void addPointToCloud (const PointT& point_arg, shared_ptr[cpp.PointCloud[PointT]] cloud_arg, shared_ptr[vector[int]] indices_arg)
+        
+        # \brief Check if voxel at given point exist.
+        # \param[in] point_arg point to be checked
+        # \return "true" if voxel exist; "false" otherwise
+        # bool isVoxelOccupiedAtPoint (const PointT& point_arg) const;
+        # bool isVoxelOccupiedAtPoint (const PointT& point_arg)
+        
+        # \brief Delete the octree structure and its leaf nodes.
+        # \param freeMemory_arg: if "true", allocated octree nodes are deleted, otherwise they are pushed to the octree node pool
+        # void deleteTree (bool freeMemory_arg = false)
+        void deleteTree()
+        # void deleteTree (bool freeMemory_arg)
+        
+        # \brief Check if voxel at given point coordinates exist.
+        # \param[in] pointX_arg X coordinate of point to be checked
+        # \param[in] pointY_arg Y coordinate of point to be checked
+        # \param[in] pointZ_arg Z coordinate of point to be checked
+        # \return "true" if voxel exist; "false" otherwise
+        # bool isVoxelOccupiedAtPoint (const double pointX_arg, const double pointY_arg, const double pointZ_arg) const;
+        # bool isVoxelOccupiedAtPoint(double, double, double)
+        bool isVoxelOccupiedAtPoint (const double pointX_arg, const double pointY_arg, const double pointZ_arg)
+        
+        # \brief Check if voxel at given point from input cloud exist.
+        # \param[in] pointIdx_arg point to be checked
+        # \return "true" if voxel exist; "false" otherwise
+        # bool isVoxelOccupiedAtPoint (const int& pointIdx_arg) const;
+        # bool isVoxelOccupiedAtPoint (const int& pointIdx_arg)
+        
+        # \brief Get a T vector of centers of all occupied voxels.
+        # \param[out] voxelCenterList_arg results are written to this vector of T elements
+        # \return number of occupied voxels
+        # int getOccupiedVoxelCenters (vector2[PointT, eig.aligned_allocator[PointT]] &voxelCenterList_arg) const;
+        # int getOccupiedVoxelCenters(vector2[PointT, eig.aligned_allocator[PointT]])
+        int getOccupiedVoxelCenters (vector2[PointT, eig.aligned_allocator[PointT]] &voxelCenterList_arg)
+        
+        # \brief Get a T vector of centers of voxels intersected by a line segment.
+        #  This returns a approximation of the actual intersected voxels by walking
+        #  along the line with small steps. Voxels are ordered, from closest to
+        #  furthest w.r.t. the origin.
+        # \param[in] origin origin of the line segment
+        # \param[in] end end of the line segment
+        # \param[out] voxel_center_list results are written to this vector of T elements
+        # \param[in] precision determines the size of the steps: step_size = octree_resolution x precision
+        # \return number of intersected voxels
+        # int getApproxIntersectedVoxelCentersBySegment (const Eigen::Vector3f& origin, const Eigen::Vector3f& end, AlignedPointTVector &voxel_center_list, float precision = 0.2);
+        int getApproxIntersectedVoxelCentersBySegment (const eig.Vector3f& origin, const eig.Vector3f& end, vector2[PointT, eig.aligned_allocator[PointT]] &voxel_center_list, float precision)
+        
+        # \brief Delete leaf node / voxel at given point
+        # \param[in] point_arg point addressing the voxel to be deleted.
+        # void deleteVoxelAtPoint(const PointT& point_arg);
+        # void deleteVoxelAtPoint(PointT point)
+        void deleteVoxelAtPoint (const PointT& point_arg)
+        
+        # \brief Delete leaf node / voxel at given point from input cloud
+        # \param[in] pointIdx_arg index of point addressing the voxel to be deleted.
+        # void deleteVoxelAtPoint (const int& pointIdx_arg);
+        void deleteVoxelAtPoint (const int& pointIdx_arg)
+        
+        # Bounding box methods
+        # \brief Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. */
+        # void defineBoundingBox ();
+        void defineBoundingBox ()
+        
+        # \brief Define bounding box for octree
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] minX_arg X coordinate of lower bounding box corner
+        # \param[in] minY_arg Y coordinate of lower bounding box corner
+        # \param[in] minZ_arg Z coordinate of lower bounding box corner
+        # \param[in] maxX_arg X coordinate of upper bounding box corner
+        # \param[in] maxY_arg Y coordinate of upper bounding box corner
+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner
+        # void defineBoundingBox (const double minX_arg, const double minY_arg, const double minZ_arg, const double maxX_arg, const double maxY_arg, const double maxZ_arg);
+        # void defineBoundingBox(double, double, double, double, double, double)
+        void defineBoundingBox (const double minX_arg, const double minY_arg, const double minZ_arg, const double maxX_arg, const double maxY_arg, const double maxZ_arg)
+        
+        # \brief Define bounding box for octree
+        # \note Lower bounding box point is set to (0, 0, 0)
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] maxX_arg X coordinate of upper bounding box corner
+        # \param[in] maxY_arg Y coordinate of upper bounding box corner
+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner
+        # void defineBoundingBox (const double maxX_arg, const double maxY_arg, const double maxZ_arg);
+        # void defineBoundingBox (const double maxX_arg, const double maxY_arg, const double maxZ_arg)
+        
+        # \brief Define bounding box cube for octree
+        # \note Lower bounding box corner is set to (0, 0, 0)
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] cubeLen_arg side length of bounding box cube.
+        # void defineBoundingBox (const double cubeLen_arg);
+        # void defineBoundingBox (const double cubeLen_arg)
+        
+        # \brief Get bounding box for octree
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] minX_arg X coordinate of lower bounding box corner
+        # \param[in] minY_arg Y coordinate of lower bounding box corner
+        # \param[in] minZ_arg Z coordinate of lower bounding box corner
+        # \param[in] maxX_arg X coordinate of upper bounding box corner
+        # \param[in] maxY_arg Y coordinate of upper bounding box corner
+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner
+        # void getBoundingBox (double& minX_arg, double& minY_arg, double& minZ_arg, double& maxX_arg, double& maxY_arg, double& maxZ_arg) const;
+        void getBoundingBox (double& minX_arg, double& minY_arg, double& minZ_arg, double& maxX_arg, double& maxY_arg, double& maxZ_arg)
+        
+        # \brief Calculates the squared diameter of a voxel at given tree depth
+        # \param[in] treeDepth_arg depth/level in octree
+        # \return squared diameter
+        # double getVoxelSquaredDiameter (unsigned int treeDepth_arg) const;
+        double getVoxelSquaredDiameter (unsigned int treeDepth_arg)
+        
+        # \brief Calculates the squared diameter of a voxel at leaf depth
+        # \return squared diameter
+        # inline double getVoxelSquaredDiameter () const
+        double getVoxelSquaredDiameter ()
+        
+        # \brief Calculates the squared voxel cube side length at given tree depth
+        # \param[in] treeDepth_arg depth/level in octree
+        # \return squared voxel cube side length
+        # double getVoxelSquaredSideLen (unsigned int treeDepth_arg) const;
+        double getVoxelSquaredSideLen (unsigned int treeDepth_arg)
+        
+        # \brief Calculates the squared voxel cube side length at leaf level
+        # \return squared voxel cube side length
+        # inline double getVoxelSquaredSideLen () const
+        double getVoxelSquaredSideLen ()
+        
+        # \brief Generate bounds of the current voxel of an octree iterator
+        # \param[in] iterator: octree iterator
+        # \param[out] min_pt lower bound of voxel
+        # \param[out] max_pt upper bound of voxel
+        # inline void getVoxelBounds (OctreeIteratorBase<int, OctreeT>& iterator, Eigen::Vector3f &min_pt, Eigen::Vector3f &max_pt)
+        void getVoxelBounds (OctreeIteratorBase[OctreeT]& iterator, eig.Vector3f &min_pt, eig.Vector3f &max_pt)
+
+
+ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_t
+ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZI_t
+ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGB_t
+ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGBA_t
+ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_t
+ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZI_t
+ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGB_t
+ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGBA_t
+###
+
+# namespace pcl
+# namespace octree
+# pcl_1.7.2 use octree_pointcloud_changedetector.h
+# pcl 1.7.2 Template Changed(OctreeContainerDataTVector to OctreeContainerPointIndices)
+# template<typename PointT,
+#         typename LeafContainerT = OctreeContainerPointIndices,
+#         typename BranchContainerT = OctreeContainerEmpty >
+cdef extern from "pcl/octree/octree_pointcloud_changedetector.h" namespace "pcl::octree":
+    # pcl version 1.7.2
+    cdef cppclass OctreePointCloudChangeDetector[PointT](OctreePointCloud[PointT, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t]):
+        OctreePointCloudChangeDetector (const double resolution_arg)
+        # public:
+        # \brief Get a indices from all leaf nodes that did not exist in previous buffer.
+        # \param indicesVector_arg: results are written to this vector of int indices
+        # \param minPointsPerLeaf_arg: minimum amount of points required within leaf node to become serialized.
+        # \return number of point indices
+        # int getPointIndicesFromNewVoxels (std::vector<int> &indicesVector_arg, const int minPointsPerLeaf_arg = 0)
+        int getPointIndicesFromNewVoxels (vector[int] &indicesVector_arg, const int minPointsPerLeaf_arg)
+
+
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZ] OctreePointCloudChangeDetector_t
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZI] OctreePointCloudChangeDetector_PointXYZI_t
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGB]] OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGBA]] OctreePointCloudChangeDetector_PointXYZRGBA_Ptr_t
+###
+
+# octree_pointcloud_density.h
+# namespace pcl
+# namespace octree
+# template<typename PointT, typename LeafContainerT = OctreePointCloudDensityContainer, typename BranchContainerT = OctreeContainerEmpty >
+# class OctreePointCloudDensity : public OctreePointCloud<PointT, LeafContainerT, BranchContainerT>
+cdef extern from "pcl/octree/octree_pointcloud_density.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloudDensity[PointT](OctreePointCloud[PointT, OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t, OctreeBase_OctreePointCloudDensity_t]):
+        OctreePointCloudDensity (const double resolution_arg)
+        # /** \brief Get the amount of points within a leaf node voxel which is addressed by a point
+        #   * \param[in] point_arg: a point addressing a voxel
+        #   * \return amount of points that fall within leaf node voxel
+        #   */
+        # unsigned int getVoxelDensityAtPoint (const PointT& point_arg) const
+
+
+ctypedef OctreePointCloudDensity[cpp.PointXYZ] OctreePointCloudDensity_t
+ctypedef OctreePointCloudDensity[cpp.PointXYZI] OctreePointCloudDensity_PointXYZI_t
+ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t
+ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGB]] OctreePointCloudDensity_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGBA]] OctreePointCloudDensity_PointXYZRGBA_Ptr_t
+###
+
+# octree_pointcloud_occupancy.h
+###
+
+# octree_pointcloud_pointvector.h
+###
+
+# octree_pointcloud_singlepoint.h
+###
+
+# octree_pointcloud_voxelcentroid.h
+###
+
+# octree_search.h
+cdef extern from "pcl/octree/octree_search.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloudSearch[PointT](OctreePointCloud[PointT, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t]):
+        OctreePointCloudSearch (const double resolution_arg)
+        # int radiusSearch (cpp.PointXYZ, double, vector[int], vector[float], unsigned int)
+        # int radiusSearch (cpp.PointXYZI, double, vector[int], vector[float], unsigned int)
+        # int radiusSearch (cpp.PointXYZRGB, double, vector[int], vector[float], unsigned int)
+        # int radiusSearch (cpp.PointXYZRGBA, double, vector[int], vector[float], unsigned int)
+        # PointT
+        int radiusSearch (PointT, double, vector[int], vector[float], unsigned int)
+        
+        # Add index(inline?)
+        int radiusSearch (cpp.PointCloud[PointT], int, double, vector[int], vector[float], unsigned int)
+        
+        # inline define
+        # int nearestKSearch (cpp.PointCloud[PointT], int, int, vector[int], vector[float])
+        int nearestKSearch (cpp.PointCloud[PointT], int, int, vector[int], vector[float])
+        
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        # int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        ## Functions
+        # brief Search for neighbors within a voxel at given point
+        # param[in] point point addressing a leaf node voxel
+        # param[out] point_idx_data the resultant indices of the neighboring voxel points
+        # return "true" if leaf node exist; "false" otherwise
+        # bool voxelSearch (const PointT& point, std::vector<int>& point_idx_data);
+        bool voxelSearch (const PointT& point, vector[int] point_idx_data)
+        
+        # brief Search for neighbors within a voxel at given point referenced by a point index
+        # param[in] index the index in input cloud defining the query point
+        # param[out] point_idx_data the resultant indices of the neighboring voxel points
+        # return "true" if leaf node exist; "false" otherwise
+        # bool voxelSearch (const int index, std::vector<int>& point_idx_data);
+        bool voxelSearch (const int index, vector[int] point_idx_data)
+        
+        # brief Search for approx. nearest neighbor at the query point.
+        # param[in] cloud the point cloud data
+        # param[in] query_index the index in \a cloud representing the query point
+        # param[out] result_index the resultant index of the neighbor point
+        # param[out] sqr_distance the resultant squared distance to the neighboring point
+        # return number of neighbors found
+        # 
+        # inline void approxNearestSearch (const PointCloud &cloud, int query_index, int &result_index, float &sqr_distance)
+        approxNearestSearch (const cpp.PointCloud[PointT] &cloud, int query_index, int &result_index, float &sqr_distance)
+        
+        # /** \brief Search for approx. nearest neighbor at the query point.
+        #   * \param[in] p_q the given query point
+        #   * \param[out] result_index the resultant index of the neighbor point
+        #   * \param[out] sqr_distance the resultant squared distance to the neighboring point
+        #   */
+        # void approxNearestSearch (const PointT &p_q, int &result_index, float &sqr_distance);
+        void approxNearestSearch (const PointT &p_q, int &result_index, float &sqr_distance)
+        
+        # /** \brief Search for approx. nearest neighbor at the query point.
+        #   * \param[in] query_index index representing the query point in the dataset given by \a setInputCloud.
+        #   *        If indices were given in setInputCloud, index will be the position in the indices vector.
+        #   * \param[out] result_index the resultant index of the neighbor point
+        #   * \param[out] sqr_distance the resultant squared distance to the neighboring point
+        #   * \return number of neighbors found
+        #   */
+        # void approxNearestSearch (int query_index, int &result_index, float &sqr_distance);
+        void approxNearestSearch (int query_index, int &result_index, float &sqr_distance)
+        
+        # /** \brief Get a PointT vector of centers of all voxels that intersected by a ray (origin, direction).
+        #   * \param[in] origin ray origin
+        #   * \param[in] direction ray direction vector
+        #   * \param[out] voxel_center_list results are written to this vector of PointT elements
+        #   * \param[in] max_voxel_count stop raycasting when this many voxels intersected (0: disable)
+        #   * \return number of intersected voxels
+        #  */
+        # int getIntersectedVoxelCenters (Eigen::Vector3f origin, Eigen::Vector3f direction, AlignedPointTVector &voxel_center_list, int max_voxel_count = 0) const;
+        # int getIntersectedVoxelCenters (eig.Vector3f origin, eig.Vector3f direction, AlignedPointTVector &voxel_center_list, int max_voxel_count = 0) const;
+        
+        # /** \brief Get indices of all voxels that are intersected by a ray (origin, direction).
+        #   * \param[in] origin ray origin
+        #   * \param[in] direction ray direction vector
+        #   * \param[out] k_indices resulting point indices from intersected voxels
+        #   * \param[in] max_voxel_count stop raycasting when this many voxels intersected (0: disable)
+        #  * \return number of intersected voxels
+        #  */
+        # int getIntersectedVoxelIndices (Eigen::Vector3f origin, Eigen::Vector3f direction, std::vector<int> &k_indices, int max_voxel_count = 0) const; 
+        int getIntersectedVoxelIndices (eig.Vector3f origin, eig.Vector3f direction, vector[int] &k_indices, int max_voxel_count)
+        
+        # /** \brief Search for points within rectangular search area
+        #  * \param[in] min_pt lower corner of search area
+        #  * \param[in] max_pt upper corner of search area
+        #  * \param[out] k_indices the resultant point indices
+        #  * \return number of points found within search area
+        #  */
+        # int boxSearch (const Eigen::Vector3f &min_pt, const Eigen::Vector3f &max_pt, std::vector<int> &k_indices) const;
+        int boxSearch (const eig.Vector3f &min_pt, const eig.Vector3f &max_pt, vector[int] &k_indices)
+
+
+ctypedef OctreePointCloudSearch[cpp.PointXYZ] OctreePointCloudSearch_t
+ctypedef OctreePointCloudSearch[cpp.PointXYZI] OctreePointCloudSearch_PointXYZI_t
+ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t
+ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGB]] OctreePointCloudSearch_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGBA]] OctreePointCloudSearch_PointXYZRGBA_Ptr_t
+###
+
+
+# 1.7.2 Add headers
+# octree2buf_base.h
+# octree_pointcloud_adjacency.h
+# octree_pointcloud_adjacency_container.h
+# octree_pointcloud_changedetector.h
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
+
+
diff --git a/pcl/pcl_octree_180.pxd b/pcl/pcl_octree_180.pxd
new file mode 100644
index 0000000..9223fb9
--- /dev/null
+++ b/pcl/pcl_octree_180.pxd
@@ -0,0 +1,1458 @@
+# -*- coding: utf-8 -*-
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eig
+from vector cimport vector as vector2
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# octree_container.h
+# namespace pcl
+# namespace octree
+# \brief @b Octree container class that can serve as a base to construct own leaf node container classes.
+# \author Julius Kammerl (julius@kammerl.de)
+# class OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerBase:
+        OctreeContainerBase ()
+        # \brief Empty constructor.
+        
+        # \brief Empty constructor.
+        # OctreeContainerBase (const OctreeContainerBase&)
+        
+        # \brief Empty deconstructor.
+        # virtual ~OctreeContainerBase ()
+        
+        # \brief Equal comparison operator
+        # virtual bool operator== (const OctreeContainerBase&) const
+        
+        # \brief Inequal comparison operator
+        # \param[in] other OctreeContainerBase to compare with
+        # bool operator!= (const OctreeContainerBase& other) const
+        
+        # \brief Pure abstract method to get size of container (number of indices)
+        # \return number of points/indices stored in leaf node container.
+        # virtual size_t getSize () const
+        
+        # \brief Pure abstract reset leaf node implementation. */
+        # virtual void reset () = 0;
+        
+        # \brief Empty addPointIndex implementation. This leaf node does not store any point indices.
+        void addPointIndex (const int&)
+        
+        # \brief Empty getPointIndex implementation as this leaf node does not store any point indices.
+        # void getPointIndex (int&) const
+        
+        # \brief Empty getPointIndices implementation as this leaf node does not store any data.
+        # void getPointIndices (std::vector<int>&) const
+
+
+##
+
+# octree_container.h
+# namespace pcl
+# namespace octree
+# class OctreeContainerEmpty : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerEmpty(OctreeContainerBase):
+        OctreeContainerEmpty()
+        # OctreeContainerEmpty (const OctreeContainerEmpty&)
+        # public:
+        # /** \brief Octree deep copy method */
+        # virtual OctreeContainerEmpty *deepCopy () const
+        # /** \brief Octree deep copy method */
+        # virtual OctreeContainerEmpty *deepCopy () const
+        # 
+        # /** \brief Abstract get size of container (number of DataT objects)
+        # * \return number of DataT elements in leaf node container.
+        # */
+        # virtual size_t getSize () const
+        # 
+        # /** \brief Abstract reset leaf node implementation. */
+        # virtual void reset ()
+        # 
+        # /** \brief Empty addPointIndex implementation. This leaf node does not store any point indices.
+        # */
+        # void addPointIndex (int)
+        # 
+        # /** \brief Empty getPointIndex implementation as this leaf node does not store any point indices.
+        # */
+        # int getPointIndex () const
+        # 
+        # /** \brief Empty getPointIndices implementation as this leaf node does not store any data. \
+        # */
+        # void getPointIndices (std::vector<int>&) const
+
+
+ctypedef OctreeContainerEmpty OctreeContainerEmpty_t
+ctypedef shared_ptr[OctreeContainerEmpty] OctreeContainerEmptyPtr_t
+###
+
+
+# octree_container.h
+# namespace pcl
+# namespace octree
+# \brief @b Octree container class that does store a vector of point indices.
+# \note Enables the octree to store multiple DataT elements within its leaf nodes.
+# \author Julius Kammerl (julius@kammerl.de)
+# class OctreeContainerPointIndices : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerPointIndices(OctreeContainerBase):
+        OctreeContainerPointIndices()
+        #   /** \brief Empty constructor. */
+        #   OctreeContainerPointIndices () :
+        #     OctreeContainerBase (), leafDataTVector_ ()
+        # 
+        #   /** \brief Empty constructor. */
+        #   OctreeContainerPointIndices (const OctreeContainerPointIndices& source) :
+        #       OctreeContainerBase (), leafDataTVector_ (source.leafDataTVector_)
+        # 
+        #   /** \brief Empty deconstructor. */
+        #   virtual
+        #   ~OctreeContainerPointIndices ()
+        # 
+        #   /** \brief Octree deep copy method */
+        #   virtual OctreeContainerPointIndices *deepCopy () const
+        # 
+        #   /** \brief Equal comparison operator
+        #    * \param[in] other OctreeContainerDataTVector to compare with
+        #    */
+        #   virtual bool
+        #   operator== (const OctreeContainerBase& other) const
+        # 
+        #   /** \brief Add point index to container memory. This container stores a vector of point indices.
+        #    * \param[in] data_arg index to be stored within leaf node.
+        #    */
+        #   void addPointIndex (int data_arg)
+        # 
+        #   /** \brief Retrieve point index from container. This container stores a vector of point indices.
+        #    * \return index stored within container.
+        #    */
+        #   int getPointIndex ( ) const
+        # 
+        #   /** \brief Retrieve point indices from container. This container stores a vector of point indices.
+        #    * \param[out] data_vector_arg vector of point indices to be stored within data vector
+        #    */
+        #   void getPointIndices (std::vector<int>& data_vector_arg) const
+        # 
+        #   /** \brief Retrieve reference to point indices vector. This container stores a vector of point indices.
+        #    * \return reference to vector of point indices to be stored within data vector
+        #    */
+        #   std::vector<int>& getPointIndicesVector ()
+        # 
+        #   /** \brief Get size of container (number of indices)
+        #    * \return number of point indices in container.
+        #    */
+        #   size_t getSize () const
+        # 
+        #   /** \brief Reset leaf node. Clear DataT vector.*/
+        #   virtual void reset ()
+
+
+ctypedef OctreeContainerPointIndices OctreeContainerPointIndices_t
+# ctypedef shared_ptr[OctreeContainerPointIndices] OctreeContainerPointIndicesPtr_t
+###
+
+# octree_pointcloud_density.h
+# namespace pcl
+# namespace octree
+# class OctreePointCloudDensityContainer : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_pointcloud_density.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloudDensityContainer(OctreeContainerBase):
+        OctreePointCloudDensityContainer ()
+        # /** \brief deep copy function */
+        # virtual OctreePointCloudDensityContainer * deepCopy () const
+        
+        # /** \brief Equal comparison operator
+        #  * \param[in] other OctreePointCloudDensityContainer to compare with
+        #  */
+        # virtual bool operator==(const OctreeContainerBase& other) const
+        
+        # /** \brief Read input data. Only an internal counter is increased.
+        #   */
+        # void addPointIndex (int)
+        
+        # /** \brief Return point counter.
+        #   * \return Amount of points
+        #   */
+        # unsigned int getPointCounter ()
+        
+        # /** \brief Reset leaf node. */
+        # virtual void reset ()
+
+
+ctypedef OctreePointCloudDensityContainer OctreePointCloudDensityContainer_t
+ctypedef shared_ptr[OctreePointCloudDensityContainer] OctreePointCloudDensityContainerPtr_t
+###
+
+# octree_base.h
+# namespace pcl
+# namespace octree
+# pcl 1.7.2
+# template<typename LeafContainerT = int, typename BranchContainerT = OctreeContainerEmpty >
+# class OctreeBase
+cdef extern from "pcl/octree/octree_base.h" namespace "pcl::octree":
+     # cdef cppclass OctreeBase:
+     cdef cppclass OctreeBase[LeafContainerT, BranchContainerT]:
+        OctreeBase()
+        # OctreeBase (const OctreeBase& source) :
+        # inline OctreeBase& operator = (const OctreeBase &source)
+        # public:
+        # typedef OctreeBase<LeafContainerT, BranchContainerT> OctreeT;
+        # typedef OctreeBranchNode<BranchContainerT> BranchNode;
+        # typedef OctreeLeafNode<LeafContainerT> LeafNode;
+        # typedef BranchContainerT BranchContainer;
+        # typedef LeafContainerT LeafContainer;
+        # // iterators are friends
+        # friend class OctreeIteratorBase<OctreeT> ;
+        # friend class OctreeDepthFirstIterator<OctreeT> ;
+        # friend class OctreeBreadthFirstIterator<OctreeT> ;
+        # friend class OctreeLeafNodeIterator<OctreeT> ;
+        # 
+        # // Octree default iterators
+        # typedef OctreeDepthFirstIterator<OctreeT> Iterator;
+        # typedef const OctreeDepthFirstIterator<OctreeT> ConstIterator;
+        # Iterator begin(unsigned int max_depth_arg = 0) {return Iterator(this, max_depth_arg);};
+        # const Iterator end() {return Iterator();};
+        # 
+        # // Octree leaf node iterators
+        # typedef OctreeLeafNodeIterator<OctreeT> LeafNodeIterator;
+        # typedef const OctreeLeafNodeIterator<OctreeT> ConstLeafNodeIterator;
+        # LeafNodeIterator leaf_begin(unsigned int max_depth_arg = 0) {return LeafNodeIterator(this, max_depth_arg);};
+        # const LeafNodeIterator leaf_end() {return LeafNodeIterator();};
+        # 
+        # // Octree depth-first iterators
+        # typedef OctreeDepthFirstIterator<OctreeT> DepthFirstIterator;
+        # typedef const OctreeDepthFirstIterator<OctreeT> ConstDepthFirstIterator;
+        # DepthFirstIterator depth_begin(unsigned int max_depth_arg = 0) {return DepthFirstIterator(this, max_depth_arg);};
+        # const DepthFirstIterator depth_end() {return DepthFirstIterator();};
+        # 
+        # // Octree breadth-first iterators
+        # typedef OctreeBreadthFirstIterator<OctreeT> BreadthFirstIterator;
+        # typedef const OctreeBreadthFirstIterator<OctreeT> ConstBreadthFirstIterator;
+        # BreadthFirstIterator breadth_begin(unsigned int max_depth_arg = 0) {return BreadthFirstIterator(this, max_depth_arg);};
+        # const BreadthFirstIterator breadth_end() {return BreadthFirstIterator();};
+        # 
+        # /** \brief Empty constructor. */
+        # OctreeBase ();
+        # 
+        # /** \brief Empty deconstructor. */
+        # virtual ~OctreeBase ();
+        # 
+        # /** \brief Copy constructor. */
+        # OctreeBase (const OctreeBase& source)
+        # 
+        # /** \brief Copy operator. */
+        # OctreeBase& operator = (const OctreeBase &source)
+        # 
+        # /** \brief Set the maximum amount of voxels per dimension.
+        #   * \param[in] max_voxel_index_arg maximum amount of voxels per dimension
+        #   */
+        # void setMaxVoxelIndex (unsigned int max_voxel_index_arg);
+        void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg)
+        
+        # \brief Set the maximum depth of the octree.
+        # \param max_depth_arg: maximum depth of octree
+        # void setTreeDepth (unsigned int max_depth_arg);
+        void setTreeDepth (unsigned int max_depth_arg)
+        
+        # \brief Get the maximum depth of the octree.
+        # \return depth_arg: maximum depth of octree
+        # unsigned int getTreeDepth () const
+        unsigned int getTreeDepth ()
+
+        # /** \brief Create new leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to new leaf node container.
+        #  * */
+        # LeafContainerT* createLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief Find leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to leaf node container if found, null pointer otherwise.
+        #  * */
+        # LeafContainerT* findLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief idx_x_arg for the existence of leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return "true" if leaf node search is successful, otherwise it returns "false".
+        #  * */
+        # bool existLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg) const ;
+        # 
+        # /** \brief Remove leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  * */
+        # void removeLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # \brief Return the amount of existing leafs in the octree.
+        # \return amount of registered leaf nodes.
+        # std::size_t getLeafCount () const
+        size_t getLeafCount ()
+        
+        # \brief Return the amount of existing branches in the octree.
+        # \return amount of branch nodes.
+        # std::size_t getBranchCount () const
+        size_t getBranchCount ()
+        
+        # /** \brief Delete the octree structure and its leaf nodes.
+        #  * */
+        # void deleteTree ( );
+        void deleteTree ( )
+        
+        # \brief Serialize octree into a binary output vector describing its branch node structure.
+        # \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        # void serializeTree (vector[char]& binary_tree_out_arg)
+        void serializeTree (vector[char]& binary_tree_out_arg)
+        
+        # 
+        # /** \brief Serialize octree into a binary output vector describing its branch node structure and push all LeafContainerT elements stored in the octree to a vector.
+        #  * \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        #  * \param leaf_container_vector_arg: pointer to all LeafContainerT objects in the octree
+        #  * */
+        # void serializeTree (std::vector<char>& binary_tree_out_arg, std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # void serializeTree (vector[char]& binary_tree_out_arg, vector[LeafContainerT*]& leaf_container_vector_arg)
+        # 
+        # /** \brief Outputs a vector of all LeafContainerT elements that are stored within the octree leaf nodes.
+        #  *  \param leaf_container_vector_arg: pointers to LeafContainerT vector that receives a copy of all LeafContainerT objects in the octree.
+        #  * */
+        # void serializeLeafs (std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # void serializeLeafs (vector[LeafContainerT*]& leaf_container_vector_arg)
+        # 
+        # /** \brief Deserialize a binary octree description vector and create a corresponding octree structure. Leaf nodes are initialized with getDataTByKey(..).
+        #  *  \param binary_tree_input_arg: reference to input vector for reading binary tree structure.
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_input_arg);
+        # void deserializeTree (vector[char]& binary_tree_input_arg)
+        # 
+        # /** \brief Deserialize a binary octree description and create a corresponding octree structure. Leaf nodes are initialized with LeafContainerT elements from the dataVector.
+        #  *  \param binary_tree_input_arg: reference to input vector for reading binary tree structure.
+        #  *  \param leaf_container_vector_arg: pointer to container vector.
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_input_arg, std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # void deserializeTree (vector[char]& binary_tree_input_arg, vector[LeafContainerT*]& leaf_container_vector_arg)
+        # 
+        # typedef OctreeBranchNode<BranchT> BranchNode;
+        # typedef OctreeLeafNode<LeafT> LeafNode;
+        # // Octree iterators
+
+
+ctypedef OctreeBase[int, OctreeContainerEmpty_t] OctreeBase_t
+ctypedef shared_ptr[OctreeBase[int, OctreeContainerEmpty_t]] OctreeBasePtr_t
+# use OctreePointCloud
+ctypedef OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] OctreeBase_OctreeContainerPointIndices_t
+ctypedef shared_ptr[OctreeBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] OctreeBase_OctreeContainerPointIndicesPtr_t
+# use OctreePointCloudDensity
+ctypedef OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t] OctreeBase_OctreePointCloudDensity_t
+ctypedef shared_ptr[OctreeBase[OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t]] OctreeBase_OctreePointCloudDensityPtr_t
+###
+
+### Inheritance class ###
+
+# octree.h
+# header include
+###
+
+# Version 1.7.2
+# octree2buf_base.h
+# namespace pcl
+# namespace octree
+    # template<typename ContainerT>
+    # class BufferedBranchNode : public OctreeNode, ContainerT
+    # {
+        # using ContainerT::getSize;
+        # using ContainerT::getData;
+        # using ContainerT::setData;
+        # 
+        # public:
+        # /** \brief Empty constructor. */
+        # BufferedBranchNode () : OctreeNode(), ContainerT(),  preBuf(0xFFFFFF), postBuf(0xFFFFFF)
+        # /** \brief Copy constructor. */
+        # BufferedBranchNode (const BufferedBranchNode& source) : ContainerT(source)
+        # /** \brief Copy operator. */
+        # inline BufferedBranchNode& operator = (const BufferedBranchNode &source_arg)
+        # /** \brief Empty constructor. */
+        # virtual ~BufferedBranchNode ()
+        # 
+        # /** \brief Method to perform a deep copy of the octree */
+        # virtual BufferedBranchNode* deepCopy () const
+        # 
+        # /** \brief Get child pointer in current branch node
+        #  *  \param buffer_arg: buffer selector
+        #  *  \param index_arg: index of child in node
+        #  *  \return pointer to child node
+        #  * */
+        # inline OctreeNode* getChildPtr (unsigned char buffer_arg, unsigned char index_arg) const
+        # 
+        # /** \brief Set child pointer in current branch node
+        #  *  \param buffer_arg: buffer selector
+        #  *  \param index_arg: index of child in node
+        #  *  \param newNode_arg: pointer to new child node
+        #  * */
+        # inline void setChildPtr (unsigned char buffer_arg, unsigned char index_arg, OctreeNode* newNode_arg)
+        # 
+        # /** \brief Check if branch is pointing to a particular child node
+        #  *  \param buffer_arg: buffer selector
+        #  *  \param index_arg: index of child in node
+        #  *  \return "true" if pointer to child node exists; "false" otherwise
+        #  * */
+        # inline bool hasChild (unsigned char buffer_arg, unsigned char index_arg) const
+        # 
+        # /** \brief Get the type of octree node. Returns LEAVE_NODE type */
+        # virtual node_type_t getNodeType () const
+        # 
+        # /** \brief Reset branch node container for every branch buffer. */
+        # inline void reset ()
+
+
+###
+
+# namespace pcl
+# namespace octree
+# /** \brief @b Octree double buffer class
+#  * \note This octree implementation keeps two separate octree structures
+#  * in memory. This enables to create octree structures at high rate due to
+#  * an advanced memory management.
+#  * \note Furthermore, it allows for detecting and differentially compare the adjacent octree structures.
+#  * \note The tree depth defines the maximum amount of octree voxels / leaf nodes (should be initially defined).
+#  * \note All leaf nodes are addressed by integer indices.
+#  * \note Note: The tree depth equates to the bit length of the voxel indices.
+#  * \ingroup octree
+#  * \author Julius Kammerl (julius@kammerl.de)
+#  */
+# template<typename LeafContainerT = int,
+# typename BranchContainerT = OctreeContainerEmpty >
+# class Octree2BufBase
+cdef extern from "pcl/octree/octree2buf_base.h" namespace "pcl::octree":
+    cdef cppclass Octree2BufBase[LeafContainerT, BranchContainerT]:
+        Octree2BufBase()
+        # public:
+        # typedef Octree2BufBase<DataT, LeafT, BranchT> OctreeT;
+        # // iterators are friends
+        # friend class OctreeIteratorBase<DataT, OctreeT> ;
+        # friend class OctreeDepthFirstIterator<DataT, OctreeT> ;
+        # friend class OctreeBreadthFirstIterator<DataT, OctreeT> ;
+        # friend class OctreeLeafNodeIterator<DataT, OctreeT> ;
+        # typedef BufferedBranchNode<BranchT> BranchNode;
+        # typedef OctreeLeafNode<LeafT> LeafNode;
+        # 
+        # // Octree iterators
+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> Iterator;
+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstIterator;
+        # typedef OctreeLeafNodeIterator<DataT, OctreeT> LeafNodeIterator;
+        # typedef const OctreeLeafNodeIterator<DataT, OctreeT> ConstLeafNodeIterator;
+        # typedef OctreeDepthFirstIterator<DataT, OctreeT> DepthFirstIterator;
+        # typedef const OctreeDepthFirstIterator<DataT, OctreeT> ConstDepthFirstIterator;
+        # typedef OctreeBreadthFirstIterator<DataT, OctreeT> BreadthFirstIterator;
+        # typedef const OctreeBreadthFirstIterator<DataT, OctreeT> ConstBreadthFirstIterator;
+        # 
+        # /** \brief Empty constructor. */
+        # Octree2BufBase ();
+        # 
+        # /** \brief Empty deconstructor. */
+        # virtual ~Octree2BufBase ();
+        # 
+        # /** \brief Copy constructor. */
+        # Octree2BufBase (const Octree2BufBase& source) :
+        #     leafCount_ (source.leafCount_), branchCount_ (source.branchCount_), objectCount_ (
+        #     source.objectCount_), rootNode_ (
+        #       new (BranchNode) (* (source.rootNode_))), depthMask_ (
+        #       source.depthMask_), maxKey_ (source.maxKey_), branchNodePool_ (), leafNodePool_ (), bufferSelector_ (
+        #         source.bufferSelector_), treeDirtyFlag_ (source.treeDirtyFlag_), octreeDepth_ (
+        #         source.octreeDepth_)
+        # 
+        # /** \brief Copy constructor. */
+        # inline Octree2BufBase& operator = (const Octree2BufBase& source)
+        # 
+        # /** \brief Set the maximum amount of voxels per dimension.
+        #   * \param[in] max_voxel_index_arg maximum amount of voxels per dimension
+        #   */
+        # void setMaxVoxelIndex (unsigned int max_voxel_index_arg);
+        void setMaxVoxelIndex (unsigned int maxVoxelIndex_arg)
+        
+        # \brief Set the maximum depth of the octree.
+        # \param max_depth_arg: maximum depth of octree
+        # void setTreeDepth (unsigned int max_depth_arg);
+        void setTreeDepth (unsigned int max_depth_arg)
+        
+        # \brief Get the maximum depth of the octree.
+        # \return depth_arg: maximum depth of octree
+        # unsigned int getTreeDepth () const
+        unsigned int getTreeDepth ()
+
+        # /** \brief Create new leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to new leaf node container.
+        #  * */
+        # LeafContainerT* createLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief Find leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \note If leaf node already exist, this method returns the existing node
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return pointer to leaf node container if found, null pointer otherwise.
+        #  * */
+        # LeafContainerT* findLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # /** \brief idx_x_arg for the existence of leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  *  \return "true" if leaf node search is successful, otherwise it returns "false".
+        #  * */
+        # bool existLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg) const ;
+        # 
+        # /** \brief Remove leaf node at (idx_x_arg, idx_y_arg, idx_z_arg).
+        #  *  \param idx_x_arg: index of leaf node in the X axis.
+        #  *  \param idx_y_arg: index of leaf node in the Y axis.
+        #  *  \param idx_z_arg: index of leaf node in the Z axis.
+        #  * */
+        # void removeLeaf (unsigned int idx_x_arg, unsigned int idx_y_arg, unsigned int idx_z_arg);
+        # 
+        # \brief Return the amount of existing leafs in the octree.
+        # \return amount of registered leaf nodes.
+        # std::size_t getLeafCount () const
+        size_t getLeafCount ()
+        
+        # \brief Return the amount of existing branches in the octree.
+        # \return amount of branch nodes.
+        # std::size_t getBranchCount () const
+        size_t getBranchCount ()
+        
+        # /** \brief Delete the octree structure and its leaf nodes.
+        #  * */
+        # void deleteTree ( );
+        void deleteTree ( )
+        
+        # /** \brief Delete octree structure of previous buffer. */
+        # inline void deletePreviousBuffer ()
+        
+        # /** \brief Delete the octree structure in the current buffer. */
+        # inline void deleteCurrentBuffer ()
+        
+        # /** \brief Switch buffers and reset current octree structure. */
+        void switchBuffers ()
+        
+        # \brief Serialize octree into a binary output vector describing its branch node structure.
+        # \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        # void serializeTree (vector[char]& binary_tree_out_arg)
+        # void serializeTree (vector[char]& binary_tree_out_arg)
+        # 
+        # /** \brief Serialize octree into a binary output vector describing its branch node structure.
+        #  *  \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        #  *  \param do_XOR_encoding_arg: select if binary tree structure should be generated based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void serializeTree (std::vector<char>& binary_tree_out_arg, bool do_XOR_encoding_arg = false);
+        # 
+        # /** \brief Serialize octree into a binary output vector describing its branch node structure and and push all DataT elements stored in the octree to a vector.
+        #  * \param binary_tree_out_arg: reference to output vector for writing binary tree structure.
+        #  * \param leaf_container_vector_arg: pointer to all LeafContainerT objects in the octree
+        #  * \param do_XOR_encoding_arg: select if binary tree structure should be generated based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void serializeTree (std::vector<char>& binary_tree_out_arg,
+        #                std::vector<LeafContainerT*>& leaf_container_vector_arg,
+        #                bool do_XOR_encoding_arg = false);
+        # 
+        # /** \brief Outputs a vector of all DataT elements that are stored within the octree leaf nodes.
+        #  *  \param leaf_container_vector_arg: vector of pointers to all LeafContainerT objects in the octree
+        #  * */
+        # void serializeLeafs (std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # 
+        # /** \brief Outputs a vector of all DataT elements from leaf nodes, that do not exist in the previous octree buffer.
+        #  *  \param leaf_container_vector_arg: vector of pointers to all LeafContainerT objects in the octree
+        #  * */
+        # void serializeNewLeafs (std::vector<LeafContainerT*>& leaf_container_vector_arg);
+        # 
+        # /** \brief Deserialize a binary octree description vector and create a corresponding octree structure. Leaf nodes are initialized with getDataTByKey(..).
+        #  *  \param binary_tree_in_arg: reference to input vector for reading binary tree structure.
+        #  *  \param do_XOR_decoding_arg: select if binary tree structure is based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_in_arg, bool do_XOR_decoding_arg = false);
+        # 
+        # /** \brief Deserialize a binary octree description and create a corresponding octree structure. Leaf nodes are initialized with DataT elements from the dataVector.
+        #  *  \param binary_tree_in_arg: reference to inpvectoream for reading binary tree structure.
+        #  *  \param leaf_container_vector_arg: vector of pointers to all LeafContainerT objects in the octree
+        #  *  \param do_XOR_decoding_arg: select if binary tree structure is based on current octree (false) of based on a XOR comparison between current and previous octree
+        #  * */
+        # void deserializeTree (std::vector<char>& binary_tree_in_arg,
+        #                  std::vector<LeafContainerT*>& leaf_container_vector_arg,
+        #                  bool do_XOR_decoding_arg = false);
+
+
+ctypedef Octree2BufBase[int, OctreeContainerEmpty_t] Octree2BufBase_t
+ctypedef shared_ptr[Octree2BufBase[int, OctreeContainerEmpty_t]] Octree2BufBasePtr_t
+ctypedef Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t] Octree2BufBase_OctreeContainerPointIndices_t
+ctypedef shared_ptr[Octree2BufBase[OctreeContainerPointIndices_t, OctreeContainerEmpty_t]] Octree2BufBasePtr_OctreeContainerPointIndicesPtr_t
+###
+
+# nothing use PCL 1.7.2/1.8.0
+# template<typename DataT>
+# class OctreeContainerDataT
+# cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+#     cdef cppclass OctreeContainerDataT[DataT]:
+#         OctreeContainerDataT()
+#         # OctreeContainerDataT (const OctreeContainerDataT& source) :
+#         # public:
+#         # /** \brief Octree deep copy method */
+#         # virtual OctreeContainerDataT* deepCopy () const
+#         # /** \brief Copies a DataT element to leaf node memorye.
+#         #  * \param[in] data_arg reference to DataT element to be stored within leaf node.
+#         # void setData (const DataT& data_arg)
+#         # /** \brief Adds leaf node DataT element to dataVector vector of type DataT.
+#         #  * \param[in] dataVector_arg: reference to DataT type to obtain the most recently added leaf node DataT element.
+#         # void getData (DataT& dataVector_arg) const
+#         # /** \brief Adds leaf node DataT element to dataVector vector of type DataT.
+#         #  * \param[in] dataVector_arg: reference to DataT vector that is to be extended with leaf node DataT elements.
+#         # void getData (vector<DataT>& dataVector_arg) const
+#         # /** \brief Get size of container (number of DataT objects)
+#         #  * \return number of DataT elements in leaf node container.
+#         # size_t getSize () const
+#         # /** \brief Reset leaf node memory to zero. */
+#         # void reset ()
+#         # protected:
+#         # /** \brief Leaf node DataT storage. */
+#         # DataT data_;
+#         # /** \brief Bool indicating if leaf node is empty or not. */
+#         # bool isEmpty_;
+# 
+# 
+# ctypedef OctreeContainerDataT[int] OctreeContainerDataT_t
+# # ctypedef shared_ptr[OctreeContainerDataT[int]] OctreeContainerDataTPtr_t
+###
+
+# \brief @b Octree container class that does store a single point index.
+# \note Enables the octree to store a single DataT element within its leaf nodes.
+# \author Julius Kammerl (julius@kammerl.de)
+# class OctreeContainerPointIndex : public OctreeContainerBase
+cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+    cdef cppclass OctreeContainerPointIndex(OctreeContainerBase):
+        OctreeContainerPointIndex()
+        # \brief Empty constructor.
+        # OctreeContainerPointIndex (const OctreeContainerPointIndex& source)
+        # 
+        # /** \brief Empty deconstructor. */
+        # virtual ~OctreeContainerPointIndex ()
+        # 
+        # /** \brief Octree deep copy method */
+        # virtual OctreeContainerPointIndex* deepCopy () const
+        # 
+        # /** \brief Equal comparison operator
+        #  * \param[in] other OctreeContainerBase to compare with
+        # virtual bool operator== (const OctreeContainerBase& other) const
+        # 
+        # /** \brief Add point index to container memory. This container stores a only a single point index.
+        #  * \param[in] data_arg index to be stored within leaf node.
+        # void addPointIndex (int data_arg)
+        # 
+        # /** \brief Retrieve point index from container. This container stores a only a single point index
+        #  * \return index stored within container.
+        # int getPointIndex () const
+        # 
+        # /** \brief Retrieve point indices from container. This container stores only a single point index
+        #  * \param[out] data_vector_arg vector of point indices to be stored within data vector
+        # void getPointIndices (std::vector<int>& data_vector_arg) const
+        # 
+        # \brief Get size of container (number of DataT objects)
+        # \return number of DataT elements in leaf node container.
+        # size_t getSize () const
+        # 
+        # /** \brief Reset leaf node memory to zero. */
+        # virtual void reset ()
+
+
+###
+
+# no use pcl 1.8.0
+# replace : OctreeContainerPointIndices
+# template<typename DataT>
+# class OctreeContainerDataTVector
+# cdef extern from "pcl/octree/octree_container.h" namespace "pcl::octree":
+#     cdef cppclass OctreeContainerDataTVector[DataT]:
+#         OctreeContainerDataTVector()
+#         # OctreeContainerDataTVector (const OctreeContainerDataTVector& source) :
+#         # public:
+#         # /** \brief Octree deep copy method */
+#         # virtual OctreeContainerDataTVector *deepCopy () const
+#         # /** \brief Pushes a DataT element to internal DataT vector.
+#         #  * \param[in] data_arg reference to DataT element to be stored within leaf node.
+#         #  */
+#         # void setData (const DataT& data_arg)
+#         # /** \brief Receive the most recent DataT element that was pushed to the internal DataT vector.
+#         #  * \param[in] data_arg reference to DataT type to obtain the most recently added leaf node DataT element.
+#         #  */
+#         # void getData (DataT& data_arg) const
+#         # /** \brief Concatenate the internal DataT vector to vector argument dataVector_arg.
+#         #  * \param[in] dataVector_arg: reference to DataT vector that is to be extended with leaf node DataT elements.
+#         #  */
+#         # void getData (vector[DataT]& dataVector_arg) const
+#         # /** \brief Return const reference to internal DataT vector
+#         #  * \return  const reference to internal DataT vector
+#         # const vector[DataT]& getDataTVector () const
+#         # /** \brief Get size of container (number of DataT objects)
+#         #  * \return number of DataT elements in leaf node container.
+#         # size_t getSize () const
+#         # /** \brief Reset leaf node. Clear DataT vector.*/
+#         void reset ()
+# 
+# 
+# ctypedef OctreeContainerDataTVector[int] OctreeContainerDataTVector_t
+# # ctypedef shared_ptr[OctreeContainerDataTVector[int]] OctreeContainerDataTVectorPtr_t
+###
+
+# octree_impl.h
+# impl header include
+###
+
+
+# octree_iterator.h
+# namespace pcl
+# namespace octree
+#   template<typename DataT, typename OctreeT>
+#       class OctreeIteratorBase : public std::iterator<std::forward_iterator_tag, const OctreeNode, void, const OctreeNode*, const OctreeNode&>
+# pcl 1.8.0
+# template<typename OctreeT>
+# class OctreeIteratorBase : public std::iterator<std::forward_iterator_tag, const OctreeNode, void,
+# const OctreeNode*, const OctreeNode&>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeIteratorBase[OctreeT]:
+        OctreeIteratorBase()
+        # explicit OctreeIteratorBase (OctreeT& octree_arg)
+        # OctreeIteratorBase (const OctreeIteratorBase& src) :
+        # inline OctreeIteratorBase& operator = (const OctreeIteratorBase& src)
+        # public:
+        # typedef typename OctreeT::LeafNode LeafNode;
+        # typedef typename OctreeT::BranchNode BranchNode;
+        # /** \brief initialize iterator globals */
+        # inline void reset ()
+        # /** \brief Get octree key for the current iterator octree node
+        #  * \return octree key of current node
+        # inline const OctreeKey& getCurrentOctreeKey () const
+        # /** \brief Get the current depth level of octree
+        #  * \return depth level
+        # inline unsigned int getCurrentOctreeDepth () const
+        # /** \brief Get the current octree node
+        #  * \return pointer to current octree node
+        # inline OctreeNode* getCurrentOctreeNode () const
+        # /** \brief *operator.
+        #  * \return pointer to the current octree node
+        # inline OctreeNode* operator* () const
+        # /** \brief check if current node is a branch node
+        #  * \return true if current node is a branch node, false otherwise
+        # inline bool isBranchNode () const
+        # /** \brief check if current node is a branch node
+        #  * \return true if current node is a branch node, false otherwise
+        # inline bool isLeafNode () const
+        # /** \brief Get bit pattern of children configuration of current node
+        #  * \return bit pattern (byte) describing the existence of 8 children of the current node
+        # inline char getNodeConfiguration () const
+        # /** \brief Method for retrieving a single DataT element from the octree leaf node
+        #  * \param[in] data_arg reference to return pointer of leaf node DataT element.
+        # virtual void getData (DataT& data_arg) const
+        # /** \brief Method for retrieving a vector of DataT elements from the octree laef node
+        #  * \param[in] dataVector_arg reference to DataT vector that is extended with leaf node DataT elements.
+        # virtual void getData (std::vector<DataT>& dataVector_arg) const
+        # /** \brief Method for retrieving the size of the DataT vector from the octree laef node
+        # virtual std::size_t getSize () const
+        # /** \brief get a integer identifier for current node (note: identifier depends on tree depth).
+        #  * \return node id.
+        # virtual unsigned long getNodeID () const
+
+
+###
+
+# pcl 1.7.2
+# template<typename DataT, typename OctreeT>
+# class OctreeDepthFirstIterator : public OctreeIteratorBase<DataT, OctreeT>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeDepthFirstIterator[OctreeT](OctreeIteratorBase[OctreeT]):
+        OctreeDepthFirstIterator()
+        # explicit OctreeDepthFirstIterator (OctreeT& octree_arg)
+        # public:
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::LeafNode LeafNode;
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::BranchNode BranchNode;
+        # /** \brief Reset the iterator to the root node of the octree
+        # virtual void reset ();
+        # /** \brief Preincrement operator.
+        #  * \note recursively step to next octree node
+        # OctreeDepthFirstIterator& operator++ ();
+        # /** \brief postincrement operator.
+        #  * \note recursively step to next octree node
+        # inline OctreeDepthFirstIterator operator++ (int)
+        # /** \brief Skip all child voxels of current node and return to parent node.
+        # void skipChildVoxels ();
+        # protected:
+        # /** Child index at current octree node. */
+        # unsigned char currentChildIdx_;
+        # /** Stack structure. */
+        # std::vector<std::pair<OctreeNode*, unsigned char> > stack_;
+
+
+###
+
+# pcl 1.7.2
+# template<typename DataT, typename OctreeT>
+# class OctreeBreadthFirstIterator : public OctreeIteratorBase<DataT, OctreeT>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeBreadthFirstIterator[OctreeT](OctreeIteratorBase[OctreeT]):
+        OctreeDepthFirstIterator()
+        # explicit OctreeBreadthFirstIterator (OctreeT& octree_arg);
+        # // public typedefs
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::BranchNode BranchNode;
+        # typedef typename OctreeIteratorBase<DataT, OctreeT>::LeafNode LeafNode;
+        # struct FIFOElement
+        # {
+        #   OctreeNode* node;
+        #   OctreeKey key;
+        #   unsigned int depth;
+        # };
+        # public:
+        # /** \brief Reset the iterator to the root node of the octree
+        # void reset ();
+        # /** \brief Preincrement operator.
+        #  * \note step to next octree node
+        # OctreeBreadthFirstIterator& operator++ ();
+        # /** \brief postincrement operator.
+        #  * \note step to next octree node
+        # inline OctreeBreadthFirstIterator operator++ (int)
+        # protected:
+        # /** \brief Add children of node to FIFO
+        #  * \param[in] node: node with children to be added to FIFO
+        # void addChildNodesToFIFO (const OctreeNode* node);
+        # /** FIFO list */
+        # std::deque<FIFOElement> FIFO_;
+
+
+###
+
+# template<typename DataT, typename OctreeT>
+# class OctreeLeafNodeIterator : public OctreeDepthFirstIterator<DataT, OctreeT>
+cdef extern from "pcl/octree/octree_iterator.h" namespace "pcl::octree":
+    cdef cppclass OctreeLeafNodeIterator[OctreeT](OctreeDepthFirstIterator[OctreeT]):
+        OctreeLeafNodeIterator()
+        # explicit OctreeLeafNodeIterator (OctreeT& octree_arg)
+        # typedef typename OctreeDepthFirstIterator<DataT, OctreeT>::BranchNode BranchNode;
+        # typedef typename OctreeDepthFirstIterator<DataT, OctreeT>::LeafNode LeafNode;
+        # public:
+        # /** \brief Constructor.
+        #  * \param[in] octree_arg Octree to be iterated. Initially the iterator is set to its root node.
+        # /** \brief Reset the iterator to the root node of the octree
+        # inline void reset ()
+        # /** \brief Preincrement operator.
+        #  * \note recursively step to next octree leaf node
+        # inline OctreeLeafNodeIterator& operator++ ()
+        # /** \brief postincrement operator.
+        #  * \note step to next octree node
+        # inline OctreeLeafNodeIterator operator++ (int)
+        # /** \brief *operator.
+        #  * \return pointer to the current octree leaf node
+        # OctreeNode* operator* () const
+
+
+###
+
+# octree_key.h
+# namespace pcl
+# namespace octree
+# class OctreeKey
+cdef extern from "pcl/octree/octree_key.h" namespace "pcl::octree":
+    cdef cppclass OctreeKey:
+        OctreeKey()
+        # OctreeKey (unsigned int keyX, unsigned int keyY, unsigned int keyZ) :
+        # OctreeKey (const OctreeKey& source) :
+        # public:
+        # /** \brief Operator== for comparing octree keys with each other.
+        # *  \return "true" if leaf node indices are identical; "false" otherwise.
+        # bool operator == (const OctreeKey& b) const
+        # /** \brief Operator<= for comparing octree keys with each other.
+        # *  \return "true" if key indices are not greater than the key indices of b  ; "false" otherwise.
+        # bool operator <= (const OctreeKey& b) const
+        # /** \brief Operator>= for comparing octree keys with each other.
+        # *  \return "true" if key indices are not smaller than the key indices of b  ; "false" otherwise.
+        # bool operator >= (const OctreeKey& b) const
+        # /** \brief push a child node to the octree key
+        # *  \param[in] childIndex index of child node to be added (0-7)
+        # */
+        # inline void pushBranch (unsigned char childIndex)
+        # /** \brief pop child node from octree key
+        # inline void popBranch ()
+        # /** \brief get child node index using depthMask
+        # *  \param[in] depthMask bit mask with single bit set at query depth
+        # *  \return child node index
+        # * */
+        # inline unsigned char getChildIdxWithDepthMask (unsigned int depthMask) const
+        # // Indices addressing a voxel at (X, Y, Z)
+        # unsigned int x;
+        # unsigned int y;
+        # unsigned int z;
+###
+
+# pcl 1.7.2/1.8.0 nothing
+# octree_node_pool.h
+# namespace pcl
+# namespace octree
+# template<typename NodeT>
+# class OctreeNodePool
+# cdef extern from "pcl/octree/octree_node_pool.h" namespace "pcl::octree":
+#     cdef cppclass OctreeNodePool[NodeT]:
+#         OctreeNodePool()
+#         # public:
+#         # /** \brief Push node to pool
+#         # *  \param childIdx_arg: pointer of noe
+#         # inline void pushNode (NodeT* node_arg)
+#         # /** \brief Pop node from pool - Allocates new nodes if pool is empty
+#         # *  \return Pointer to octree node
+#         # inline NodeT* popNode ()
+#         # /** \brief Delete all nodes in pool
+#         # */
+#         # void deletePool ()
+#         # protected:
+#         # vector<NodeT*> nodePool_;
+###
+
+# NG
+# octree_nodes.h
+# namespace pcl
+# namespace octree
+#     // enum of node types within the octree
+#     enum node_type_t
+#     {
+#       BRANCH_NODE, LEAF_NODE
+#     };
+##
+# namespace pcl
+# namespace octree
+# class PCL_EXPORTS OctreeNode
+#       public:
+#       OctreeNode ()
+#       /** \brief Pure virtual method for receiving the type of octree node (branch or leaf)  */
+#       virtual node_type_t getNodeType () const = 0;
+#       /** \brief Pure virtual method to perform a deep copy of the octree */
+#       virtual OctreeNode* deepCopy () const = 0;
+##
+# template<typename ContainerT>
+# class OctreeLeafNode : public OctreeNode, public ContainerT
+# cdef cppclass OctreeLeafNode[ContainerT](OctreeNode)(ContainerT):
+# cdef extern from "pcl/octree/octree_nodes.h" namespace "pcl::octree":
+#     cdef cppclass OctreeLeafNode[ContainerT]:
+#         OctreeLeafNode()
+#         # OctreeLeafNode (const OctreeLeafNode& source) :
+#         # public:
+#         # using ContainerT::getSize;
+#         # using ContainerT::getData;
+#         # using ContainerT::setData;
+#         # /** \brief Method to perform a deep copy of the octree */
+#         # virtual OctreeLeafNode<ContainerT>* deepCopy () const
+#         # /** \brief Get the type of octree node. Returns LEAVE_NODE type */
+#         # virtual node_type_t getNodeType () const
+#         # /** \brief Reset node */
+#         # inline void reset ()
+###
+# # template<typename ContainerT>
+# # class OctreeBranchNode : public OctreeNode, ContainerT
+# # cdef extern from "pcl/octree/octree_nodes.h" namespace "pcl::octree":
+# #     cdef cppclass OctreeBranchNode[ContainerT]:
+# #         OctreeBranchNode()
+#         # OctreeBranchNode (const OctreeBranchNode& source)
+#         # inline OctreeBranchNode& operator = (const OctreeBranchNode &source)
+#         # public:
+#         # using ContainerT::getSize;
+#         # using ContainerT::getData;
+#         # using ContainerT::setData;
+#         # /** \brief Octree deep copy method */
+#         # virtual OctreeBranchNode* deepCopy () const
+#         # inline void reset ()
+#         # /** \brief Access operator.
+#         #  *  \param childIdx_arg: index to child node
+#         #  *  \return OctreeNode pointer
+#         #  * */
+#         # inline OctreeNode*& operator[] (unsigned char childIdx_arg)
+#         # /** \brief Get pointer to child
+#         #  *  \param childIdx_arg: index to child node
+#         #  *  \return OctreeNode pointer
+#         #  * */
+#         # inline OctreeNode* getChildPtr (unsigned char childIdx_arg) const
+#         # /** \brief Get pointer to child
+#         #  *  \return OctreeNode pointer
+#         #  * */
+#         # inline void setChildPtr (OctreeNode* child, unsigned char index)
+#         # /** \brief Check if branch is pointing to a particular child node
+#         #  *  \param childIdx_arg: index to child node
+#         #  *  \return "true" if pointer to child node exists; "false" otherwise
+#         #  * */
+#         # inline bool hasChild (unsigned char childIdx_arg) const
+#         # /** \brief Get the type of octree node. Returns LEAVE_NODE type */
+#         # virtual node_type_t getNodeType () const
+#         # protected:
+#         # OctreeNode* childNodeArray_[8];
+###
+
+# octree_pointcloud.h
+# namespace pcl
+# namespace octree
+# template<typename PointT, typename LeafT = OctreeContainerPointIndices,
+#       typename BranchT = OctreeContainerEmpty,
+#       typename OctreeT = OctreeBase<LeafT, BranchT> >
+# class OctreePointCloud : public OctreeT
+cdef extern from "pcl/octree/octree_pointcloud.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloud[PointT, LeafT, BranchT, OctreeT]:
+        OctreePointCloud(const double resolution_arg)
+        # OctreePointCloud(double resolution_arg)
+        
+        # // iterators are friends
+        # friend class OctreeIteratorBase<int, OctreeT> ;
+        # friend class OctreeDepthFirstIterator<int, OctreeT> ;
+        # friend class OctreeBreadthFirstIterator<int, OctreeT> ;
+        # friend class OctreeLeafNodeIterator<int, OctreeT> ;
+        # public:
+        # typedef OctreeT Base;
+        # typedef typename OctreeT::LeafNode LeafNode;
+        # typedef typename OctreeT::BranchNode BranchNode;
+        # // Octree iterators
+        # typedef OctreeDepthFirstIterator<int, OctreeT> Iterator;
+        # typedef const OctreeDepthFirstIterator<int, OctreeT> ConstIterator;
+        # typedef OctreeLeafNodeIterator<int, OctreeT> LeafNodeIterator;
+        # typedef const OctreeLeafNodeIterator<int, OctreeT> ConstLeafNodeIterator;
+        # typedef OctreeDepthFirstIterator<int, OctreeT> DepthFirstIterator;
+        # typedef const OctreeDepthFirstIterator<int, OctreeT> ConstDepthFirstIterator;
+        # typedef OctreeBreadthFirstIterator<int, OctreeT> BreadthFirstIterator;
+        # typedef const OctreeBreadthFirstIterator<int, OctreeT> ConstBreadthFirstIterator;
+        # /** \brief Octree pointcloud constructor.
+        #  * \param[in] resolution_arg octree resolution at lowest octree level
+        # // public typedefs
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # // public typedefs for single/double buffering
+        # typedef OctreePointCloud<PointT, LeafT, OctreeBase<int, LeafT> > SingleBuffer;
+        # typedef OctreePointCloud<PointT, LeafT, Octree2BufBase<int, LeafT> > DoubleBuffer;
+        # // Boost shared pointers
+        # typedef boost::shared_ptr<OctreePointCloud<PointT, LeafT, OctreeT> > Ptr;
+        # typedef boost::shared_ptr<const OctreePointCloud<PointT, LeafT, OctreeT> > ConstPtr;
+        # // Eigen aligned allocator
+        # typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        # 
+        # /** \brief Provide a pointer to the input data set.
+        #  * \param[in] cloud_arg the const boost shared pointer to a PointCloud message
+        #  * \param[in] indices_arg the point indices subset that is to be used from \a cloud - if 0 the whole point cloud is used
+        #  */
+        # inline void setInputCloud (const PointCloudConstPtr &cloud_arg, const IndicesConstPtr &indices_arg = IndicesConstPtr ())
+        void setInputCloud (shared_ptr[cpp.PointCloud[PointT]])
+        # void setInputCloud (const shared_ptr[cpp.PointCloud] &cloud_arg, const shared_ptr[const vector[int]] &indices_ar)
+        
+        # /** \brief Get a pointer to the vector of indices used.
+        #  * \return pointer to vector of indices used.
+        #  */
+        # inline IndicesConstPtr const getIndices () const
+        const shared_ptr[const vector[int]] getIndices ()
+        
+        # /** \brief Get a pointer to the input point cloud dataset.
+        #  * \return pointer to pointcloud input class.
+        #  */
+        # inline PointCloudConstPtr getInputCloud () const
+        # PointCloudConstPtr getInputCloud () const
+        shared_ptr[const cpp.PointCloud[PointT]] getInputCloud ()
+        
+        # /** \brief Set the search epsilon precision (error bound) for nearest neighbors searches.
+        #  * \param[in] eps precision (error bound) for nearest neighbors searches
+        #  */
+        # inline void setEpsilon (double eps)
+        void setEpsilon (double eps)
+        
+        # /** \brief Get the search epsilon precision (error bound) for nearest neighbors searches. */
+        # inline double getEpsilon () const
+        double getEpsilon () const
+        
+        # /** \brief Set/change the octree voxel resolution
+        #  * \param[in] resolution_arg side length of voxels at lowest tree level
+        #  */
+        # inline void setResolution (double resolution_arg)
+        void setResolution (double resolution_arg)
+        
+        # /** \brief Get octree voxel resolution
+        #  * \return voxel resolution at lowest tree level
+        #  */
+        # inline double getResolution () const
+        double getResolution () const
+        
+        # \brief Get the maximum depth of the octree.
+        # \return depth_arg: maximum depth of octree
+        # inline unsigned int getTreeDepth () const
+        unsigned int getTreeDepth ()
+        
+        # brief Add points from input point cloud to octree.
+        # void addPointsFromInputCloud ();
+        void addPointsFromInputCloud ()
+        
+        # \brief Add point at given index from input point cloud to octree. Index will be also added to indices vector.
+        # \param[in] pointIdx_arg index of point to be added
+        # \param[in] indices_arg pointer to indices vector of the dataset (given by \a setInputCloud)
+        # void addPointFromCloud (const int pointIdx_arg, IndicesPtr indices_arg);
+        void addPointFromCloud (const int pointIdx_arg, shared_ptr[vector[int]] indices_arg)
+        
+        # \brief Add point simultaneously to octree and input point cloud.
+        # \param[in] point_arg point to be added
+        # \param[in] cloud_arg pointer to input point cloud dataset (given by \a setInputCloud)
+        # void addPointToCloud (const PointT& point_arg, PointCloudPtr cloud_arg);
+        void addPointToCloud (const PointT& point_arg, shared_ptr[cpp.PointCloud[PointT]] cloud_arg)
+        
+        # \brief Add point simultaneously to octree and input point cloud. A corresponding index will be added to the indices vector.
+        # \param[in] point_arg point to be added
+        # \param[in] cloud_arg pointer to input point cloud dataset (given by \a setInputCloud)
+        # \param[in] indices_arg pointer to indices vector of the dataset (given by \a setInputCloud)
+        # void addPointToCloud (const PointT& point_arg, PointCloudPtr cloud_arg, IndicesPtr indices_arg);
+        void addPointToCloud (const PointT& point_arg, shared_ptr[cpp.PointCloud[PointT]] cloud_arg, shared_ptr[vector[int]] indices_arg)
+        
+        # \brief Check if voxel at given point exist.
+        # \param[in] point_arg point to be checked
+        # \return "true" if voxel exist; "false" otherwise
+        # bool isVoxelOccupiedAtPoint (const PointT& point_arg) const;
+        # bool isVoxelOccupiedAtPoint (const PointT& point_arg)
+        
+        # \brief Delete the octree structure and its leaf nodes.
+        # \param freeMemory_arg: if "true", allocated octree nodes are deleted, otherwise they are pushed to the octree node pool
+        # void deleteTree (bool freeMemory_arg = false)
+        void deleteTree()
+        # void deleteTree (bool freeMemory_arg)
+        
+        # \brief Check if voxel at given point coordinates exist.
+        # \param[in] pointX_arg X coordinate of point to be checked
+        # \param[in] pointY_arg Y coordinate of point to be checked
+        # \param[in] pointZ_arg Z coordinate of point to be checked
+        # \return "true" if voxel exist; "false" otherwise
+        # bool isVoxelOccupiedAtPoint (const double pointX_arg, const double pointY_arg, const double pointZ_arg) const;
+        # bool isVoxelOccupiedAtPoint(double, double, double)
+        bool isVoxelOccupiedAtPoint (const double pointX_arg, const double pointY_arg, const double pointZ_arg)
+        
+        # \brief Check if voxel at given point from input cloud exist.
+        # \param[in] pointIdx_arg point to be checked
+        # \return "true" if voxel exist; "false" otherwise
+        # bool isVoxelOccupiedAtPoint (const int& pointIdx_arg) const;
+        # bool isVoxelOccupiedAtPoint (const int& pointIdx_arg)
+        
+        # \brief Get a T vector of centers of all occupied voxels.
+        # \param[out] voxelCenterList_arg results are written to this vector of T elements
+        # \return number of occupied voxels
+        # int getOccupiedVoxelCenters (vector2[PointT, eig.aligned_allocator[PointT]] &voxelCenterList_arg) const;
+        # int getOccupiedVoxelCenters(vector2[PointT, eig.aligned_allocator[PointT]])
+        int getOccupiedVoxelCenters (vector2[PointT, eig.aligned_allocator[PointT]] &voxelCenterList_arg)
+        
+        # \brief Get a T vector of centers of voxels intersected by a line segment.
+        #  This returns a approximation of the actual intersected voxels by walking
+        #  along the line with small steps. Voxels are ordered, from closest to
+        #  furthest w.r.t. the origin.
+        # \param[in] origin origin of the line segment
+        # \param[in] end end of the line segment
+        # \param[out] voxel_center_list results are written to this vector of T elements
+        # \param[in] precision determines the size of the steps: step_size = octree_resolution x precision
+        # \return number of intersected voxels
+        # int getApproxIntersectedVoxelCentersBySegment (const Eigen::Vector3f& origin, const Eigen::Vector3f& end, AlignedPointTVector &voxel_center_list, float precision = 0.2);
+        int getApproxIntersectedVoxelCentersBySegment (const eig.Vector3f& origin, const eig.Vector3f& end, vector2[PointT, eig.aligned_allocator[PointT]] &voxel_center_list, float precision)
+        
+        # \brief Delete leaf node / voxel at given point
+        # \param[in] point_arg point addressing the voxel to be deleted.
+        # void deleteVoxelAtPoint(const PointT& point_arg);
+        # void deleteVoxelAtPoint(PointT point)
+        void deleteVoxelAtPoint (const PointT& point_arg)
+        
+        # \brief Delete leaf node / voxel at given point from input cloud
+        # \param[in] pointIdx_arg index of point addressing the voxel to be deleted.
+        # void deleteVoxelAtPoint (const int& pointIdx_arg);
+        void deleteVoxelAtPoint (const int& pointIdx_arg)
+        
+        # Bounding box methods
+        # \brief Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. */
+        # void defineBoundingBox ();
+        void defineBoundingBox ()
+        
+        # \brief Define bounding box for octree
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] minX_arg X coordinate of lower bounding box corner
+        # \param[in] minY_arg Y coordinate of lower bounding box corner
+        # \param[in] minZ_arg Z coordinate of lower bounding box corner
+        # \param[in] maxX_arg X coordinate of upper bounding box corner
+        # \param[in] maxY_arg Y coordinate of upper bounding box corner
+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner
+        # void defineBoundingBox (const double minX_arg, const double minY_arg, const double minZ_arg, const double maxX_arg, const double maxY_arg, const double maxZ_arg);
+        # void defineBoundingBox(double, double, double, double, double, double)
+        void defineBoundingBox (const double minX_arg, const double minY_arg, const double minZ_arg, const double maxX_arg, const double maxY_arg, const double maxZ_arg)
+        
+        # \brief Define bounding box for octree
+        # \note Lower bounding box point is set to (0, 0, 0)
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] maxX_arg X coordinate of upper bounding box corner
+        # \param[in] maxY_arg Y coordinate of upper bounding box corner
+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner
+        # void defineBoundingBox (const double maxX_arg, const double maxY_arg, const double maxZ_arg);
+        # void defineBoundingBox (const double maxX_arg, const double maxY_arg, const double maxZ_arg)
+        
+        # \brief Define bounding box cube for octree
+        # \note Lower bounding box corner is set to (0, 0, 0)
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] cubeLen_arg side length of bounding box cube.
+        # void defineBoundingBox (const double cubeLen_arg);
+        # void defineBoundingBox (const double cubeLen_arg)
+        
+        # \brief Get bounding box for octree
+        # \note Bounding box cannot be changed once the octree contains elements.
+        # \param[in] minX_arg X coordinate of lower bounding box corner
+        # \param[in] minY_arg Y coordinate of lower bounding box corner
+        # \param[in] minZ_arg Z coordinate of lower bounding box corner
+        # \param[in] maxX_arg X coordinate of upper bounding box corner
+        # \param[in] maxY_arg Y coordinate of upper bounding box corner
+        # \param[in] maxZ_arg Z coordinate of upper bounding box corner
+        # void getBoundingBox (double& minX_arg, double& minY_arg, double& minZ_arg, double& maxX_arg, double& maxY_arg, double& maxZ_arg) const;
+        void getBoundingBox (double& minX_arg, double& minY_arg, double& minZ_arg, double& maxX_arg, double& maxY_arg, double& maxZ_arg)
+        
+        # \brief Calculates the squared diameter of a voxel at given tree depth
+        # \param[in] treeDepth_arg depth/level in octree
+        # \return squared diameter
+        # double getVoxelSquaredDiameter (unsigned int treeDepth_arg) const;
+        double getVoxelSquaredDiameter (unsigned int treeDepth_arg)
+        
+        # \brief Calculates the squared diameter of a voxel at leaf depth
+        # \return squared diameter
+        # inline double getVoxelSquaredDiameter () const
+        double getVoxelSquaredDiameter ()
+        
+        # \brief Calculates the squared voxel cube side length at given tree depth
+        # \param[in] treeDepth_arg depth/level in octree
+        # \return squared voxel cube side length
+        # double getVoxelSquaredSideLen (unsigned int treeDepth_arg) const;
+        double getVoxelSquaredSideLen (unsigned int treeDepth_arg)
+        
+        # \brief Calculates the squared voxel cube side length at leaf level
+        # \return squared voxel cube side length
+        # inline double getVoxelSquaredSideLen () const
+        double getVoxelSquaredSideLen ()
+        
+        # \brief Generate bounds of the current voxel of an octree iterator
+        # \param[in] iterator: octree iterator
+        # \param[out] min_pt lower bound of voxel
+        # \param[out] max_pt upper bound of voxel
+        # inline void getVoxelBounds (OctreeIteratorBase<int, OctreeT>& iterator, Eigen::Vector3f &min_pt, Eigen::Vector3f &max_pt)
+        void getVoxelBounds (OctreeIteratorBase[OctreeT]& iterator, eig.Vector3f &min_pt, eig.Vector3f &max_pt)
+
+
+ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_t
+ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZI_t
+ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGB_t
+ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t] OctreePointCloud_PointXYZRGBA_t
+ctypedef OctreePointCloud[cpp.PointXYZ, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_t
+ctypedef OctreePointCloud[cpp.PointXYZI, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZI_t
+ctypedef OctreePointCloud[cpp.PointXYZRGB, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGB_t
+ctypedef OctreePointCloud[cpp.PointXYZRGBA, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t] OctreePointCloud2Buf_PointXYZRGBA_t
+###
+
+# namespace pcl
+# namespace octree
+# pcl_1.7.2 use octree_pointcloud_changedetector.h
+# pcl 1.7.2 Template Changed(OctreeContainerDataTVector to OctreeContainerPointIndices)
+# template<typename PointT,
+#         typename LeafContainerT = OctreeContainerPointIndices,
+#         typename BranchContainerT = OctreeContainerEmpty >
+cdef extern from "pcl/octree/octree_pointcloud_changedetector.h" namespace "pcl::octree":
+    # pcl version 1.7.2
+    cdef cppclass OctreePointCloudChangeDetector[PointT](OctreePointCloud[PointT, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, Octree2BufBase_OctreeContainerPointIndices_t]):
+        OctreePointCloudChangeDetector (const double resolution_arg)
+        # public:
+        # \brief Get a indices from all leaf nodes that did not exist in previous buffer.
+        # \param indicesVector_arg: results are written to this vector of int indices
+        # \param minPointsPerLeaf_arg: minimum amount of points required within leaf node to become serialized.
+        # \return number of point indices
+        # int getPointIndicesFromNewVoxels (std::vector<int> &indicesVector_arg, const int minPointsPerLeaf_arg = 0)
+        int getPointIndicesFromNewVoxels (vector[int] &indicesVector_arg, const int minPointsPerLeaf_arg)
+
+
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZ] OctreePointCloudChangeDetector_t
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZI] OctreePointCloudChangeDetector_PointXYZI_t
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGB] OctreePointCloudChangeDetector_PointXYZRGB_t
+ctypedef OctreePointCloudChangeDetector[cpp.PointXYZRGBA] OctreePointCloudChangeDetector_PointXYZRGBA_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZ]] OctreePointCloudChangeDetectorPtr_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZI]] OctreePointCloudChangeDetector_PointXYZI_Ptr_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGB]] OctreePointCloudChangeDetector_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[OctreePointCloudChangeDetector[cpp.PointXYZRGBA]] OctreePointCloudChangeDetector_PointXYZRGBA_Ptr_t
+###
+
+# octree_pointcloud_density.h
+# namespace pcl
+# namespace octree
+# template<typename PointT, typename LeafContainerT = OctreePointCloudDensityContainer, typename BranchContainerT = OctreeContainerEmpty >
+# class OctreePointCloudDensity : public OctreePointCloud<PointT, LeafContainerT, BranchContainerT>
+cdef extern from "pcl/octree/octree_pointcloud_density.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloudDensity[PointT](OctreePointCloud[PointT, OctreePointCloudDensityContainer_t, OctreeContainerEmpty_t, OctreeBase_OctreePointCloudDensity_t]):
+        OctreePointCloudDensity (const double resolution_arg)
+        # /** \brief Get the amount of points within a leaf node voxel which is addressed by a point
+        #   * \param[in] point_arg: a point addressing a voxel
+        #   * \return amount of points that fall within leaf node voxel
+        #   */
+        # unsigned int getVoxelDensityAtPoint (const PointT& point_arg) const
+
+
+ctypedef OctreePointCloudDensity[cpp.PointXYZ] OctreePointCloudDensity_t
+ctypedef OctreePointCloudDensity[cpp.PointXYZI] OctreePointCloudDensity_PointXYZI_t
+ctypedef OctreePointCloudDensity[cpp.PointXYZRGB] OctreePointCloudDensity_PointXYZRGB_t
+ctypedef OctreePointCloudDensity[cpp.PointXYZRGBA] OctreePointCloudDensity_PointXYZRGBA_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZ]] OctreePointCloudDensityPtr_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZI]] OctreePointCloudDensity_PointXYZI_Ptr_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGB]] OctreePointCloudDensity_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[OctreePointCloudDensity[cpp.PointXYZRGBA]] OctreePointCloudDensity_PointXYZRGBA_Ptr_t
+###
+
+# octree_pointcloud_occupancy.h
+###
+
+# octree_pointcloud_pointvector.h
+###
+
+# octree_pointcloud_singlepoint.h
+###
+
+# octree_pointcloud_voxelcentroid.h
+###
+
+# octree_search.h
+cdef extern from "pcl/octree/octree_search.h" namespace "pcl::octree":
+    cdef cppclass OctreePointCloudSearch[PointT](OctreePointCloud[PointT, OctreeContainerPointIndices_t, OctreeContainerEmpty_t, OctreeBase_OctreeContainerPointIndices_t]):
+        OctreePointCloudSearch (const double resolution_arg)
+        # int radiusSearch (cpp.PointXYZ, double, vector[int], vector[float], unsigned int)
+        # int radiusSearch (cpp.PointXYZI, double, vector[int], vector[float], unsigned int)
+        # int radiusSearch (cpp.PointXYZRGB, double, vector[int], vector[float], unsigned int)
+        # int radiusSearch (cpp.PointXYZRGBA, double, vector[int], vector[float], unsigned int)
+        # PointT
+        int radiusSearch (PointT, double, vector[int], vector[float], unsigned int)
+        
+        # Add index(inline?)
+        int radiusSearch (cpp.PointCloud[PointT], int, double, vector[int], vector[float], unsigned int)
+        
+        # inline define
+        # int nearestKSearch (cpp.PointCloud[PointT], int, int, vector[int], vector[float])
+        int nearestKSearch (cpp.PointCloud[PointT], int, int, vector[int], vector[float])
+        
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        # int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        ## Functions
+        # brief Search for neighbors within a voxel at given point
+        # param[in] point point addressing a leaf node voxel
+        # param[out] point_idx_data the resultant indices of the neighboring voxel points
+        # return "true" if leaf node exist; "false" otherwise
+        # bool voxelSearch (const PointT& point, std::vector<int>& point_idx_data);
+        bool voxelSearch (const PointT& point, vector[int] point_idx_data)
+        
+        # brief Search for neighbors within a voxel at given point referenced by a point index
+        # param[in] index the index in input cloud defining the query point
+        # param[out] point_idx_data the resultant indices of the neighboring voxel points
+        # return "true" if leaf node exist; "false" otherwise
+        # bool voxelSearch (const int index, std::vector<int>& point_idx_data);
+        bool voxelSearch (const int index, vector[int] point_idx_data)
+        
+        # brief Search for approx. nearest neighbor at the query point.
+        # param[in] cloud the point cloud data
+        # param[in] query_index the index in \a cloud representing the query point
+        # param[out] result_index the resultant index of the neighbor point
+        # param[out] sqr_distance the resultant squared distance to the neighboring point
+        # return number of neighbors found
+        # 
+        # inline void approxNearestSearch (const PointCloud &cloud, int query_index, int &result_index, float &sqr_distance)
+        approxNearestSearch (const cpp.PointCloud[PointT] &cloud, int query_index, int &result_index, float &sqr_distance)
+        
+        # /** \brief Search for approx. nearest neighbor at the query point.
+        #   * \param[in] p_q the given query point
+        #   * \param[out] result_index the resultant index of the neighbor point
+        #   * \param[out] sqr_distance the resultant squared distance to the neighboring point
+        #   */
+        # void approxNearestSearch (const PointT &p_q, int &result_index, float &sqr_distance);
+        void approxNearestSearch (const PointT &p_q, int &result_index, float &sqr_distance)
+        
+        # /** \brief Search for approx. nearest neighbor at the query point.
+        #   * \param[in] query_index index representing the query point in the dataset given by \a setInputCloud.
+        #   *        If indices were given in setInputCloud, index will be the position in the indices vector.
+        #   * \param[out] result_index the resultant index of the neighbor point
+        #   * \param[out] sqr_distance the resultant squared distance to the neighboring point
+        #   * \return number of neighbors found
+        #   */
+        # void approxNearestSearch (int query_index, int &result_index, float &sqr_distance);
+        void approxNearestSearch (int query_index, int &result_index, float &sqr_distance)
+        
+        # /** \brief Get a PointT vector of centers of all voxels that intersected by a ray (origin, direction).
+        #   * \param[in] origin ray origin
+        #   * \param[in] direction ray direction vector
+        #   * \param[out] voxel_center_list results are written to this vector of PointT elements
+        #   * \param[in] max_voxel_count stop raycasting when this many voxels intersected (0: disable)
+        #   * \return number of intersected voxels
+        #  */
+        # int getIntersectedVoxelCenters (Eigen::Vector3f origin, Eigen::Vector3f direction, AlignedPointTVector &voxel_center_list, int max_voxel_count = 0) const;
+        # int getIntersectedVoxelCenters (eig.Vector3f origin, eig.Vector3f direction, AlignedPointTVector &voxel_center_list, int max_voxel_count = 0) const;
+        
+        # /** \brief Get indices of all voxels that are intersected by a ray (origin, direction).
+        #   * \param[in] origin ray origin
+        #   * \param[in] direction ray direction vector
+        #   * \param[out] k_indices resulting point indices from intersected voxels
+        #   * \param[in] max_voxel_count stop raycasting when this many voxels intersected (0: disable)
+        #  * \return number of intersected voxels
+        #  */
+        # int getIntersectedVoxelIndices (Eigen::Vector3f origin, Eigen::Vector3f direction, std::vector<int> &k_indices, int max_voxel_count = 0) const; 
+        int getIntersectedVoxelIndices (eig.Vector3f origin, eig.Vector3f direction, vector[int] &k_indices, int max_voxel_count)
+        
+        # /** \brief Search for points within rectangular search area
+        #  * \param[in] min_pt lower corner of search area
+        #  * \param[in] max_pt upper corner of search area
+        #  * \param[out] k_indices the resultant point indices
+        #  * \return number of points found within search area
+        #  */
+        # int boxSearch (const Eigen::Vector3f &min_pt, const Eigen::Vector3f &max_pt, std::vector<int> &k_indices) const;
+        int boxSearch (const eig.Vector3f &min_pt, const eig.Vector3f &max_pt, vector[int] &k_indices)
+
+
+ctypedef OctreePointCloudSearch[cpp.PointXYZ] OctreePointCloudSearch_t
+ctypedef OctreePointCloudSearch[cpp.PointXYZI] OctreePointCloudSearch_PointXYZI_t
+ctypedef OctreePointCloudSearch[cpp.PointXYZRGB] OctreePointCloudSearch_PointXYZRGB_t
+ctypedef OctreePointCloudSearch[cpp.PointXYZRGBA] OctreePointCloudSearch_PointXYZRGBA_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZ]] OctreePointCloudSearchPtr_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZI]] OctreePointCloudSearch_PointXYZI_Ptr_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGB]] OctreePointCloudSearch_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[OctreePointCloudSearch[cpp.PointXYZRGBA]] OctreePointCloudSearch_PointXYZRGBA_Ptr_t
+###
+
+
+# 1.7.2 Add headers
+# octree2buf_base.h
+# octree_pointcloud_adjacency.h
+# octree_pointcloud_adjacency_container.h
+# octree_pointcloud_changedetector.h
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
+
+
diff --git a/pcl/pcl_outofcore_172.pxd b/pcl/pcl_outofcore_172.pxd
new file mode 100644
index 0000000..f3ad63a
--- /dev/null
+++ b/pcl/pcl_outofcore_172.pxd
@@ -0,0 +1,1581 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+
+###############################################################################
+# Types
+###############################################################################
+
+# # visualization
+# # axis.h
+# class Axes : public Object
+# {
+# public:
+    # 
+    # // Operators
+    # Axes (std::string name, float size = 1.0) : Object (name)
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkAxes> getAxes () const
+    # 
+    # vtkSmartPointer<vtkActor> getAxesActor () const
+
+
+###
+
+# # camera.h
+# class Camera : public Object
+# {
+# public:
+    # // Operators
+    # Camera (std::string name);
+    # Camera (std::string name, vtkSmartPointer<vtkCamera> camera);
+    # 
+    # public:
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkCamera> getCamera () const
+    # 
+    # inline vtkSmartPointer<vtkCameraActor> getCameraActor () const
+    # 
+    # inline vtkSmartPointer<vtkActor> getHullActor () const
+    # 
+    # inline bool getDisplay () const
+    # 
+    # void setDisplay (bool display)
+    # 
+    # void getFrustum (double frustum[])
+    # 
+    # void setProjectionMatrix (const Eigen::Matrix4d &projection_matrix)
+    # 
+    # Eigen::Matrix4d getProjectionMatrix ()
+    # 
+    # void setModelViewMatrix (const Eigen::Matrix4d &model_view_matrix)
+    # 
+    # Eigen::Matrix4d getModelViewMatrix ()
+    # 
+    # Eigen::Matrix4d getViewProjectionMatrix ()
+    # 
+    # Eigen::Vector3d getPosition ()
+    # 
+    # inline void setClippingRange (float near_value = 0.0001f, float far_value = 100000.f)
+    # 
+    # virtual void render (vtkRenderer* renderer);
+    # 
+    # // Methods
+    # void computeFrustum ();
+    # void printFrustum ();
+
+
+###
+
+# common.h
+###
+
+# geometry.h
+# class Geometry : public Object
+# {
+    # protected:
+    # 
+    # // Operators
+    # // -----------------------------------------------------------------------------
+    # Geometry (std::string name) : Object (name)
+    # 
+    # 
+    # public:
+    # virtual ~Geometry () { }
+    # 
+    # public:
+    # // Accessors
+    # virtual vtkSmartPointer<vtkActor> getActor () const
+
+
+###
+
+# grid.h
+# //class Grid : public Geometry
+# class Grid : public Object
+# {
+    # public:
+    # 
+    # // Operators
+    # Grid (std::string name, int size = 10, double spacing = 1.0);
+    # ~Grid () { }
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkRectilinearGrid> getGrid () const
+    # 
+    # vtkSmartPointer<vtkActor> getGridActor () const
+
+
+###
+
+
+# # object.h
+# class Object
+# {
+    # public:
+    # 
+    # // Operators
+    # Object (std::string name);
+    # 
+    # virtual ~Object () { }
+    # 
+    # 
+    # // Accessors
+    # std::string getName () const;
+    # 
+    # void setName (std::string name);
+    # 
+    # virtual void render (vtkRenderer* renderer);
+    # 
+    # bool hasActor (vtkActor *actor);
+    # 
+    # void addActor (vtkActor *actor);
+    # 
+    # void removeActor (vtkActor *actor);
+    # 
+    # vtkSmartPointer<vtkActorCollection> getActors ();
+    # 
+
+
+###
+
+
+# outofcore_cloud.h
+# class OutofcoreCloud : public Object
+# {
+    # // Typedefs
+    # // -----------------------------------------------------------------------------
+    # typedef pcl::PointXYZ PointT;
+    # //    typedef pcl::outofcore::OutofcoreOctreeBase<pcl::outofcore::OutofcoreOctreeDiskContainer<PointT>, PointT> octree_disk;
+    # //    typedef pcl::outofcore::OutofcoreOctreeBaseNode<pcl::outofcore::OutofcoreOctreeDiskContainer<PointT>, PointT> octree_disk_node;
+    # 
+    # typedef pcl::outofcore::OutofcoreOctreeBase<> OctreeDisk;
+    # typedef pcl::outofcore::OutofcoreOctreeBaseNode<> OctreeDiskNode;
+    # //    typedef pcl::outofcore::OutofcoreBreadthFirstIterator<> OctreeBreadthFirstIterator;
+    # 
+    # typedef boost::shared_ptr<OctreeDisk> OctreeDiskPtr;
+    # typedef Eigen::aligned_allocator<PointT> AlignedPointT;
+    # 
+    # typedef std::map<std::string, vtkSmartPointer<vtkActor> > CloudActorMap;
+    # 
+    # public:
+    # 
+    # //    typedef std::map<std::string, vtkSmartPointer<vtkPolyData> > CloudDataCache;
+    # //    typedef std::map<std::string, vtkSmartPointer<vtkPolyData> >::iterator CloudDataCacheIterator;
+    # 
+    # static boost::shared_ptr<boost::thread> pcd_reader_thread;
+    # //static MonitorQueue<std::string> pcd_queue;
+    # 
+    # struct PcdQueueItem
+    # {
+        # PcdQueueItem (std::string pcd_file, float coverage)
+        # 
+        # bool operator< (const PcdQueueItem& rhs) const
+        # 
+        # std::string pcd_file;
+        # float coverage;
+    # };
+    # 
+    # typedef std::priority_queue<PcdQueueItem> PcdQueue;
+    # static PcdQueue pcd_queue;
+    # static boost::mutex pcd_queue_mutex;
+    # static boost::condition pcd_queue_ready;
+    # 
+    # 
+    # 
+    # class CloudDataCacheItem : public LRUCacheItem< vtkSmartPointer<vtkPolyData> >
+    # {
+        # public:
+        # 
+        # CloudDataCacheItem (std::string pcd_file, float coverage, vtkSmartPointer<vtkPolyData> cloud_data, size_t timestamp)
+        # 
+        # virtual size_t sizeOf() const
+        # 
+        # std::string pcd_file;
+        # float coverage;
+    # };
+    # 
+    # 
+    # //    static CloudDataCache cloud_data_map;
+    # //    static boost::mutex cloud_data_map_mutex;
+    # typedef LRUCache<std::string, CloudDataCacheItem> CloudDataCache;
+    # static CloudDataCache cloud_data_cache;
+    # static boost::mutex cloud_data_cache_mutex;
+    # 
+    # static void pcdReaderThread();
+    # 
+    # // Operators
+    # OutofcoreCloud (std::string name, boost::filesystem::path& tree_root);
+    # 
+    # // Methods
+    # void updateVoxelData ();
+    # 
+    # // Accessors
+    # OctreeDiskPtr getOctree ()
+    # 
+    # inline vtkSmartPointer<vtkActor> getVoxelActor () const
+    # 
+    # inline vtkSmartPointer<vtkActorCollection> getCloudActors () const
+    # 
+    # 
+    # void setDisplayDepth (int displayDepth)
+    # 
+    # int getDisplayDepth ()
+    # 
+    # uint64_t getPointsLoaded ()
+    # 
+    # uint64_t getDataLoaded ()
+    # 
+    # Eigen::Vector3d getBoundingBoxMin ()
+    # 
+    # Eigen::Vector3d getBoundingBoxMax ()
+    # 
+    # void setDisplayVoxels (bool display_voxels)
+    # bool getDisplayVoxels()
+    # void setRenderCamera(Camera *render_camera)
+    # int getLodPixelThreshold ()
+    # 
+    # void setLodPixelThreshold (int lod_pixel_threshold)
+    # void increaseLodPixelThreshold ()
+    # void decreaseLodPixelThreshold ()
+    # 
+    # virtual void render (vtkRenderer* renderer);
+
+
+###
+
+
+# scene.h
+# class Scene
+# {
+    # public:
+    # 
+    # // Singleton
+    # static Scene* instance ()
+    # 
+    # // Accessors - Cameras
+    # void addCamera (Camera *camera);
+    # 
+    # std::vector<Camera*> getCameras ();
+    # 
+    # Camera* getCamera (vtkCamera *camera);
+    # 
+    # Camera* getCamera (std::string name);
+    # 
+    # // Accessors - Objects
+    # void addObject (Object *object);
+    # 
+    # Object* getObjectByName (std::string name);
+    # 
+    # std::vector<Object*> getObjects ();
+    # 
+    # // Accessors - Viewports
+    # 
+    # void addViewport (Viewport *viewport);
+    # 
+    # std::vector<Viewport*> getViewports ();
+    # 
+    # 
+    # void lock ()
+    # void unlock ()
+
+
+###
+
+# viewport.h
+# class Viewport
+# {
+    # public:
+    # 
+    # // Operators
+    # Viewport (vtkSmartPointer<vtkRenderWindow> window, double xmin = 0.0, double ymin = 0.0, double xmax = 1.0, double ymax = 1.0);
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkRenderer> getRenderer () const
+    # 
+    # void setCamera (Camera* camera)
+
+
+###
+
+
+# boost.h
+###
+
+
+# cJSON.h
+# /* cJSON Types: */
+# #define cJSON_False 0
+# #define cJSON_True 1
+# #define cJSON_NULL 2
+# #define cJSON_Number 3
+# #define cJSON_String 4
+# #define cJSON_Array 5
+# #define cJSON_Object 6
+#   
+# #define cJSON_IsReference 256
+# 
+# /* The cJSON structure: */
+# typedef struct cJSON {
+#   struct cJSON *next,*prev;   /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+#   struct cJSON *child;        /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+# 
+#   int type;                   /* The type of the item, as above. */
+# 
+#   char *valuestring;          /* The item's string, if type==cJSON_String */
+#   int valueint;               /* The item's number, if type==cJSON_Number */
+#   double valuedouble;         /* The item's number, if type==cJSON_Number */
+# 
+#   char *string;               /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+# } cJSON;
+# 
+# typedef struct cJSON_Hooks {
+#       void *(*malloc_fn)(size_t sz);
+#       void (*free_fn)(void *ptr);
+# } cJSON_Hooks;
+# 
+# /* Supply malloc, realloc and free functions to cJSON */
+# PCLAPI(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+# 
+# 
+# /* Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished. */
+# PCLAPI(cJSON *) cJSON_Parse(const char *value);
+# /* Render a cJSON entity to text for transfer/storage. Free the char* when finished. */
+# PCLAPI(char  *) cJSON_Print(cJSON *item);
+# /* Render a cJSON entity to text for transfer/storage without any formatting. Free the char* when finished. */
+# PCLAPI(char  *) cJSON_PrintUnformatted(cJSON *item);
+# /* Delete a cJSON entity and all subentities. */
+# PCLAPI(void)   cJSON_Delete(cJSON *c);
+# /* Render a cJSON entity to text for transfer/storage. */
+# PCLAPI(void) cJSON_PrintStr(cJSON *item, std::string& s);
+# /* Render a cJSON entity to text for transfer/storage without any formatting. */
+# PCLAPI(void) cJSON_PrintUnformattedStr(cJSON *item, std::string& s);
+# 
+# /* Returns the number of items in an array (or object). */
+# PCLAPI(int)     cJSON_GetArraySize(cJSON *array);
+# /* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
+# PCLAPI(cJSON *) cJSON_GetArrayItem(cJSON *array,int item);
+# /* Get item "string" from object. Case insensitive. */
+# PCLAPI(cJSON *) cJSON_GetObjectItem(cJSON *object,const char *string);
+# 
+# /* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+# PCLAPI(const char *) cJSON_GetErrorPtr();
+#   
+# /* These calls create a cJSON item of the appropriate type. */
+# PCLAPI(cJSON *) cJSON_CreateNull();
+# PCLAPI(cJSON *) cJSON_CreateTrue();
+# PCLAPI(cJSON *) cJSON_CreateFalse();
+# PCLAPI(cJSON *) cJSON_CreateBool(int b);
+# PCLAPI(cJSON *) cJSON_CreateNumber(double num);
+# PCLAPI(cJSON *) cJSON_CreateString(const char *string);
+# PCLAPI(cJSON *) cJSON_CreateArray();
+# PCLAPI(cJSON *) cJSON_CreateObject();
+# 
+# /* These utilities create an Array of count items. */
+# PCLAPI(cJSON *) cJSON_CreateIntArray(int *numbers,int count);
+# PCLAPI(cJSON *) cJSON_CreateFloatArray(float *numbers,int count);
+# PCLAPI(cJSON *) cJSON_CreateDoubleArray(double *numbers,int count);
+# PCLAPI(cJSON *) cJSON_CreateStringArray(const char **strings,int count);
+# 
+# /* Append item to the specified array/object. */
+# PCLAPI(void) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+# PCLAPI(void) cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
+# /* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+# PCLAPI(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+# PCLAPI(void) cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item);
+# 
+# /* Remove/Detatch items from Arrays/Objects. */
+# PCLAPI(cJSON *) cJSON_DetachItemFromArray(cJSON *array,int which);
+# PCLAPI(void)    cJSON_DeleteItemFromArray(cJSON *array,int which);
+# PCLAPI(cJSON *) cJSON_DetachItemFromObject(cJSON *object,const char *string);
+# PCLAPI(void)    cJSON_DeleteItemFromObject(cJSON *object,const char *string);
+#   
+# /* Update array items. */
+# PCLAPI(void) cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem);
+# PCLAPI(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+# 
+# #define cJSON_AddNullToObject(object,name)    cJSON_AddItemToObject(object, name, cJSON_CreateNull())
+# #define cJSON_AddTrueToObject(object,name)    cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
+# #define cJSON_AddFalseToObject(object,name)       cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
+# #define cJSON_AddNumberToObject(object,name,n)    cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
+# #define cJSON_AddStringToObject(object,name,s)    cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
+
+
+###
+
+# metadata.h
+# namespace pcl
+# namespace outofcore
+#     
+# /** \class AbstractMetadata
+#  *
+#  *  \brief Abstract interface for outofcore metadata file types
+#  *
+#  *  \ingroup outofcore
+#  *  \author Stephen Fox (foxstephend@gmail.com)
+#  */
+# class PCL_EXPORTS OutofcoreAbstractMetadata
+# {
+    # public:
+    # /** \brief Empty constructor */
+    # OutofcoreAbstractMetadata ()
+    # 
+    # virtual ~OutofcoreAbstractMetadata ()
+    # 
+    # /** \brief Write the metadata in the on-disk format, e.g. JSON. */
+    # virtual void serializeMetadataToDisk () = 0;
+    # 
+    # /** \brief Method which should read and parse metadata and store
+    #  *  it in variables that have public getters and setters*/
+    # virtual int loadMetadataFromDisk (const boost::filesystem::path& path_to_metadata) = 0;
+    # 
+    # /** \brief Should write the same ascii metadata that is saved on
+    #  *   disk, or a human readable format of the metadata in case a binary format is being used */
+    # friend std::ostream& operator<<(std::ostream& os, const OutofcoreAbstractMetadata& metadata_arg);
+
+
+###
+
+# octree_abstract_node_container.h
+# namespace pcl
+# namespace outofcore
+    # template<typename PointT>
+    # class OutofcoreAbstractNodeContainer 
+        # public:
+        # typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        # 
+        # OutofcoreAbstractNodeContainer () : container_ ()
+        # 
+        # OutofcoreAbstractNodeContainer (const boost::filesystem::path&) {}
+        # 
+        # virtual ~OutofcoreAbstractNodeContainer () {}        
+        # virtual void insertRange (const PointT* start, const uint64_t count)=0;
+        # virtual void insertRange (const PointT* const* start, const uint64_t count)=0;
+        # virtual void readRange (const uint64_t start, const uint64_t count, AlignedPointTVector& v)=0;
+        # virtual void readRangeSubSample (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector& v) =0;
+        # virtual bool empty () const=0;
+        # virtual uint64_t size () const =0;
+        # virtual void clear ()=0;
+        # virtual void convertToXYZ (const boost::filesystem::path& path)=0;
+        # virtual PointT operator[] (uint64_t idx) const=0;
+
+
+###
+
+# octree_base.h
+# namespace pcl
+# namespace outofcore
+    # struct OutofcoreParams
+    # {
+    #   std::string node_index_basename_;
+    #   std::string node_container_basename_;
+    #   std::string node_index_extension_;
+    #   std::string node_container_extension_;
+    #   double sample_percent;
+    # };
+    # 
+    # /** \class OutofcoreOctreeBase 
+    #  *  \brief This code defines the octree used for point storage at Urban Robotics. 
+    #  * 
+    #  *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    #  *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    #  *  http://www.urbanrobotics.net/. This code was integrated for the Urban Robotics 
+    #  *  Code Sprint (URCS) by Stephen Fox (foxstephend@gmail.com). Additional development notes can be found at
+    #  *  http://www.pointclouds.org/blog/urcs/.
+    #  *
+    #  *  The primary purpose of this class is an interface to the
+    #  *  recursive traversal (recursion handled by \ref pcl::outofcore::OutofcoreOctreeBaseNode) of the
+    #  *  in-memory/top-level octree structure. The metadata in each node
+    #  *  can be loaded entirely into main memory, from which the tree can be traversed
+    #  *  recursively in this state. This class provides an the interface
+    #  *  for: 
+    #  *               -# Point/Region insertion methods 
+    #  *               -# Frustrum/box/region queries
+    #  *               -# Parameterization of resolution, container type, etc...
+    #  *
+    #  *  For lower-level node access, there is a Depth-First iterator
+    #  *  for traversing the trees with direct access to the nodes. This
+    #  *  can be used for implementing other algorithms, and other
+    #  *  iterators can be written in a similar fashion.
+    #  *
+    #  *  The format of the octree is stored on disk in a hierarchical
+    #  *  octree structure, where .oct_idx are the JSON-based node
+    #  *  metadata files managed by \ref pcl::outofcore::OutofcoreOctreeNodeMetadata,
+    #  *  and .octree is the JSON-based octree metadata file managed by
+    #  *  \ref pcl::outofcore::OutofcoreOctreeBaseMetadata. Children of each node live
+    #  *  in up to eight subdirectories named from 0 to 7, where a
+    #  *  metadata and optionally a pcd file will exist. The PCD files
+    #  *  are stored in compressed binary PCD format, containing all of
+    #  *  the fields existing in the PCLPointCloud2 objects originally
+    #  *  inserted into the out of core object.
+    #  *  
+    #  *  A brief outline of the out of core octree can be seen
+    #  *  below. The files in [brackets] exist only when the LOD are
+    #  *  built.
+    #  *
+    #  *  At this point in time, there is not support for multiple trees
+    #  *  existing in a single directory hierarchy.
+    #  *
+    #  *  \verbatim
+    #  tree_name/
+    #       tree_name.oct_idx
+    #       tree_name.octree
+    #       [tree_name-uuid.pcd]
+    #       0/
+    #            tree_name.oct_idx
+    #            [tree_name-uuid.pcd]
+    #            0/
+    #               ...
+    #            1/
+    #                ...
+    #                  ...
+    #                      0/
+    #                          tree_name.oct_idx
+    #                          tree_name.pcd
+    #       1/
+    #       ...
+    #       7/
+    #  \endverbatim
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Jacob Schloss (jacob.schloss@urbanrobotics.net)
+    #  *  \author Stephen Fox, Urban Robotics Code Sprint (foxstephend@gmail.com)
+    #  *
+    #  */
+    # template<typename ContainerT = OutofcoreOctreeDiskContainer<pcl::PointXYZ>, typename PointT = pcl::PointXYZ>
+    # class OutofcoreOctreeBase
+    # {
+        friend class OutofcoreOctreeBaseNode<ContainerT, PointT>;
+        friend class pcl::outofcore::OutofcoreIteratorBase<PointT, ContainerT>;
+        
+        public:
+        
+        // public typedefs
+        typedef OutofcoreOctreeBase<OutofcoreOctreeDiskContainer<PointT>, PointT > octree_disk;
+        typedef OutofcoreOctreeBaseNode<OutofcoreOctreeDiskContainer<PointT>, PointT > octree_disk_node;
+        
+        typedef OutofcoreOctreeBase<OutofcoreOctreeRamContainer<PointT>, PointT> octree_ram;
+        typedef OutofcoreOctreeBaseNode<OutofcoreOctreeRamContainer<PointT>, PointT> octree_ram_node;
+        
+        typedef OutofcoreOctreeBaseNode<ContainerT, PointT> OutofcoreNodeType;
+        
+        typedef OutofcoreOctreeBaseNode<ContainerT, PointT> BranchNode;
+        typedef OutofcoreOctreeBaseNode<ContainerT, PointT> LeafNode;
+        
+        typedef OutofcoreDepthFirstIterator<PointT, ContainerT> Iterator;
+        typedef const OutofcoreDepthFirstIterator<PointT, ContainerT> ConstIterator;
+        
+        typedef OutofcoreBreadthFirstIterator<PointT, ContainerT> BreadthFirstIterator;
+        typedef const OutofcoreBreadthFirstIterator<PointT, ContainerT> BreadthFirstConstIterator;
+        
+        typedef OutofcoreDepthFirstIterator<PointT, ContainerT> DepthFirstIterator;
+        typedef const OutofcoreDepthFirstIterator<PointT, ContainerT> DepthFirstConstIterator;
+        
+        typedef boost::shared_ptr<OutofcoreOctreeBase<ContainerT, PointT> > Ptr;
+        typedef boost::shared_ptr<const OutofcoreOctreeBase<ContainerT, PointT> > ConstPtr;
+        
+        typedef pcl::PointCloud<PointT> PointCloud;
+        
+        typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        
+        typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        
+        typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        
+        // Constructors
+        // -----------------------------------------------------------------------
+        /** \brief Load an existing tree
+         *
+         * If load_all is set, the BB and point count for every node is loaded,
+         * otherwise only the root node is actually created, and the rest will be
+         * generated on insertion or query.
+         *
+         * \param root_node_name Path to the top-level tree/tree.oct_idx metadata file
+         * \param load_all Load entire tree metadata (does not load any points from disk)
+         * \throws PCLException for bad extension (root node metadata must be .oct_idx extension)
+         */
+        OutofcoreOctreeBase (const boost::filesystem::path &root_node_name, const bool load_all);
+        
+        /** \brief Create a new tree
+         *
+         * Create a new tree rootname with specified bounding box; will remove and overwrite existing tree with the same name
+         *
+         * Computes the depth of the tree based on desired leaf , then calls the other constructor.
+         *
+         * \param min Bounding box min
+         * \param max Bounding box max
+         * \param resolution_arg Node dimension in meters (assuming your point data is in meters)
+         * \param root_node_name must end in ".oct_idx" 
+         * \param coord_sys Coordinate system which is stored in the JSON metadata
+         * \throws PCLException if root file extension does not match \ref pcl::outofcore::OutofcoreOctreeBaseNode::node_index_extension
+         */
+        OutofcoreOctreeBase (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const double resolution_arg, const boost::filesystem::path &root_node_name, const std::string &coord_sys);
+        
+        /** \brief Create a new tree; will not overwrite existing tree of same name
+         *
+         * Create a new tree rootname with specified bounding box; will not overwrite an existing tree
+         *
+         * \param max_depth Specifies a fixed number of LODs to generate, which is the depth of the tree
+         * \param min Bounding box min
+         * \param max Bounding box max
+         * \note Bounding box of the tree must be set before inserting any points. The tree \b cannot be resized at this time.
+         * \param root_node_name must end in ".oct_idx" 
+         * \param coord_sys Coordinate system which is stored in the JSON metadata
+         * \throws PCLException if the parent directory has existing children (detects an existing tree)
+         * \throws PCLException if file extension is not ".oct_idx"
+         */
+        OutofcoreOctreeBase (const boost::uint64_t max_depth, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::filesystem::path &root_node_name, const std::string &coord_sys);
+        
+        virtual ~OutofcoreOctreeBase ();
+        
+        // Point/Region INSERTION methods
+        // --------------------------------------------------------------------------------
+        /** \brief Recursively add points to the tree 
+         *  \note shared read_write_mutex lock occurs
+         */
+        boost::uint64_t addDataToLeaf (const AlignedPointTVector &p);
+        
+        /** \brief Copies the points from the point_cloud falling within the bounding box of the octree to the
+         *   out-of-core octree; this is an interface to addDataToLeaf and can be used multiple times.
+         *  \param point_cloud Pointer to the point cloud data to copy to the outofcore octree; Assumes templated
+         *   PointT matches for each.
+         *  \return Number of points successfully copied from the point cloud to the octree.
+         */
+        boost::uint64_t addPointCloud (PointCloudConstPtr point_cloud);
+        
+        /** \brief Recursively copies points from input_cloud into the leaf nodes of the out-of-core octree, and stores them to disk.
+         *
+         * \param[in] input_cloud The cloud of points to be inserted into the out-of-core octree. Note if multiple PCLPointCloud2 objects are added to the tree, this assumes that they all have exactly the same fields.
+         * \param[in] skip_bb_check (default=false) whether to skip the bounding box check on insertion. Note the bounding box check is never skipped in the current implementation.
+         * \return Number of poitns successfully copied from the point cloud to the octree
+         */
+        boost::uint64_t addPointCloud (pcl::PCLPointCloud2::Ptr &input_cloud, const bool skip_bb_check = false);
+        
+        /** \brief Recursively add points to the tree. 
+         *
+         * Recursively add points to the tree. 1/8 of the remaining
+         * points at each LOD are stored at each internal node of the
+         * octree until either (a) runs out of points, in which case
+         * the leaf is not at the maximum depth of the tree, or (b)
+         * a larger set of points falls in the leaf at the maximum depth.
+         * Note unlike the old implementation, multiple
+         * copies of the same point will \b not be added at multiple
+         * LODs as it walks the tree. Once the point is added to the
+         * octree, it is no longer propagated further down the tree.
+         *
+         *\param[in] input_cloud The input cloud of points which will
+         * be copied into the sorted nodes of the out-of-core octree
+         * \return The total number of points added to the out-of-core
+         * octree.
+         */
+        boost::uint64_t addPointCloud_and_genLOD (pcl::PCLPointCloud2::Ptr &input_cloud);
+        
+        boost::uint64_t addPointCloud (pcl::PCLPointCloud2::Ptr &input_cloud);
+        
+        boost::uint64_t addPointCloud_and_genLOD (PointCloudConstPtr point_cloud);
+        
+        /** \brief Recursively add points to the tree subsampling LODs on the way.
+         * shared read_write_mutex lock occurs
+         */
+        boost::uint64_t addDataToLeaf_and_genLOD (AlignedPointTVector &p);
+        
+        // Frustrum/Box/Region REQUESTS/QUERIES: DB Accessors
+        // -----------------------------------------------------------------------
+        void queryFrustum (const double *planes, std::list<std::string>& file_names) const;
+        
+        void queryFrustum (const double *planes, std::list<std::string>& file_names, const boost::uint32_t query_depth) const;
+        
+        void queryFrustum (const double *planes, const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix,
+                            std::list<std::string>& file_names, const boost::uint32_t query_depth) const;
+        
+        // templated PointT methods
+        
+        /** \brief Get a list of file paths at query_depth that intersect with your bounding box specified by \c min and \c max.
+         *  When querying with this method, you may be stuck with extra data (some outside of your query bounds) that reside in the files.
+         *
+         * \param[in] min The minimum corner of the bounding box
+         * \param[in] max The maximum corner of the bounding box
+         * \param[in] query_depth 0 is root, (this->depth) is full
+         * \param[out] bin_name List of paths to point data files (PCD currently) which satisfy the query
+         */
+        void queryBBIntersects (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name) const;
+        
+        /** \brief Get Points in BB, only points inside BB. The query
+         * processes the data at each node, filtering points that fall
+         * out of the query bounds, and returns a single, concatenated
+         * point cloud.
+         *
+         * \param[in] min The minimum corner of the bounding box for querying
+         * \param[in] max The maximum corner of the bounding box for querying
+         * \param[in] query_depth The depth from which point data will be taken
+         *   \note If the LODs of the tree have not been built, you must specify the maximum depth in order to retrieve any data
+         * \param[out] dst The destination vector of points
+         */
+        void queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint64_t query_depth, AlignedPointTVector &dst) const;
+        
+        /** \brief Query all points falling within the input bounding box at \c query_depth and return a PCLPointCloud2 object in \c dst_blob.
+         *
+         * \param[in] min The minimum corner of the input bounding box.
+         * \param[in] max The maximum corner of the input bounding box.
+         * \param[in] query_depth The query depth at which to search for points; only points at this depth are returned
+         * \param[out] dst_blob Storage location for the points satisfying the query.
+         **/
+        void queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob) const;
+        
+        /** \brief Returns a random subsample of points within the given bounding box at \c query_depth.
+         *
+         * \param[in] min The minimum corner of the boudning box to query.
+         * \param[out] max The maximum corner of the bounding box to query.
+         * \param[in] query_depth The depth in the tree at which to look for the points. Only returns points within the given bounding box at the specified \c query_depth.
+         * \param[out] dst The destination in which to return the points.
+         * 
+         */
+        void queryBBIncludes_subsample (const Eigen::Vector3d &min, const Eigen::Vector3d &max, uint64_t query_depth, const double percent, AlignedPointTVector &dst) const;
+        
+        // PCLPointCloud2 methods
+        
+        /** \brief Query all points falling within the input bounding box at \c query_depth and return a PCLPointCloud2 object in \c dst_blob.
+         *   If the optional argument for filter is given, points are processed by that filter before returning.
+         *  \param[in] min The minimum corner of the input bounding box.
+         *  \param[in] max The maximum corner of the input bounding box.
+         *  \param[in] query_depth The depth of tree at which to query; only points at this depth are returned
+         *  \param[out] dst_blob The destination in which points within the bounding box are stored.
+         *  \param[in] percent optional sampling percentage which is applied after each time data are read from disk
+         */
+        virtual void queryBoundingBox (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const int query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob, double percent = 1.0);
+        
+        /** \brief Returns list of pcd files from nodes whose bounding boxes intersect with the input bounding box.
+         * \param[in] min The minimum corner of the input bounding box.
+         * \param[in] max The maximum corner of the input bounding box.
+         * \param query_depth
+         * \param[out] filenames The list of paths to the PCD files which can be loaded and processed.
+         */
+        inline virtual void queryBoundingBox (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const int query_depth, std::list<std::string> &filenames) const
+        
+        // Parameterization: getters and setters
+        
+        /** \brief Get the overall bounding box of the outofcore
+         *  octree; this is the same as the bounding box of the \c root_node_ node
+         *  \param min
+         *  \param max
+         */
+        bool getBoundingBox (Eigen::Vector3d &min, Eigen::Vector3d &max) const;
+        
+        /** \brief Get number of points at specified LOD 
+         * \param[in] depth_index the level of detail at which we want the number of points (0 is root, 1, 2,...)
+         * \return number of points in the tree at \b depth
+         */
+        inline boost::uint64_t getNumPointsAtDepth (const boost::uint64_t& depth_index) const
+        
+        /** \brief Queries the number of points in a bounding box 
+         *  \param[in] min The minimum corner of the input bounding box
+         *  \param[out] max The maximum corner of the input bounding box
+         *  \param[in] query_depth The depth of the nodes to restrict the search to (only this depth is searched)
+         *  \param[in] load_from_disk (default true) Whether to load PCD files to count exactly the number of points within the bounding box; setting this to false will return an upper bound by just reading the number of points from the PCD header, even if there may be some points in that node do not fall within the query bounding box.
+         *  \return Number of points in the bounding box at depth \b query_depth
+         **/
+        boost::uint64_t queryBoundingBoxNumPoints (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const int query_depth, bool load_from_disk = true);
+        
+        /** \brief Get number of points at each LOD 
+         * \return vector of number of points in each LOD indexed by each level of depth, 0 to the depth of the tree.
+         */
+        inline const std::vector<boost::uint64_t>& getNumPointsVector () const
+        
+        /** \brief Get number of LODs, which is the height of the tree
+         */
+        inline boost::uint64_t getDepth () const
+        inline boost::uint64_t getTreeDepth () const
+        /** \brief Computes the expected voxel dimensions at the leaves 
+         */
+        bool getBinDimension (double &x, double &y) const;
+        
+        /** \brief gets the side length of an (assumed) perfect cubic voxel.
+         *  \note If the initial bounding box specified in constructing the octree is not square, then this method does not return a sensible value 
+         *  \return the side length of the cubic voxel size at the specified depth
+         */
+        double getVoxelSideLength (const boost::uint64_t& depth) const;
+        
+        /** \brief Gets the smallest (assumed) cubic voxel side lengths. The smallest voxels are located at the max depth of the tree.
+         * \return The side length of a the cubic voxel located at the leaves
+         */
+        double getVoxelSideLength () const
+        
+        /** \brief Get coordinate system tag from the JSON metadata file
+         */
+        const std::string& getCoordSystem () const
+        
+        // Mutators
+        
+        /** \brief Generate multi-resolution LODs for the tree, which are a uniform random sampling all child leafs below the node.
+         */
+        void buildLOD ();
+        
+        /** \brief Prints size of BBox to stdout
+         */ 
+        void printBoundingBox (const size_t query_depth) const;
+        
+        /** \brief Prints the coordinates of the bounding box of the node to stdout */
+        void printBoundingBox (OutofcoreNodeType& node) const;
+        
+        /** \brief Prints size of the bounding boxes to stdou
+         */
+        inline void printBoundingBox() const
+        
+        /** \brief Returns the voxel centers of all existing voxels at \c query_depth
+            \param[out] voxel_centers Vector of PointXYZ voxel centers for nodes that exist at that depth
+            \param[in] query_depth the depth of the tree at which to retrieve occupied/existing voxels
+        */
+        void getOccupiedVoxelCenters(AlignedPointTVector &voxel_centers, size_t query_depth) const;
+        
+        /** \brief Returns the voxel centers of all existing voxels at \c query_depth
+            \param[out] voxel_centers Vector of PointXYZ voxel centers for nodes that exist at that depth
+            \param[in] query_depth the depth of the tree at which to retrieve occupied/existing voxels
+        */
+        void getOccupiedVoxelCenters(std::vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d> > &voxel_centers, size_t query_depth) const;
+        
+        /** \brief Gets the voxel centers of all occupied/existing leaves of the tree */
+        void getOccupiedVoxelCenters(AlignedPointTVector &voxel_centers) const
+        
+        /** \brief Returns the voxel centers of all occupied/existing leaves of the tree 
+         *  \param[out] voxel_centers std::vector of the centers of all occupied leaves of the octree
+         */
+        void getOccupiedVoxelCenters(std::vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d> > &voxel_centers) const
+        
+        // Serializers
+        
+        /** \brief Save each .bin file as an XYZ file */
+        void convertToXYZ ();
+        
+        /** \brief Write a python script using the vpython module containing all
+         * the bounding boxes */
+        void writeVPythonVisual (const boost::filesystem::path filename);
+        
+        OutofcoreNodeType* getBranchChildPtr (const BranchNode& branch_arg, unsigned char childIdx_arg) const;
+        
+        pcl::Filter<pcl::PCLPointCloud2>::Ptr getLODFilter ();
+        const pcl::Filter<pcl::PCLPointCloud2>::ConstPtr getLODFilter () const;
+        
+        /** \brief Sets the filter to use when building the levels of depth. Recommended filters are pcl::RandomSample<pcl::PCLPointCloud2> or pcl::VoxelGrid */
+        void setLODFilter (const pcl::Filter<pcl::PCLPointCloud2>::Ptr& filter_arg);
+        
+        /** \brief Returns the sample_percent_ used when constructing the LOD. */
+        double getSamplePercent () const
+        
+        /** \brief Sets the sampling percent for constructing LODs. Each LOD gets sample_percent^d points. 
+         * \param[in] sample_percent_arg Percentage between 0 and 1. */
+        inline void setSamplePercent (const double sample_percent_arg)
+
+
+###
+
+# octree_base_node.h
+# namespace pcl
+# namespace outofcore
+    # // Forward Declarations
+    # template<typename ContainerT, typename PointT>
+    # class OutofcoreOctreeBaseNode;
+    # 
+    # template<typename ContainerT, typename PointT>
+    # class OutofcoreOctreeBase;
+    # 
+    # /** \brief Non-class function which creates a single child leaf; used with \ref queryBBIntersects_noload to avoid loading the data from disk */
+    # template<typename ContainerT, typename PointT> OutofcoreOctreeBaseNode<ContainerT, PointT>*
+    # makenode_norec (const boost::filesystem::path &path, OutofcoreOctreeBaseNode<ContainerT, PointT>* super);
+    # 
+    # /** \brief Non-class method which performs a bounding box query without loading any of the point cloud data from disk */
+    # template<typename ContainerT, typename PointT> void
+    # queryBBIntersects_noload (const boost::filesystem::path &root_node, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+    # 
+    # /** \brief Non-class method overload */
+    # template<typename ContainerT, typename PointT> void
+    # queryBBIntersects_noload (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d&, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+    # 
+    # /** \class OutofcoreOctreeBaseNode 
+    #  *
+    #  *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    #  *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    #  *  http://www.urbanrobotics.net/
+    #  *
+    #  *  \brief OutofcoreOctreeBaseNode Class internally representing nodes of an
+    #  *  outofcore octree, with accessors to its data via the \ref
+    #  *  pcl::outofcore::OutofcoreOctreeDiskContainer class or \ref pcl::outofcore::OutofcoreOctreeRamContainer class,
+    #  *  whichever it is templated against.  
+    #  * 
+    #  *  \ingroup outofcore
+    #  *  \author Jacob Schloss (jacob.schloss@urbanrobotics.net)
+    #  *
+    #  */
+    # template<typename ContainerT = OutofcoreOctreeDiskContainer<pcl::PointXYZ>, typename PointT = pcl::PointXYZ>
+    # class OutofcoreOctreeBaseNode : public pcl::octree::OctreeNode
+    # {
+        # friend class OutofcoreOctreeBase<ContainerT, PointT> ;
+        # 
+        # // these methods can be rewritten with the iterators. 
+        # friend OutofcoreOctreeBaseNode<ContainerT, PointT>*
+        # makenode_norec<ContainerT, PointT> (const boost::filesystem::path &path, OutofcoreOctreeBaseNode<ContainerT, PointT>* super);
+        # 
+        # friend void queryBBIntersects_noload<ContainerT, PointT> (const boost::filesystem::path &rootnode, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+        # 
+        # friend void queryBBIntersects_noload<ContainerT, PointT> (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+        # 
+        # public:
+        # typedef OutofcoreOctreeBase<OutofcoreOctreeDiskContainer < PointT > , PointT > octree_disk;
+        # typedef OutofcoreOctreeBaseNode<OutofcoreOctreeDiskContainer < PointT > , PointT > octree_disk_node;
+        # typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        # typedef pcl::octree::node_type_t node_type_t;
+        # 
+        # const static std::string node_index_basename;
+        # const static std::string node_container_basename;
+        # const static std::string node_index_extension;
+        # const static std::string node_container_extension;
+        # const static double sample_percent_;
+        # 
+        # /** \brief Empty constructor; sets pointers for children and for bounding boxes to 0
+        #  */
+        # OutofcoreOctreeBaseNode ();
+        # 
+        # /** \brief Create root node and directory */
+        # OutofcoreOctreeBaseNode (const Eigen::Vector3d &bb_min, const Eigen::Vector3d &bb_max, OutofcoreOctreeBase<ContainerT, PointT> * const tree, const boost::filesystem::path &root_name);
+        # 
+        # /** \brief Will recursively delete all children calling recFreeChildrein */
+        # virtual ~OutofcoreOctreeBaseNode ();
+        # 
+        # //query
+        # /** \brief gets the minimum and maximum corner of the bounding box represented by this node
+        #  * \param[out] min_bb returns the minimum corner of the bounding box indexed by 0-->X, 1-->Y, 2-->Z 
+        #  * \param[out] max_bb returns the maximum corner of the bounding box indexed by 0-->X, 1-->Y, 2-->Z 
+        #  */
+        # virtual inline void getBoundingBox (Eigen::Vector3d &min_bb, Eigen::Vector3d &max_bb) const
+        # 
+        # const boost::filesystem::path& getPCDFilename () const
+        # const boost::filesystem::path& getMetadataFilename () const
+        # 
+        # void queryFrustum (const double planes[24], std::list<std::string>& file_names);
+        # void queryFrustum (const double planes[24], std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check = false);
+        # void queryFrustum (const double planes[24], const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix, std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check = false);
+        # 
+        # //point extraction
+        # /** \brief Recursively add points that fall into the queried bounding box up to the \b query_depth 
+        #  *
+        #  *  \param[in] min_bb the minimum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] max_bb the maximum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] query_depth the maximum depth to query in the octree for points within the bounding box
+        #  *  \param[out] dst destion of points returned by the queries
+        #  */
+        # virtual void queryBBIncludes (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, size_t query_depth, AlignedPointTVector &dst);
+        # 
+        # /** \brief Recursively add points that fall into the queried bounding box up to the \b query_depth
+        #  *
+        #  *  \param[in] min_bb the minimum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] max_bb the maximum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] query_depth the maximum depth to query in the octree for points within the bounding box
+        #  *  \param[out] dst_blob destion of points returned by the queries
+        #  */
+        # virtual void queryBBIncludes (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, size_t query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob);
+        # 
+        # /** \brief Recursively add points that fall into the queried bounding box up to the \b query_depth 
+        #  *
+        #  *  \param[in] min_bb the minimum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] max_bb the maximum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] query_depth
+        #  *  \param percent
+        #  *  \param[out] v std::list of points returned by the query
+        #  */
+        # virtual void queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, boost::uint64_t query_depth, const double percent, AlignedPointTVector &v);
+        # virtual void queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob, double percent = 1.0);
+        # 
+        # /** \brief Recursive acquires PCD paths to any node with which the queried bounding box intersects (at query_depth only).
+        #  */
+        # virtual void queryBBIntersects (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const boost::uint32_t query_depth, std::list<std::string> &file_names);
+        # 
+        # /** \brief Write the voxel size to stdout at \c query_depth 
+        #  * \param[in] query_depth The depth at which to print the size of the voxel/bounding boxes
+        #  */
+        # virtual void printBoundingBox (const size_t query_depth) const;
+        # 
+        # /** \brief add point to this node if we are a leaf, or find the leaf below us that is supposed to take the point 
+        #  *  \param[in] p vector of points to add to the leaf
+        #  *  \param[in] skip_bb_check whether to check if the point's coordinates fall within the bounding box
+        #  */
+        # virtual boost::uint64_t addDataToLeaf (const AlignedPointTVector &p, const bool skip_bb_check = true);
+        # 
+        # virtual boost::uint64_t addDataToLeaf (const std::vector<const PointT*> &p, const bool skip_bb_check = true);
+        # 
+        # /** \brief Add a single PCLPointCloud2 object into the octree.
+        #  * \param[in] input_cloud
+        #  * \param[in] skip_bb_check (default = false)
+        #  */
+        # virtual boost::uint64_t addPointCloud (const pcl::PCLPointCloud2::Ptr &input_cloud, const bool skip_bb_check = false);
+        # 
+        # /** \brief Add a single PCLPointCloud2 into the octree and build the subsampled LOD during construction; this method of LOD construction is <b>not</b> multiresolution. Rather, there are no redundant data. */
+        # virtual boost::uint64_t addPointCloud_and_genLOD (const pcl::PCLPointCloud2::Ptr input_cloud); //, const bool skip_bb_check);
+        # 
+        # /** \brief Recursively add points to the leaf and children subsampling LODs
+        #  * on the way down.
+        #  * \note rng_mutex_ lock occurs
+        #  */
+        # virtual boost::uint64_t addDataToLeaf_and_genLOD (const AlignedPointTVector &p, const bool skip_bb_check);
+        # 
+        # /** \brief Write a python visual script to @b file
+        #  * \param[in] file output file stream to write the python visual script
+        #  */
+        # void writeVPythonVisual (std::ofstream &file);
+        # 
+        # virtual int read (pcl::PCLPointCloud2::Ptr &output_cloud);
+        # virtual inline node_type_t getNodeType () const
+        # 
+        # virtual OutofcoreOctreeBaseNode*  deepCopy () const
+        # 
+        # virtual inline size_t getDepth () const
+        # 
+        # /** \brief Returns the total number of children on disk */
+        # virtual size_t getNumChildren () const 
+        # 
+        # /** \brief Count loaded chilren */
+        # virtual size_t getNumLoadedChildren ()  const
+        # 
+        # /** \brief Returns a pointer to the child in octant index_arg */
+        # virtual OutofcoreOctreeBaseNode* getChildPtr (size_t index_arg) const;
+        # 
+        # /** \brief Gets the number of points available in the PCD file */
+        # virtual boost::uint64_t getDataSize () const;
+        # 
+        # inline virtual void clearData ()
+
+
+###
+
+# octree_disk_container.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeDiskContainer
+    # *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    # *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    # *  http://www.urbanrobotics.net/
+    # *
+    # *  \brief Class responsible for serialization and deserialization of out of core point data
+    # *  \ingroup outofcore
+    # *  \author Jacob Schloss (jacob.schloss@urbanrobotics.net)
+    # */
+    # template<typename PointT = pcl::PointXYZ>
+    # class OutofcoreOctreeDiskContainer : public OutofcoreAbstractNodeContainer<PointT>
+    # {
+        # public:
+        # typedef typename OutofcoreAbstractNodeContainer<PointT>::AlignedPointTVector AlignedPointTVector;
+        # 
+        # /** \brief Empty constructor creates disk container and sets filename from random uuid string*/
+        # OutofcoreOctreeDiskContainer ();
+        # 
+        # /** \brief Creates uuid named file or loads existing file
+        #  * If \b dir is a directory, this constructor will create a new
+        #  * uuid named file; if \b dir is an existing file, it will load the
+        #  * file metadata for accessing the tree.
+        #  * \param[in] dir Path to the tree. If it is a directory, it
+        #  * will create the metadata. If it is a file, it will load the metadata into memory.
+        #  */
+        # OutofcoreOctreeDiskContainer (const boost::filesystem::path &dir);
+        # 
+        # /** \brief flushes write buffer, then frees memory */
+        # ~OutofcoreOctreeDiskContainer ();
+        # 
+        # /** \brief provides random access to points based on a linear index
+        #  */
+        # inline PointT operator[] (uint64_t idx) const;
+        # 
+        # /** \brief Adds a single point to the buffer to be written to disk when the buffer grows sufficiently large, the object is destroyed, or the write buffer is manually flushed */
+        # inline void push_back (const PointT& p);
+        # 
+        # /** \brief Inserts a vector of points into the disk data structure */
+        # void insertRange (const AlignedPointTVector& src);
+        # 
+        # /** \brief Inserts a PCLPointCloud2 object directly into the disk container */
+        # void insertRange (const pcl::PCLPointCloud2::Ptr &input_cloud);
+        # 
+        # void insertRange (const PointT* const * start, const uint64_t count);
+        # 
+        # /** \brief This is the primary method for serialization of
+        #  * blocks of point data. This is called by the outofcore
+        #  * octree interface, opens the binary file for appending data,
+        #  * and writes it to disk.
+        #  * \param[in] start address of the first point to insert
+        #  * \param[in] count offset from start of the last point to insert
+        #  */
+        # void insertRange (const PointT* start, const uint64_t count);
+        # 
+        # /** \brief Reads \b count points into memory from the disk container
+        #  * Reads \b count points into memory from the disk container, reading at most 2 million elements at a time
+        #  * \param[in] start index of first point to read from disk
+        #  * \param[in] count offset of last point to read from disk
+        #  * \param[out] dst std::vector as destination for points read from disk into memory
+        #  */
+        # void readRange (const uint64_t start, const uint64_t count, AlignedPointTVector &dst);
+        # 
+        # void readRange (const uint64_t, const uint64_t, pcl::PCLPointCloud2::Ptr &dst);
+        # 
+        # /** \brief Reads the entire point contents from disk into \c output_cloud
+        #  *  \param[out] output_cloud
+        #  */
+        # int read (pcl::PCLPointCloud2::Ptr &output_cloud);
+        # 
+        # /** \brief  grab percent*count random points. points are \b not guaranteed to be
+        #  * unique (could have multiple identical points!)
+        #  * \param[in] start The starting index of points to select
+        #  * \param[in] count The length of the range of points from which to randomly sample 
+        #  *  (i.e. from start to start+count)
+        #  * \param[in] percent The percentage of count that is enough points to make up this random sample
+        #  * \param[out] dst std::vector as destination for randomly sampled points; size will 
+        #  * be percentage*count
+        #  */
+        # void readRangeSubSample (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector &dst);
+        # 
+        # /** \brief Use bernoulli trials to select points. All points selected will be unique.
+        #  * \param[in] start The starting index of points to select
+        #  * \param[in] count The length of the range of points from which to randomly sample 
+        #  *  (i.e. from start to start+count)
+        #  * \param[in] percent The percentage of count that is enough points to make up this random sample
+        #  * \param[out] dst std::vector as destination for randomly sampled points; size will 
+        #  * be percentage*count
+        #  */
+        # void readRangeSubSample_bernoulli (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector& dst);
+        # 
+        # /** \brief Returns the total number of points for which this container is responsible, \c filelen_ + points in \c writebuff_ that have not yet been flushed to the disk
+        #  */
+        # uint64_t size () const
+        # 
+        # /** \brief STL-like empty test
+        #  * \return true if container has no data on disk or waiting to be written in \c writebuff_ */
+        # inline bool empty () const
+        # 
+        # /** \brief Exposed functionality for manually flushing the write buffer during tree creation */
+        # void flush (const bool force_cache_dealloc)
+        # 
+        # /** \brief Returns this objects path name */
+        # inline std::string& path ()
+        # 
+        # inline void clear ()
+        # 
+        # /** \brief write points to disk as ascii
+        #  * \param[in] path
+        #  */
+        # void convertToXYZ (const boost::filesystem::path &path)
+        # 
+        # /** \brief Generate a universally unique identifier (UUID)
+        #  * A mutex lock happens to ensure uniquness
+        #  */
+        # static void getRandomUUIDString (std::string &s);
+        # 
+        # /** \brief Returns the number of points in the PCD file by reading the PCD header. */
+        # boost::uint64_t getDataSize () const;
+
+
+###
+
+# octree_ram_container.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeRamContainer
+    #  *  \brief Storage container class which the outofcore octree base is templated against
+    #  *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    #  *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    #  *  http://www.urbanrobotics.net/
+    #  * 
+    #  *  \ingroup outofcore
+    #  *  \author Jacob Schloss (jacob.scloss@urbanrobotics.net)
+    #  */
+    # template<typename PointT>
+    # class OutofcoreOctreeRamContainer : public OutofcoreAbstractNodeContainer<PointT>
+    # {
+        # public:
+        # typedef typename OutofcoreAbstractNodeContainer<PointT>::AlignedPointTVector AlignedPointTVector;
+        # 
+        # /** \brief empty contructor (with a path parameter?)
+        #   */
+        # OutofcoreOctreeRamContainer (const boost::filesystem::path&) : container_ () { }
+        # 
+        # /** \brief inserts count number of points into container; uses the container_ type's insert function
+        #   * \param[in] start - address of first point in array
+        #   * \param[in] count - the maximum offset from start of points inserted 
+        #   */
+        # void insertRange (const PointT* start, const uint64_t count);
+        # 
+        # /** \brief inserts count points into container 
+        #   * \param[in] start - address of first point in array
+        #   * \param[in] count - the maximum offset from start of points inserted 
+        #   */
+        # void insertRange (const PointT* const * start, const uint64_t count);
+        # 
+        # void insertRange (AlignedPointTVector& /*p*/)
+        # 
+        # void insertRange (const AlignedPointTVector& /*p*/)
+        # 
+        # /** \brief 
+        #   * \param[in] start Index of first point to return from container
+        #   * \param[in] count Offset (start + count) of the last point to return from container
+        #   * \param[out] v Array of points read from the input range
+        #   */
+        # void readRange (const uint64_t start, const uint64_t count, AlignedPointTVector &v);
+        # 
+        # /** \brief grab percent*count random points. points are NOT
+        #   *   guaranteed to be unique (could have multiple identical points!)
+        #   * \param[in] start Index of first point in range to subsample
+        #   * \param[in] count Offset (start+count) of last point in range to subsample
+        #   * \param[in] percent Percentage of range to return
+        #   * \param[out] v Vector with percent*count uniformly random sampled 
+        #   * points from given input rangerange
+        #   */
+        # void readRangeSubSample (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector &v);
+        # 
+        # /** \brief returns the size of the vector of points stored in this class */
+        # inline uint64_t size () const
+        # 
+        # inline bool empty () const
+        # 
+        # 
+        # /** \brief clears the vector of points in this class */
+        # inline void clear ()
+        # 
+        # /** \brief Writes ascii x,y,z point data to path.string().c_str()
+        #   *  \param path The path/filename destination of the ascii xyz data
+        #   */
+        # void convertToXYZ (const boost::filesystem::path &path);
+        # 
+        # inline PointT operator[] (uint64_t index) const
+
+
+###
+
+# outofcore.h
+###
+
+
+# outofcore_base_data.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeBaseMetadata 
+    #  *  \brief Encapsulated class to read JSON metadata into memory,
+    #  *  and write the JSON metadata associated with the octree root
+    #  *  node. This is global information that is not the same as the
+    #  *  metadata for the root node. Inherits OutofcoreAbstractMetadata
+    #  *  interface for metadata in \b pcl_outofcore.
+    #  *  This class encapsulates the outofcore base metadata
+    #  *  serialization/deserialization. At the time it was written,
+    #  *  this depended on cJSON to write JSON objects to disk. This
+    #  *  class can be extended to have arbitrary JSON ascii metadata
+    #  *  fields saved to the metadata object file on disk. The class
+    #  *  has been encapuslated to abstract the detailso of the on-disk
+    #  *  format from the outofcore implementation. For example, the
+    #  *  format could be changed to XML/YAML, or any dynamic format at
+    #  *  some point.
+    #  *  The JSON file is formatted in the following way:
+    #  *  \verbatim
+    #  {
+    #    "name": "nameoftree",
+    #    "version": 3,
+    #    "pointtype": "urp",               #(needs to be changed*)
+    #    "lod": 3,                         #(depth of the tree
+    #    "numpts":  [X0, X1, X2, ..., XD], #total number of points at each LOD
+    #    "coord_system": "ECEF"            #the tree is not affected by this value
+    #  }
+    #  \endverbatim
+    #  *
+    #  *  Any properties not stored in the metadata file are computed
+    #  *  when the file is loaded. By convention, and for historical
+    #  *  reasons from the original Urban Robotics implementation, the
+    #  *  JSON file representing the overall tree is a JSON file named
+    #  *  with the ".octree" extension.
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  */
+    # class PCL_EXPORTS OutofcoreOctreeBaseMetadata : public OutofcoreAbstractMetadata
+        # public:
+        # /** \brief Empty constructor */
+        # OutofcoreOctreeBaseMetadata ();
+        # /** \brief Load metadata from disk 
+        #  *
+        #  *  \param[in] path_arg Location of JSON metadata file to load from disk
+        #  */
+        # OutofcoreOctreeBaseMetadata (const boost::filesystem::path& path_arg);
+        # /** \brief Default destructor*/
+        # ~OutofcoreOctreeBaseMetadata ();
+        # 
+        # /** \brief Copy constructor */
+        # OutofcoreOctreeBaseMetadata (const OutofcoreOctreeBaseMetadata& orig);
+        # 
+        # /** \brief et the outofcore version read from the "version" field of the JSON object */
+        # int getOutofcoreVersion () const;
+        # /** \brief Set the outofcore version stored in the "version" field of the JSON object */
+        # void setOutofcoreVersion (const int version);
+        # 
+        # /** \brief Gets the name of the JSON file */
+        # boost::filesystem::path getMetadataFilename () const;
+        # /** \brief Sets the name of the JSON file */
+        # void setMetadataFilename (const boost::filesystem::path& path_to_metadata);
+        #  
+        # /** \brief Writes the data to a JSON file located at \ref metadata_filename_ */
+        # virtual void serializeMetadataToDisk ();
+        # 
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # virtual int loadMetadataFromDisk ();
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # 
+        # virtual int loadMetadataFromDisk (const boost::filesystem::path& path_to_metadata);
+        # 
+        # /** \brief Returns the name of the tree; this is not the same as the filename */
+        # virtual std::string getOctreeName ();
+        # /** \brief Sets the name of the tree */
+        # virtual void setOctreeName (const std::string& name_arg);
+        # 
+        # virtual std::string getPointType ();
+        # /** \brief Sets a single string identifying the point type of this tree */
+        # virtual void setPointType (const std::string& point_type_arg);
+        # 
+        # virtual std::vector<boost::uint64_t>& getLODPoints ();
+        # virtual std::vector<boost::uint64_t> getLODPoints () const;
+        # /** \brief Get the number of points at the given depth */
+        # virtual boost::uint64_t getLODPoints (const boost::uint64_t& depth_index) const;
+        # 
+        # /** \brief Initialize the LOD vector with points all 0 */
+        # virtual void setLODPoints (const boost::uint64_t& depth);
+        # /** \brief Copy a vector of LOD points into this metadata (dangerous!)*/
+        # virtual void setLODPoints (std::vector<boost::uint64_t>& lod_points_arg);
+        # 
+        # /** \brief Set the number of points at lod_index_arg manually 
+        #  *  \param[in] lod_index_arg the depth at which this increments the number of LOD points
+        #  *  \param[in] num_points_arg The number of points to store at that LOD
+        #  *  \param[in] increment If true, increments the number of points at the LOD rather than overwriting the number of points
+        #  */
+        # virtual void setLODPoints (const boost::uint64_t& lod_index_arg, const boost::uint64_t& num_points_arg, const bool increment=true);
+        # 
+        # /** \brief Set information about the coordinate system */
+        # virtual void setCoordinateSystem (const std::string& coordinate_system);
+        # /** \brief Get metadata information about the coordinate system */
+        # virtual std::string getCoordinateSystem () const;
+        # 
+        # /** \brief Set the depth of the tree corresponding to JSON "lod:number". This should always be equal to LOD_num_points_.size()-1 */
+        # virtual void setDepth (const boost::uint64_t& depth_arg);
+        # virtual boost::uint64_t getDepth () const;
+        # 
+        # /** \brief Provide operator overload to stream ascii file data*/
+        # friend std::ostream& operator<<(std::ostream& os, const OutofcoreOctreeBaseMetadata& metadata_arg);
+
+
+###
+
+
+# outofcore_breadth_first_iterator.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreBreadthFirstIterator
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Justin Rosen (jmylesrosen@gmail.com)
+    #  *  \note Code adapted from \ref octree_iterator.h in Module \ref pcl::octree written by Julius Kammerl
+    #  */
+    # template<typename PointT=pcl::PointXYZ, typename ContainerT=OutofcoreOctreeDiskContainer<pcl::PointXYZ> >
+    # class OutofcoreBreadthFirstIterator : public OutofcoreIteratorBase<PointT, ContainerT>
+        # public:
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT> OctreeDisk;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> OctreeDiskNode;
+        # 
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> LeafNode;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> BranchNode;
+        # 
+        # explicit OutofcoreBreadthFirstIterator (OctreeDisk& octree_arg);
+        # virtual ~OutofcoreBreadthFirstIterator ();
+        # 
+        # OutofcoreBreadthFirstIterator& operator++ ();
+        # inline OutofcoreBreadthFirstIterator operator++ (int)
+        # 
+        # virtual inline void reset ()
+        # 
+        # void skipChildVoxels ()
+
+
+###
+
+
+# outofcore_depth_first_iterator.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreDepthFirstIterator
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  *  \note Code adapted from \ref octree_iterator.h in Module \ref pcl::octree written by Julius Kammerl
+    #  */
+    # template<typename PointT=pcl::PointXYZ, typename ContainerT=OutofcoreOctreeDiskContainer<pcl::PointXYZ> >
+    # class OutofcoreDepthFirstIterator : public OutofcoreIteratorBase<PointT, ContainerT>
+        # public:
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT> OctreeDisk;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> OctreeDiskNode;
+        # 
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> LeafNode;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> BranchNode;
+        # 
+        # explicit OutofcoreDepthFirstIterator (OctreeDisk& octree_arg);
+        # 
+        # virtual ~OutofcoreDepthFirstIterator ();
+        
+        OutofcoreDepthFirstIterator& operator++ ();
+        
+        inline OutofcoreDepthFirstIterator operator++ (int)
+        
+        void skipChildVoxels ();
+
+
+###
+
+# outofcore_impl.h
+###
+
+
+# outofcore_iterator_base.h
+# namespace pcl
+# namespace outofcore
+    # /** \brief Abstract octree iterator class
+    #  *  \note This class is based on the octree_iterator written by Julius Kammerl adapted to the outofcore octree. The interface is very similar, but it does \b not inherit the \ref pcl::octree iterator base.
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  */
+    # template<typename PointT, typename ContainerT>
+    # class OutofcoreIteratorBase : public std::iterator<std::forward_iterator_tag,     /*iterator type*/
+    #                                                   const OutofcoreOctreeBaseNode<ContainerT, PointT>,
+    #                                                    void,  /*no defined distance between iterator*/
+    #                                                    const OutofcoreOctreeBaseNode<ContainerT, PointT>*,/*Pointer type*/
+    #                                                    const OutofcoreOctreeBaseNode<ContainerT, PointT>&>/*Reference type*/
+        # public:
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT> OctreeDisk;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> OctreeDiskNode;
+        # 
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT>::BranchNode BranchNode;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT>::LeafNode LeafNode;
+        # 
+        # typedef typename OctreeDisk::OutofcoreNodeType OutofcoreNodeType;
+        # 
+        # explicit OutofcoreIteratorBase (OctreeDisk& octree_arg) : octree_ (octree_arg), currentNode_ (NULL)
+        # virtual ~OutofcoreIteratorBase ()
+        # 
+        # OutofcoreIteratorBase (const OutofcoreIteratorBase& src) : octree_ (src.octree_), currentNode_ (src.currentNode_)
+        # 
+        # inline OutofcoreIteratorBase& operator = (const OutofcoreIteratorBase& src)
+        # 
+        # inline OutofcoreNodeType* operator* () const
+        # virtual inline OutofcoreNodeType* getCurrentOctreeNode () const
+        # 
+        # virtual inline void reset ()
+        # 
+        # inline void setMaxDepth (unsigned int max_depth)
+
+
+###
+
+# outofcore_node_data.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeNodeMetadata 
+    #  *
+    #  *  \brief Encapsulated class to read JSON metadata into memory, and write the JSON metadata for each
+    #  *  node. 
+    #  *
+    #  *  This class encapsulates the outofcore node metadata
+    #  *  serialization/deserialization. At the time it was written,
+    #  *  this depended on cJSON to write JSON objects to disk. This
+    #  *  class can be extended to have arbitrary ascii metadata fields
+    #  *  saved to the metadata object file on disk.
+    #  *
+    #  *  The JSON file is formatted in the following way:
+    #  *  \verbatim
+    #  {
+    #    "version": 3,
+    #    "bb_min":  [xxx,yyy,zzz],
+    #    "bb_max":  [xxx,yyy,zzz],
+    #    "bin":     "path_to_data.pcd"
+    #  }
+    #  \endverbatim
+    #  *
+    #  *  Any properties not stored in the metadata file are computed
+    #  *  when the file is loaded (e.g. \ref midpoint_xyz_). By
+    #  *  convention, the JSON files are stored on disk with .oct_idx
+    #  *  extension.
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  */
+    # class PCL_EXPORTS OutofcoreOctreeNodeMetadata
+        # public:
+        # //public typedefs
+        # typedef boost::shared_ptr<OutofcoreOctreeNodeMetadata> Ptr;
+        # typedef boost::shared_ptr<const OutofcoreOctreeNodeMetadata> ConstPtr;
+        # 
+        # /** \brief Empty constructor */
+        # OutofcoreOctreeNodeMetadata ();
+        # ~OutofcoreOctreeNodeMetadata ();
+        # 
+        # /** \brief Copy constructor */
+        # OutofcoreOctreeNodeMetadata (const OutofcoreOctreeNodeMetadata& orig);
+        # 
+        # /** \brief Get the lower bounding box corner */
+        # const Eigen::Vector3d& getBoundingBoxMin () const;
+        # /** \brief Set the lower bounding box corner */
+        # void setBoundingBoxMin (const Eigen::Vector3d& min_bb);
+        # /** \brief Get the upper bounding box corner */
+        # const Eigen::Vector3d& getBoundingBoxMax () const;
+        # /** \brief Set the upper bounding box corner */
+        # void setBoundingBoxMax (const Eigen::Vector3d& max_bb);
+        # 
+        # /** \brief Get the lower and upper corners of the bounding box enclosing this node */
+        # void getBoundingBox (Eigen::Vector3d &min_bb, Eigen::Vector3d &max_bb) const;
+        # /** \brief Set the lower and upper corners of the bounding box */
+        # void setBoundingBox (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb);
+        # 
+        # /** \brief Get the directory path name; this is the parent_path of  */
+        # const boost::filesystem::path& getDirectoryPathname () const;
+        # /** \brief Set the directory path name */
+        # void setDirectoryPathname (const boost::filesystem::path& directory_pathname);
+        # 
+        # /** \brief Get the path to the PCD file */
+        # const boost::filesystem::path& getPCDFilename () const;
+        # /** \brief Set the point filename; extension .pcd */
+        # void setPCDFilename (const boost::filesystem::path& point_filename);
+        # 
+        # /** \brief et the outofcore version read from the "version" field of the JSON object */
+        # int getOutofcoreVersion () const;
+        # /** \brief Set the outofcore version stored in the "version" field of the JSON object */
+        # void setOutofcoreVersion (const int version);
+        # 
+        # /** \brief Sets the name of the JSON file */
+        # const boost::filesystem::path& getMetadataFilename () const;
+        # /** \brief Gets the name of the JSON file */
+        # void setMetadataFilename (const boost::filesystem::path& path_to_metadata);
+        # 
+        # /** \brief Get the midpoint of this node's bounding box */
+        # const Eigen::Vector3d& getVoxelCenter () const;
+        # 
+        # /** \brief Writes the data to a JSON file located at \ref metadata_filename_ */
+        # void serializeMetadataToDisk ();
+        # 
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # int loadMetadataFromDisk ();
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # int loadMetadataFromDisk (const boost::filesystem::path& path_to_metadata);
+        # 
+        # friend std::ostream& operator<<(std::ostream& os, const OutofcoreOctreeNodeMetadata& metadata_arg);
+        # 
+
+
+###
+
diff --git a/pcl/pcl_outofcore_180.pxd b/pcl/pcl_outofcore_180.pxd
new file mode 100644
index 0000000..f3ad63a
--- /dev/null
+++ b/pcl/pcl_outofcore_180.pxd
@@ -0,0 +1,1581 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+
+###############################################################################
+# Types
+###############################################################################
+
+# # visualization
+# # axis.h
+# class Axes : public Object
+# {
+# public:
+    # 
+    # // Operators
+    # Axes (std::string name, float size = 1.0) : Object (name)
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkAxes> getAxes () const
+    # 
+    # vtkSmartPointer<vtkActor> getAxesActor () const
+
+
+###
+
+# # camera.h
+# class Camera : public Object
+# {
+# public:
+    # // Operators
+    # Camera (std::string name);
+    # Camera (std::string name, vtkSmartPointer<vtkCamera> camera);
+    # 
+    # public:
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkCamera> getCamera () const
+    # 
+    # inline vtkSmartPointer<vtkCameraActor> getCameraActor () const
+    # 
+    # inline vtkSmartPointer<vtkActor> getHullActor () const
+    # 
+    # inline bool getDisplay () const
+    # 
+    # void setDisplay (bool display)
+    # 
+    # void getFrustum (double frustum[])
+    # 
+    # void setProjectionMatrix (const Eigen::Matrix4d &projection_matrix)
+    # 
+    # Eigen::Matrix4d getProjectionMatrix ()
+    # 
+    # void setModelViewMatrix (const Eigen::Matrix4d &model_view_matrix)
+    # 
+    # Eigen::Matrix4d getModelViewMatrix ()
+    # 
+    # Eigen::Matrix4d getViewProjectionMatrix ()
+    # 
+    # Eigen::Vector3d getPosition ()
+    # 
+    # inline void setClippingRange (float near_value = 0.0001f, float far_value = 100000.f)
+    # 
+    # virtual void render (vtkRenderer* renderer);
+    # 
+    # // Methods
+    # void computeFrustum ();
+    # void printFrustum ();
+
+
+###
+
+# common.h
+###
+
+# geometry.h
+# class Geometry : public Object
+# {
+    # protected:
+    # 
+    # // Operators
+    # // -----------------------------------------------------------------------------
+    # Geometry (std::string name) : Object (name)
+    # 
+    # 
+    # public:
+    # virtual ~Geometry () { }
+    # 
+    # public:
+    # // Accessors
+    # virtual vtkSmartPointer<vtkActor> getActor () const
+
+
+###
+
+# grid.h
+# //class Grid : public Geometry
+# class Grid : public Object
+# {
+    # public:
+    # 
+    # // Operators
+    # Grid (std::string name, int size = 10, double spacing = 1.0);
+    # ~Grid () { }
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkRectilinearGrid> getGrid () const
+    # 
+    # vtkSmartPointer<vtkActor> getGridActor () const
+
+
+###
+
+
+# # object.h
+# class Object
+# {
+    # public:
+    # 
+    # // Operators
+    # Object (std::string name);
+    # 
+    # virtual ~Object () { }
+    # 
+    # 
+    # // Accessors
+    # std::string getName () const;
+    # 
+    # void setName (std::string name);
+    # 
+    # virtual void render (vtkRenderer* renderer);
+    # 
+    # bool hasActor (vtkActor *actor);
+    # 
+    # void addActor (vtkActor *actor);
+    # 
+    # void removeActor (vtkActor *actor);
+    # 
+    # vtkSmartPointer<vtkActorCollection> getActors ();
+    # 
+
+
+###
+
+
+# outofcore_cloud.h
+# class OutofcoreCloud : public Object
+# {
+    # // Typedefs
+    # // -----------------------------------------------------------------------------
+    # typedef pcl::PointXYZ PointT;
+    # //    typedef pcl::outofcore::OutofcoreOctreeBase<pcl::outofcore::OutofcoreOctreeDiskContainer<PointT>, PointT> octree_disk;
+    # //    typedef pcl::outofcore::OutofcoreOctreeBaseNode<pcl::outofcore::OutofcoreOctreeDiskContainer<PointT>, PointT> octree_disk_node;
+    # 
+    # typedef pcl::outofcore::OutofcoreOctreeBase<> OctreeDisk;
+    # typedef pcl::outofcore::OutofcoreOctreeBaseNode<> OctreeDiskNode;
+    # //    typedef pcl::outofcore::OutofcoreBreadthFirstIterator<> OctreeBreadthFirstIterator;
+    # 
+    # typedef boost::shared_ptr<OctreeDisk> OctreeDiskPtr;
+    # typedef Eigen::aligned_allocator<PointT> AlignedPointT;
+    # 
+    # typedef std::map<std::string, vtkSmartPointer<vtkActor> > CloudActorMap;
+    # 
+    # public:
+    # 
+    # //    typedef std::map<std::string, vtkSmartPointer<vtkPolyData> > CloudDataCache;
+    # //    typedef std::map<std::string, vtkSmartPointer<vtkPolyData> >::iterator CloudDataCacheIterator;
+    # 
+    # static boost::shared_ptr<boost::thread> pcd_reader_thread;
+    # //static MonitorQueue<std::string> pcd_queue;
+    # 
+    # struct PcdQueueItem
+    # {
+        # PcdQueueItem (std::string pcd_file, float coverage)
+        # 
+        # bool operator< (const PcdQueueItem& rhs) const
+        # 
+        # std::string pcd_file;
+        # float coverage;
+    # };
+    # 
+    # typedef std::priority_queue<PcdQueueItem> PcdQueue;
+    # static PcdQueue pcd_queue;
+    # static boost::mutex pcd_queue_mutex;
+    # static boost::condition pcd_queue_ready;
+    # 
+    # 
+    # 
+    # class CloudDataCacheItem : public LRUCacheItem< vtkSmartPointer<vtkPolyData> >
+    # {
+        # public:
+        # 
+        # CloudDataCacheItem (std::string pcd_file, float coverage, vtkSmartPointer<vtkPolyData> cloud_data, size_t timestamp)
+        # 
+        # virtual size_t sizeOf() const
+        # 
+        # std::string pcd_file;
+        # float coverage;
+    # };
+    # 
+    # 
+    # //    static CloudDataCache cloud_data_map;
+    # //    static boost::mutex cloud_data_map_mutex;
+    # typedef LRUCache<std::string, CloudDataCacheItem> CloudDataCache;
+    # static CloudDataCache cloud_data_cache;
+    # static boost::mutex cloud_data_cache_mutex;
+    # 
+    # static void pcdReaderThread();
+    # 
+    # // Operators
+    # OutofcoreCloud (std::string name, boost::filesystem::path& tree_root);
+    # 
+    # // Methods
+    # void updateVoxelData ();
+    # 
+    # // Accessors
+    # OctreeDiskPtr getOctree ()
+    # 
+    # inline vtkSmartPointer<vtkActor> getVoxelActor () const
+    # 
+    # inline vtkSmartPointer<vtkActorCollection> getCloudActors () const
+    # 
+    # 
+    # void setDisplayDepth (int displayDepth)
+    # 
+    # int getDisplayDepth ()
+    # 
+    # uint64_t getPointsLoaded ()
+    # 
+    # uint64_t getDataLoaded ()
+    # 
+    # Eigen::Vector3d getBoundingBoxMin ()
+    # 
+    # Eigen::Vector3d getBoundingBoxMax ()
+    # 
+    # void setDisplayVoxels (bool display_voxels)
+    # bool getDisplayVoxels()
+    # void setRenderCamera(Camera *render_camera)
+    # int getLodPixelThreshold ()
+    # 
+    # void setLodPixelThreshold (int lod_pixel_threshold)
+    # void increaseLodPixelThreshold ()
+    # void decreaseLodPixelThreshold ()
+    # 
+    # virtual void render (vtkRenderer* renderer);
+
+
+###
+
+
+# scene.h
+# class Scene
+# {
+    # public:
+    # 
+    # // Singleton
+    # static Scene* instance ()
+    # 
+    # // Accessors - Cameras
+    # void addCamera (Camera *camera);
+    # 
+    # std::vector<Camera*> getCameras ();
+    # 
+    # Camera* getCamera (vtkCamera *camera);
+    # 
+    # Camera* getCamera (std::string name);
+    # 
+    # // Accessors - Objects
+    # void addObject (Object *object);
+    # 
+    # Object* getObjectByName (std::string name);
+    # 
+    # std::vector<Object*> getObjects ();
+    # 
+    # // Accessors - Viewports
+    # 
+    # void addViewport (Viewport *viewport);
+    # 
+    # std::vector<Viewport*> getViewports ();
+    # 
+    # 
+    # void lock ()
+    # void unlock ()
+
+
+###
+
+# viewport.h
+# class Viewport
+# {
+    # public:
+    # 
+    # // Operators
+    # Viewport (vtkSmartPointer<vtkRenderWindow> window, double xmin = 0.0, double ymin = 0.0, double xmax = 1.0, double ymax = 1.0);
+    # 
+    # // Accessors
+    # inline vtkSmartPointer<vtkRenderer> getRenderer () const
+    # 
+    # void setCamera (Camera* camera)
+
+
+###
+
+
+# boost.h
+###
+
+
+# cJSON.h
+# /* cJSON Types: */
+# #define cJSON_False 0
+# #define cJSON_True 1
+# #define cJSON_NULL 2
+# #define cJSON_Number 3
+# #define cJSON_String 4
+# #define cJSON_Array 5
+# #define cJSON_Object 6
+#   
+# #define cJSON_IsReference 256
+# 
+# /* The cJSON structure: */
+# typedef struct cJSON {
+#   struct cJSON *next,*prev;   /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+#   struct cJSON *child;        /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+# 
+#   int type;                   /* The type of the item, as above. */
+# 
+#   char *valuestring;          /* The item's string, if type==cJSON_String */
+#   int valueint;               /* The item's number, if type==cJSON_Number */
+#   double valuedouble;         /* The item's number, if type==cJSON_Number */
+# 
+#   char *string;               /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+# } cJSON;
+# 
+# typedef struct cJSON_Hooks {
+#       void *(*malloc_fn)(size_t sz);
+#       void (*free_fn)(void *ptr);
+# } cJSON_Hooks;
+# 
+# /* Supply malloc, realloc and free functions to cJSON */
+# PCLAPI(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+# 
+# 
+# /* Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished. */
+# PCLAPI(cJSON *) cJSON_Parse(const char *value);
+# /* Render a cJSON entity to text for transfer/storage. Free the char* when finished. */
+# PCLAPI(char  *) cJSON_Print(cJSON *item);
+# /* Render a cJSON entity to text for transfer/storage without any formatting. Free the char* when finished. */
+# PCLAPI(char  *) cJSON_PrintUnformatted(cJSON *item);
+# /* Delete a cJSON entity and all subentities. */
+# PCLAPI(void)   cJSON_Delete(cJSON *c);
+# /* Render a cJSON entity to text for transfer/storage. */
+# PCLAPI(void) cJSON_PrintStr(cJSON *item, std::string& s);
+# /* Render a cJSON entity to text for transfer/storage without any formatting. */
+# PCLAPI(void) cJSON_PrintUnformattedStr(cJSON *item, std::string& s);
+# 
+# /* Returns the number of items in an array (or object). */
+# PCLAPI(int)     cJSON_GetArraySize(cJSON *array);
+# /* Retrieve item number "item" from array "array". Returns NULL if unsuccessful. */
+# PCLAPI(cJSON *) cJSON_GetArrayItem(cJSON *array,int item);
+# /* Get item "string" from object. Case insensitive. */
+# PCLAPI(cJSON *) cJSON_GetObjectItem(cJSON *object,const char *string);
+# 
+# /* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+# PCLAPI(const char *) cJSON_GetErrorPtr();
+#   
+# /* These calls create a cJSON item of the appropriate type. */
+# PCLAPI(cJSON *) cJSON_CreateNull();
+# PCLAPI(cJSON *) cJSON_CreateTrue();
+# PCLAPI(cJSON *) cJSON_CreateFalse();
+# PCLAPI(cJSON *) cJSON_CreateBool(int b);
+# PCLAPI(cJSON *) cJSON_CreateNumber(double num);
+# PCLAPI(cJSON *) cJSON_CreateString(const char *string);
+# PCLAPI(cJSON *) cJSON_CreateArray();
+# PCLAPI(cJSON *) cJSON_CreateObject();
+# 
+# /* These utilities create an Array of count items. */
+# PCLAPI(cJSON *) cJSON_CreateIntArray(int *numbers,int count);
+# PCLAPI(cJSON *) cJSON_CreateFloatArray(float *numbers,int count);
+# PCLAPI(cJSON *) cJSON_CreateDoubleArray(double *numbers,int count);
+# PCLAPI(cJSON *) cJSON_CreateStringArray(const char **strings,int count);
+# 
+# /* Append item to the specified array/object. */
+# PCLAPI(void) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+# PCLAPI(void) cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);
+# /* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+# PCLAPI(void) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+# PCLAPI(void) cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item);
+# 
+# /* Remove/Detatch items from Arrays/Objects. */
+# PCLAPI(cJSON *) cJSON_DetachItemFromArray(cJSON *array,int which);
+# PCLAPI(void)    cJSON_DeleteItemFromArray(cJSON *array,int which);
+# PCLAPI(cJSON *) cJSON_DetachItemFromObject(cJSON *object,const char *string);
+# PCLAPI(void)    cJSON_DeleteItemFromObject(cJSON *object,const char *string);
+#   
+# /* Update array items. */
+# PCLAPI(void) cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem);
+# PCLAPI(void) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+# 
+# #define cJSON_AddNullToObject(object,name)    cJSON_AddItemToObject(object, name, cJSON_CreateNull())
+# #define cJSON_AddTrueToObject(object,name)    cJSON_AddItemToObject(object, name, cJSON_CreateTrue())
+# #define cJSON_AddFalseToObject(object,name)       cJSON_AddItemToObject(object, name, cJSON_CreateFalse())
+# #define cJSON_AddNumberToObject(object,name,n)    cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))
+# #define cJSON_AddStringToObject(object,name,s)    cJSON_AddItemToObject(object, name, cJSON_CreateString(s))
+
+
+###
+
+# metadata.h
+# namespace pcl
+# namespace outofcore
+#     
+# /** \class AbstractMetadata
+#  *
+#  *  \brief Abstract interface for outofcore metadata file types
+#  *
+#  *  \ingroup outofcore
+#  *  \author Stephen Fox (foxstephend@gmail.com)
+#  */
+# class PCL_EXPORTS OutofcoreAbstractMetadata
+# {
+    # public:
+    # /** \brief Empty constructor */
+    # OutofcoreAbstractMetadata ()
+    # 
+    # virtual ~OutofcoreAbstractMetadata ()
+    # 
+    # /** \brief Write the metadata in the on-disk format, e.g. JSON. */
+    # virtual void serializeMetadataToDisk () = 0;
+    # 
+    # /** \brief Method which should read and parse metadata and store
+    #  *  it in variables that have public getters and setters*/
+    # virtual int loadMetadataFromDisk (const boost::filesystem::path& path_to_metadata) = 0;
+    # 
+    # /** \brief Should write the same ascii metadata that is saved on
+    #  *   disk, or a human readable format of the metadata in case a binary format is being used */
+    # friend std::ostream& operator<<(std::ostream& os, const OutofcoreAbstractMetadata& metadata_arg);
+
+
+###
+
+# octree_abstract_node_container.h
+# namespace pcl
+# namespace outofcore
+    # template<typename PointT>
+    # class OutofcoreAbstractNodeContainer 
+        # public:
+        # typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        # 
+        # OutofcoreAbstractNodeContainer () : container_ ()
+        # 
+        # OutofcoreAbstractNodeContainer (const boost::filesystem::path&) {}
+        # 
+        # virtual ~OutofcoreAbstractNodeContainer () {}        
+        # virtual void insertRange (const PointT* start, const uint64_t count)=0;
+        # virtual void insertRange (const PointT* const* start, const uint64_t count)=0;
+        # virtual void readRange (const uint64_t start, const uint64_t count, AlignedPointTVector& v)=0;
+        # virtual void readRangeSubSample (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector& v) =0;
+        # virtual bool empty () const=0;
+        # virtual uint64_t size () const =0;
+        # virtual void clear ()=0;
+        # virtual void convertToXYZ (const boost::filesystem::path& path)=0;
+        # virtual PointT operator[] (uint64_t idx) const=0;
+
+
+###
+
+# octree_base.h
+# namespace pcl
+# namespace outofcore
+    # struct OutofcoreParams
+    # {
+    #   std::string node_index_basename_;
+    #   std::string node_container_basename_;
+    #   std::string node_index_extension_;
+    #   std::string node_container_extension_;
+    #   double sample_percent;
+    # };
+    # 
+    # /** \class OutofcoreOctreeBase 
+    #  *  \brief This code defines the octree used for point storage at Urban Robotics. 
+    #  * 
+    #  *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    #  *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    #  *  http://www.urbanrobotics.net/. This code was integrated for the Urban Robotics 
+    #  *  Code Sprint (URCS) by Stephen Fox (foxstephend@gmail.com). Additional development notes can be found at
+    #  *  http://www.pointclouds.org/blog/urcs/.
+    #  *
+    #  *  The primary purpose of this class is an interface to the
+    #  *  recursive traversal (recursion handled by \ref pcl::outofcore::OutofcoreOctreeBaseNode) of the
+    #  *  in-memory/top-level octree structure. The metadata in each node
+    #  *  can be loaded entirely into main memory, from which the tree can be traversed
+    #  *  recursively in this state. This class provides an the interface
+    #  *  for: 
+    #  *               -# Point/Region insertion methods 
+    #  *               -# Frustrum/box/region queries
+    #  *               -# Parameterization of resolution, container type, etc...
+    #  *
+    #  *  For lower-level node access, there is a Depth-First iterator
+    #  *  for traversing the trees with direct access to the nodes. This
+    #  *  can be used for implementing other algorithms, and other
+    #  *  iterators can be written in a similar fashion.
+    #  *
+    #  *  The format of the octree is stored on disk in a hierarchical
+    #  *  octree structure, where .oct_idx are the JSON-based node
+    #  *  metadata files managed by \ref pcl::outofcore::OutofcoreOctreeNodeMetadata,
+    #  *  and .octree is the JSON-based octree metadata file managed by
+    #  *  \ref pcl::outofcore::OutofcoreOctreeBaseMetadata. Children of each node live
+    #  *  in up to eight subdirectories named from 0 to 7, where a
+    #  *  metadata and optionally a pcd file will exist. The PCD files
+    #  *  are stored in compressed binary PCD format, containing all of
+    #  *  the fields existing in the PCLPointCloud2 objects originally
+    #  *  inserted into the out of core object.
+    #  *  
+    #  *  A brief outline of the out of core octree can be seen
+    #  *  below. The files in [brackets] exist only when the LOD are
+    #  *  built.
+    #  *
+    #  *  At this point in time, there is not support for multiple trees
+    #  *  existing in a single directory hierarchy.
+    #  *
+    #  *  \verbatim
+    #  tree_name/
+    #       tree_name.oct_idx
+    #       tree_name.octree
+    #       [tree_name-uuid.pcd]
+    #       0/
+    #            tree_name.oct_idx
+    #            [tree_name-uuid.pcd]
+    #            0/
+    #               ...
+    #            1/
+    #                ...
+    #                  ...
+    #                      0/
+    #                          tree_name.oct_idx
+    #                          tree_name.pcd
+    #       1/
+    #       ...
+    #       7/
+    #  \endverbatim
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Jacob Schloss (jacob.schloss@urbanrobotics.net)
+    #  *  \author Stephen Fox, Urban Robotics Code Sprint (foxstephend@gmail.com)
+    #  *
+    #  */
+    # template<typename ContainerT = OutofcoreOctreeDiskContainer<pcl::PointXYZ>, typename PointT = pcl::PointXYZ>
+    # class OutofcoreOctreeBase
+    # {
+        friend class OutofcoreOctreeBaseNode<ContainerT, PointT>;
+        friend class pcl::outofcore::OutofcoreIteratorBase<PointT, ContainerT>;
+        
+        public:
+        
+        // public typedefs
+        typedef OutofcoreOctreeBase<OutofcoreOctreeDiskContainer<PointT>, PointT > octree_disk;
+        typedef OutofcoreOctreeBaseNode<OutofcoreOctreeDiskContainer<PointT>, PointT > octree_disk_node;
+        
+        typedef OutofcoreOctreeBase<OutofcoreOctreeRamContainer<PointT>, PointT> octree_ram;
+        typedef OutofcoreOctreeBaseNode<OutofcoreOctreeRamContainer<PointT>, PointT> octree_ram_node;
+        
+        typedef OutofcoreOctreeBaseNode<ContainerT, PointT> OutofcoreNodeType;
+        
+        typedef OutofcoreOctreeBaseNode<ContainerT, PointT> BranchNode;
+        typedef OutofcoreOctreeBaseNode<ContainerT, PointT> LeafNode;
+        
+        typedef OutofcoreDepthFirstIterator<PointT, ContainerT> Iterator;
+        typedef const OutofcoreDepthFirstIterator<PointT, ContainerT> ConstIterator;
+        
+        typedef OutofcoreBreadthFirstIterator<PointT, ContainerT> BreadthFirstIterator;
+        typedef const OutofcoreBreadthFirstIterator<PointT, ContainerT> BreadthFirstConstIterator;
+        
+        typedef OutofcoreDepthFirstIterator<PointT, ContainerT> DepthFirstIterator;
+        typedef const OutofcoreDepthFirstIterator<PointT, ContainerT> DepthFirstConstIterator;
+        
+        typedef boost::shared_ptr<OutofcoreOctreeBase<ContainerT, PointT> > Ptr;
+        typedef boost::shared_ptr<const OutofcoreOctreeBase<ContainerT, PointT> > ConstPtr;
+        
+        typedef pcl::PointCloud<PointT> PointCloud;
+        
+        typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        
+        typedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        typedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        
+        typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        
+        // Constructors
+        // -----------------------------------------------------------------------
+        /** \brief Load an existing tree
+         *
+         * If load_all is set, the BB and point count for every node is loaded,
+         * otherwise only the root node is actually created, and the rest will be
+         * generated on insertion or query.
+         *
+         * \param root_node_name Path to the top-level tree/tree.oct_idx metadata file
+         * \param load_all Load entire tree metadata (does not load any points from disk)
+         * \throws PCLException for bad extension (root node metadata must be .oct_idx extension)
+         */
+        OutofcoreOctreeBase (const boost::filesystem::path &root_node_name, const bool load_all);
+        
+        /** \brief Create a new tree
+         *
+         * Create a new tree rootname with specified bounding box; will remove and overwrite existing tree with the same name
+         *
+         * Computes the depth of the tree based on desired leaf , then calls the other constructor.
+         *
+         * \param min Bounding box min
+         * \param max Bounding box max
+         * \param resolution_arg Node dimension in meters (assuming your point data is in meters)
+         * \param root_node_name must end in ".oct_idx" 
+         * \param coord_sys Coordinate system which is stored in the JSON metadata
+         * \throws PCLException if root file extension does not match \ref pcl::outofcore::OutofcoreOctreeBaseNode::node_index_extension
+         */
+        OutofcoreOctreeBase (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const double resolution_arg, const boost::filesystem::path &root_node_name, const std::string &coord_sys);
+        
+        /** \brief Create a new tree; will not overwrite existing tree of same name
+         *
+         * Create a new tree rootname with specified bounding box; will not overwrite an existing tree
+         *
+         * \param max_depth Specifies a fixed number of LODs to generate, which is the depth of the tree
+         * \param min Bounding box min
+         * \param max Bounding box max
+         * \note Bounding box of the tree must be set before inserting any points. The tree \b cannot be resized at this time.
+         * \param root_node_name must end in ".oct_idx" 
+         * \param coord_sys Coordinate system which is stored in the JSON metadata
+         * \throws PCLException if the parent directory has existing children (detects an existing tree)
+         * \throws PCLException if file extension is not ".oct_idx"
+         */
+        OutofcoreOctreeBase (const boost::uint64_t max_depth, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::filesystem::path &root_node_name, const std::string &coord_sys);
+        
+        virtual ~OutofcoreOctreeBase ();
+        
+        // Point/Region INSERTION methods
+        // --------------------------------------------------------------------------------
+        /** \brief Recursively add points to the tree 
+         *  \note shared read_write_mutex lock occurs
+         */
+        boost::uint64_t addDataToLeaf (const AlignedPointTVector &p);
+        
+        /** \brief Copies the points from the point_cloud falling within the bounding box of the octree to the
+         *   out-of-core octree; this is an interface to addDataToLeaf and can be used multiple times.
+         *  \param point_cloud Pointer to the point cloud data to copy to the outofcore octree; Assumes templated
+         *   PointT matches for each.
+         *  \return Number of points successfully copied from the point cloud to the octree.
+         */
+        boost::uint64_t addPointCloud (PointCloudConstPtr point_cloud);
+        
+        /** \brief Recursively copies points from input_cloud into the leaf nodes of the out-of-core octree, and stores them to disk.
+         *
+         * \param[in] input_cloud The cloud of points to be inserted into the out-of-core octree. Note if multiple PCLPointCloud2 objects are added to the tree, this assumes that they all have exactly the same fields.
+         * \param[in] skip_bb_check (default=false) whether to skip the bounding box check on insertion. Note the bounding box check is never skipped in the current implementation.
+         * \return Number of poitns successfully copied from the point cloud to the octree
+         */
+        boost::uint64_t addPointCloud (pcl::PCLPointCloud2::Ptr &input_cloud, const bool skip_bb_check = false);
+        
+        /** \brief Recursively add points to the tree. 
+         *
+         * Recursively add points to the tree. 1/8 of the remaining
+         * points at each LOD are stored at each internal node of the
+         * octree until either (a) runs out of points, in which case
+         * the leaf is not at the maximum depth of the tree, or (b)
+         * a larger set of points falls in the leaf at the maximum depth.
+         * Note unlike the old implementation, multiple
+         * copies of the same point will \b not be added at multiple
+         * LODs as it walks the tree. Once the point is added to the
+         * octree, it is no longer propagated further down the tree.
+         *
+         *\param[in] input_cloud The input cloud of points which will
+         * be copied into the sorted nodes of the out-of-core octree
+         * \return The total number of points added to the out-of-core
+         * octree.
+         */
+        boost::uint64_t addPointCloud_and_genLOD (pcl::PCLPointCloud2::Ptr &input_cloud);
+        
+        boost::uint64_t addPointCloud (pcl::PCLPointCloud2::Ptr &input_cloud);
+        
+        boost::uint64_t addPointCloud_and_genLOD (PointCloudConstPtr point_cloud);
+        
+        /** \brief Recursively add points to the tree subsampling LODs on the way.
+         * shared read_write_mutex lock occurs
+         */
+        boost::uint64_t addDataToLeaf_and_genLOD (AlignedPointTVector &p);
+        
+        // Frustrum/Box/Region REQUESTS/QUERIES: DB Accessors
+        // -----------------------------------------------------------------------
+        void queryFrustum (const double *planes, std::list<std::string>& file_names) const;
+        
+        void queryFrustum (const double *planes, std::list<std::string>& file_names, const boost::uint32_t query_depth) const;
+        
+        void queryFrustum (const double *planes, const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix,
+                            std::list<std::string>& file_names, const boost::uint32_t query_depth) const;
+        
+        // templated PointT methods
+        
+        /** \brief Get a list of file paths at query_depth that intersect with your bounding box specified by \c min and \c max.
+         *  When querying with this method, you may be stuck with extra data (some outside of your query bounds) that reside in the files.
+         *
+         * \param[in] min The minimum corner of the bounding box
+         * \param[in] max The maximum corner of the bounding box
+         * \param[in] query_depth 0 is root, (this->depth) is full
+         * \param[out] bin_name List of paths to point data files (PCD currently) which satisfy the query
+         */
+        void queryBBIntersects (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name) const;
+        
+        /** \brief Get Points in BB, only points inside BB. The query
+         * processes the data at each node, filtering points that fall
+         * out of the query bounds, and returns a single, concatenated
+         * point cloud.
+         *
+         * \param[in] min The minimum corner of the bounding box for querying
+         * \param[in] max The maximum corner of the bounding box for querying
+         * \param[in] query_depth The depth from which point data will be taken
+         *   \note If the LODs of the tree have not been built, you must specify the maximum depth in order to retrieve any data
+         * \param[out] dst The destination vector of points
+         */
+        void queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint64_t query_depth, AlignedPointTVector &dst) const;
+        
+        /** \brief Query all points falling within the input bounding box at \c query_depth and return a PCLPointCloud2 object in \c dst_blob.
+         *
+         * \param[in] min The minimum corner of the input bounding box.
+         * \param[in] max The maximum corner of the input bounding box.
+         * \param[in] query_depth The query depth at which to search for points; only points at this depth are returned
+         * \param[out] dst_blob Storage location for the points satisfying the query.
+         **/
+        void queryBBIncludes (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob) const;
+        
+        /** \brief Returns a random subsample of points within the given bounding box at \c query_depth.
+         *
+         * \param[in] min The minimum corner of the boudning box to query.
+         * \param[out] max The maximum corner of the bounding box to query.
+         * \param[in] query_depth The depth in the tree at which to look for the points. Only returns points within the given bounding box at the specified \c query_depth.
+         * \param[out] dst The destination in which to return the points.
+         * 
+         */
+        void queryBBIncludes_subsample (const Eigen::Vector3d &min, const Eigen::Vector3d &max, uint64_t query_depth, const double percent, AlignedPointTVector &dst) const;
+        
+        // PCLPointCloud2 methods
+        
+        /** \brief Query all points falling within the input bounding box at \c query_depth and return a PCLPointCloud2 object in \c dst_blob.
+         *   If the optional argument for filter is given, points are processed by that filter before returning.
+         *  \param[in] min The minimum corner of the input bounding box.
+         *  \param[in] max The maximum corner of the input bounding box.
+         *  \param[in] query_depth The depth of tree at which to query; only points at this depth are returned
+         *  \param[out] dst_blob The destination in which points within the bounding box are stored.
+         *  \param[in] percent optional sampling percentage which is applied after each time data are read from disk
+         */
+        virtual void queryBoundingBox (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const int query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob, double percent = 1.0);
+        
+        /** \brief Returns list of pcd files from nodes whose bounding boxes intersect with the input bounding box.
+         * \param[in] min The minimum corner of the input bounding box.
+         * \param[in] max The maximum corner of the input bounding box.
+         * \param query_depth
+         * \param[out] filenames The list of paths to the PCD files which can be loaded and processed.
+         */
+        inline virtual void queryBoundingBox (const Eigen::Vector3d &min, const Eigen::Vector3d &max, const int query_depth, std::list<std::string> &filenames) const
+        
+        // Parameterization: getters and setters
+        
+        /** \brief Get the overall bounding box of the outofcore
+         *  octree; this is the same as the bounding box of the \c root_node_ node
+         *  \param min
+         *  \param max
+         */
+        bool getBoundingBox (Eigen::Vector3d &min, Eigen::Vector3d &max) const;
+        
+        /** \brief Get number of points at specified LOD 
+         * \param[in] depth_index the level of detail at which we want the number of points (0 is root, 1, 2,...)
+         * \return number of points in the tree at \b depth
+         */
+        inline boost::uint64_t getNumPointsAtDepth (const boost::uint64_t& depth_index) const
+        
+        /** \brief Queries the number of points in a bounding box 
+         *  \param[in] min The minimum corner of the input bounding box
+         *  \param[out] max The maximum corner of the input bounding box
+         *  \param[in] query_depth The depth of the nodes to restrict the search to (only this depth is searched)
+         *  \param[in] load_from_disk (default true) Whether to load PCD files to count exactly the number of points within the bounding box; setting this to false will return an upper bound by just reading the number of points from the PCD header, even if there may be some points in that node do not fall within the query bounding box.
+         *  \return Number of points in the bounding box at depth \b query_depth
+         **/
+        boost::uint64_t queryBoundingBoxNumPoints (const Eigen::Vector3d& min, const Eigen::Vector3d& max, const int query_depth, bool load_from_disk = true);
+        
+        /** \brief Get number of points at each LOD 
+         * \return vector of number of points in each LOD indexed by each level of depth, 0 to the depth of the tree.
+         */
+        inline const std::vector<boost::uint64_t>& getNumPointsVector () const
+        
+        /** \brief Get number of LODs, which is the height of the tree
+         */
+        inline boost::uint64_t getDepth () const
+        inline boost::uint64_t getTreeDepth () const
+        /** \brief Computes the expected voxel dimensions at the leaves 
+         */
+        bool getBinDimension (double &x, double &y) const;
+        
+        /** \brief gets the side length of an (assumed) perfect cubic voxel.
+         *  \note If the initial bounding box specified in constructing the octree is not square, then this method does not return a sensible value 
+         *  \return the side length of the cubic voxel size at the specified depth
+         */
+        double getVoxelSideLength (const boost::uint64_t& depth) const;
+        
+        /** \brief Gets the smallest (assumed) cubic voxel side lengths. The smallest voxels are located at the max depth of the tree.
+         * \return The side length of a the cubic voxel located at the leaves
+         */
+        double getVoxelSideLength () const
+        
+        /** \brief Get coordinate system tag from the JSON metadata file
+         */
+        const std::string& getCoordSystem () const
+        
+        // Mutators
+        
+        /** \brief Generate multi-resolution LODs for the tree, which are a uniform random sampling all child leafs below the node.
+         */
+        void buildLOD ();
+        
+        /** \brief Prints size of BBox to stdout
+         */ 
+        void printBoundingBox (const size_t query_depth) const;
+        
+        /** \brief Prints the coordinates of the bounding box of the node to stdout */
+        void printBoundingBox (OutofcoreNodeType& node) const;
+        
+        /** \brief Prints size of the bounding boxes to stdou
+         */
+        inline void printBoundingBox() const
+        
+        /** \brief Returns the voxel centers of all existing voxels at \c query_depth
+            \param[out] voxel_centers Vector of PointXYZ voxel centers for nodes that exist at that depth
+            \param[in] query_depth the depth of the tree at which to retrieve occupied/existing voxels
+        */
+        void getOccupiedVoxelCenters(AlignedPointTVector &voxel_centers, size_t query_depth) const;
+        
+        /** \brief Returns the voxel centers of all existing voxels at \c query_depth
+            \param[out] voxel_centers Vector of PointXYZ voxel centers for nodes that exist at that depth
+            \param[in] query_depth the depth of the tree at which to retrieve occupied/existing voxels
+        */
+        void getOccupiedVoxelCenters(std::vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d> > &voxel_centers, size_t query_depth) const;
+        
+        /** \brief Gets the voxel centers of all occupied/existing leaves of the tree */
+        void getOccupiedVoxelCenters(AlignedPointTVector &voxel_centers) const
+        
+        /** \brief Returns the voxel centers of all occupied/existing leaves of the tree 
+         *  \param[out] voxel_centers std::vector of the centers of all occupied leaves of the octree
+         */
+        void getOccupiedVoxelCenters(std::vector<Eigen::Vector3d, Eigen::aligned_allocator<Eigen::Vector3d> > &voxel_centers) const
+        
+        // Serializers
+        
+        /** \brief Save each .bin file as an XYZ file */
+        void convertToXYZ ();
+        
+        /** \brief Write a python script using the vpython module containing all
+         * the bounding boxes */
+        void writeVPythonVisual (const boost::filesystem::path filename);
+        
+        OutofcoreNodeType* getBranchChildPtr (const BranchNode& branch_arg, unsigned char childIdx_arg) const;
+        
+        pcl::Filter<pcl::PCLPointCloud2>::Ptr getLODFilter ();
+        const pcl::Filter<pcl::PCLPointCloud2>::ConstPtr getLODFilter () const;
+        
+        /** \brief Sets the filter to use when building the levels of depth. Recommended filters are pcl::RandomSample<pcl::PCLPointCloud2> or pcl::VoxelGrid */
+        void setLODFilter (const pcl::Filter<pcl::PCLPointCloud2>::Ptr& filter_arg);
+        
+        /** \brief Returns the sample_percent_ used when constructing the LOD. */
+        double getSamplePercent () const
+        
+        /** \brief Sets the sampling percent for constructing LODs. Each LOD gets sample_percent^d points. 
+         * \param[in] sample_percent_arg Percentage between 0 and 1. */
+        inline void setSamplePercent (const double sample_percent_arg)
+
+
+###
+
+# octree_base_node.h
+# namespace pcl
+# namespace outofcore
+    # // Forward Declarations
+    # template<typename ContainerT, typename PointT>
+    # class OutofcoreOctreeBaseNode;
+    # 
+    # template<typename ContainerT, typename PointT>
+    # class OutofcoreOctreeBase;
+    # 
+    # /** \brief Non-class function which creates a single child leaf; used with \ref queryBBIntersects_noload to avoid loading the data from disk */
+    # template<typename ContainerT, typename PointT> OutofcoreOctreeBaseNode<ContainerT, PointT>*
+    # makenode_norec (const boost::filesystem::path &path, OutofcoreOctreeBaseNode<ContainerT, PointT>* super);
+    # 
+    # /** \brief Non-class method which performs a bounding box query without loading any of the point cloud data from disk */
+    # template<typename ContainerT, typename PointT> void
+    # queryBBIntersects_noload (const boost::filesystem::path &root_node, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+    # 
+    # /** \brief Non-class method overload */
+    # template<typename ContainerT, typename PointT> void
+    # queryBBIntersects_noload (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d&, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+    # 
+    # /** \class OutofcoreOctreeBaseNode 
+    #  *
+    #  *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    #  *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    #  *  http://www.urbanrobotics.net/
+    #  *
+    #  *  \brief OutofcoreOctreeBaseNode Class internally representing nodes of an
+    #  *  outofcore octree, with accessors to its data via the \ref
+    #  *  pcl::outofcore::OutofcoreOctreeDiskContainer class or \ref pcl::outofcore::OutofcoreOctreeRamContainer class,
+    #  *  whichever it is templated against.  
+    #  * 
+    #  *  \ingroup outofcore
+    #  *  \author Jacob Schloss (jacob.schloss@urbanrobotics.net)
+    #  *
+    #  */
+    # template<typename ContainerT = OutofcoreOctreeDiskContainer<pcl::PointXYZ>, typename PointT = pcl::PointXYZ>
+    # class OutofcoreOctreeBaseNode : public pcl::octree::OctreeNode
+    # {
+        # friend class OutofcoreOctreeBase<ContainerT, PointT> ;
+        # 
+        # // these methods can be rewritten with the iterators. 
+        # friend OutofcoreOctreeBaseNode<ContainerT, PointT>*
+        # makenode_norec<ContainerT, PointT> (const boost::filesystem::path &path, OutofcoreOctreeBaseNode<ContainerT, PointT>* super);
+        # 
+        # friend void queryBBIntersects_noload<ContainerT, PointT> (const boost::filesystem::path &rootnode, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+        # 
+        # friend void queryBBIntersects_noload<ContainerT, PointT> (OutofcoreOctreeBaseNode<ContainerT, PointT>* current, const Eigen::Vector3d &min, const Eigen::Vector3d &max, const boost::uint32_t query_depth, std::list<std::string> &bin_name);
+        # 
+        # public:
+        # typedef OutofcoreOctreeBase<OutofcoreOctreeDiskContainer < PointT > , PointT > octree_disk;
+        # typedef OutofcoreOctreeBaseNode<OutofcoreOctreeDiskContainer < PointT > , PointT > octree_disk_node;
+        # typedef std::vector<PointT, Eigen::aligned_allocator<PointT> > AlignedPointTVector;
+        # typedef pcl::octree::node_type_t node_type_t;
+        # 
+        # const static std::string node_index_basename;
+        # const static std::string node_container_basename;
+        # const static std::string node_index_extension;
+        # const static std::string node_container_extension;
+        # const static double sample_percent_;
+        # 
+        # /** \brief Empty constructor; sets pointers for children and for bounding boxes to 0
+        #  */
+        # OutofcoreOctreeBaseNode ();
+        # 
+        # /** \brief Create root node and directory */
+        # OutofcoreOctreeBaseNode (const Eigen::Vector3d &bb_min, const Eigen::Vector3d &bb_max, OutofcoreOctreeBase<ContainerT, PointT> * const tree, const boost::filesystem::path &root_name);
+        # 
+        # /** \brief Will recursively delete all children calling recFreeChildrein */
+        # virtual ~OutofcoreOctreeBaseNode ();
+        # 
+        # //query
+        # /** \brief gets the minimum and maximum corner of the bounding box represented by this node
+        #  * \param[out] min_bb returns the minimum corner of the bounding box indexed by 0-->X, 1-->Y, 2-->Z 
+        #  * \param[out] max_bb returns the maximum corner of the bounding box indexed by 0-->X, 1-->Y, 2-->Z 
+        #  */
+        # virtual inline void getBoundingBox (Eigen::Vector3d &min_bb, Eigen::Vector3d &max_bb) const
+        # 
+        # const boost::filesystem::path& getPCDFilename () const
+        # const boost::filesystem::path& getMetadataFilename () const
+        # 
+        # void queryFrustum (const double planes[24], std::list<std::string>& file_names);
+        # void queryFrustum (const double planes[24], std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check = false);
+        # void queryFrustum (const double planes[24], const Eigen::Vector3d &eye, const Eigen::Matrix4d &view_projection_matrix, std::list<std::string>& file_names, const boost::uint32_t query_depth, const bool skip_vfc_check = false);
+        # 
+        # //point extraction
+        # /** \brief Recursively add points that fall into the queried bounding box up to the \b query_depth 
+        #  *
+        #  *  \param[in] min_bb the minimum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] max_bb the maximum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] query_depth the maximum depth to query in the octree for points within the bounding box
+        #  *  \param[out] dst destion of points returned by the queries
+        #  */
+        # virtual void queryBBIncludes (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, size_t query_depth, AlignedPointTVector &dst);
+        # 
+        # /** \brief Recursively add points that fall into the queried bounding box up to the \b query_depth
+        #  *
+        #  *  \param[in] min_bb the minimum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] max_bb the maximum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] query_depth the maximum depth to query in the octree for points within the bounding box
+        #  *  \param[out] dst_blob destion of points returned by the queries
+        #  */
+        # virtual void queryBBIncludes (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, size_t query_depth, const pcl::PCLPointCloud2::Ptr &dst_blob);
+        # 
+        # /** \brief Recursively add points that fall into the queried bounding box up to the \b query_depth 
+        #  *
+        #  *  \param[in] min_bb the minimum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] max_bb the maximum corner of the bounding box, indexed by X,Y,Z coordinates
+        #  *  \param[in] query_depth
+        #  *  \param percent
+        #  *  \param[out] v std::list of points returned by the query
+        #  */
+        # virtual void queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, boost::uint64_t query_depth, const double percent, AlignedPointTVector &v);
+        # virtual void queryBBIncludes_subsample (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, boost::uint64_t query_depth, const pcl::PCLPointCloud2::Ptr& dst_blob, double percent = 1.0);
+        # 
+        # /** \brief Recursive acquires PCD paths to any node with which the queried bounding box intersects (at query_depth only).
+        #  */
+        # virtual void queryBBIntersects (const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const boost::uint32_t query_depth, std::list<std::string> &file_names);
+        # 
+        # /** \brief Write the voxel size to stdout at \c query_depth 
+        #  * \param[in] query_depth The depth at which to print the size of the voxel/bounding boxes
+        #  */
+        # virtual void printBoundingBox (const size_t query_depth) const;
+        # 
+        # /** \brief add point to this node if we are a leaf, or find the leaf below us that is supposed to take the point 
+        #  *  \param[in] p vector of points to add to the leaf
+        #  *  \param[in] skip_bb_check whether to check if the point's coordinates fall within the bounding box
+        #  */
+        # virtual boost::uint64_t addDataToLeaf (const AlignedPointTVector &p, const bool skip_bb_check = true);
+        # 
+        # virtual boost::uint64_t addDataToLeaf (const std::vector<const PointT*> &p, const bool skip_bb_check = true);
+        # 
+        # /** \brief Add a single PCLPointCloud2 object into the octree.
+        #  * \param[in] input_cloud
+        #  * \param[in] skip_bb_check (default = false)
+        #  */
+        # virtual boost::uint64_t addPointCloud (const pcl::PCLPointCloud2::Ptr &input_cloud, const bool skip_bb_check = false);
+        # 
+        # /** \brief Add a single PCLPointCloud2 into the octree and build the subsampled LOD during construction; this method of LOD construction is <b>not</b> multiresolution. Rather, there are no redundant data. */
+        # virtual boost::uint64_t addPointCloud_and_genLOD (const pcl::PCLPointCloud2::Ptr input_cloud); //, const bool skip_bb_check);
+        # 
+        # /** \brief Recursively add points to the leaf and children subsampling LODs
+        #  * on the way down.
+        #  * \note rng_mutex_ lock occurs
+        #  */
+        # virtual boost::uint64_t addDataToLeaf_and_genLOD (const AlignedPointTVector &p, const bool skip_bb_check);
+        # 
+        # /** \brief Write a python visual script to @b file
+        #  * \param[in] file output file stream to write the python visual script
+        #  */
+        # void writeVPythonVisual (std::ofstream &file);
+        # 
+        # virtual int read (pcl::PCLPointCloud2::Ptr &output_cloud);
+        # virtual inline node_type_t getNodeType () const
+        # 
+        # virtual OutofcoreOctreeBaseNode*  deepCopy () const
+        # 
+        # virtual inline size_t getDepth () const
+        # 
+        # /** \brief Returns the total number of children on disk */
+        # virtual size_t getNumChildren () const 
+        # 
+        # /** \brief Count loaded chilren */
+        # virtual size_t getNumLoadedChildren ()  const
+        # 
+        # /** \brief Returns a pointer to the child in octant index_arg */
+        # virtual OutofcoreOctreeBaseNode* getChildPtr (size_t index_arg) const;
+        # 
+        # /** \brief Gets the number of points available in the PCD file */
+        # virtual boost::uint64_t getDataSize () const;
+        # 
+        # inline virtual void clearData ()
+
+
+###
+
+# octree_disk_container.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeDiskContainer
+    # *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    # *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    # *  http://www.urbanrobotics.net/
+    # *
+    # *  \brief Class responsible for serialization and deserialization of out of core point data
+    # *  \ingroup outofcore
+    # *  \author Jacob Schloss (jacob.schloss@urbanrobotics.net)
+    # */
+    # template<typename PointT = pcl::PointXYZ>
+    # class OutofcoreOctreeDiskContainer : public OutofcoreAbstractNodeContainer<PointT>
+    # {
+        # public:
+        # typedef typename OutofcoreAbstractNodeContainer<PointT>::AlignedPointTVector AlignedPointTVector;
+        # 
+        # /** \brief Empty constructor creates disk container and sets filename from random uuid string*/
+        # OutofcoreOctreeDiskContainer ();
+        # 
+        # /** \brief Creates uuid named file or loads existing file
+        #  * If \b dir is a directory, this constructor will create a new
+        #  * uuid named file; if \b dir is an existing file, it will load the
+        #  * file metadata for accessing the tree.
+        #  * \param[in] dir Path to the tree. If it is a directory, it
+        #  * will create the metadata. If it is a file, it will load the metadata into memory.
+        #  */
+        # OutofcoreOctreeDiskContainer (const boost::filesystem::path &dir);
+        # 
+        # /** \brief flushes write buffer, then frees memory */
+        # ~OutofcoreOctreeDiskContainer ();
+        # 
+        # /** \brief provides random access to points based on a linear index
+        #  */
+        # inline PointT operator[] (uint64_t idx) const;
+        # 
+        # /** \brief Adds a single point to the buffer to be written to disk when the buffer grows sufficiently large, the object is destroyed, or the write buffer is manually flushed */
+        # inline void push_back (const PointT& p);
+        # 
+        # /** \brief Inserts a vector of points into the disk data structure */
+        # void insertRange (const AlignedPointTVector& src);
+        # 
+        # /** \brief Inserts a PCLPointCloud2 object directly into the disk container */
+        # void insertRange (const pcl::PCLPointCloud2::Ptr &input_cloud);
+        # 
+        # void insertRange (const PointT* const * start, const uint64_t count);
+        # 
+        # /** \brief This is the primary method for serialization of
+        #  * blocks of point data. This is called by the outofcore
+        #  * octree interface, opens the binary file for appending data,
+        #  * and writes it to disk.
+        #  * \param[in] start address of the first point to insert
+        #  * \param[in] count offset from start of the last point to insert
+        #  */
+        # void insertRange (const PointT* start, const uint64_t count);
+        # 
+        # /** \brief Reads \b count points into memory from the disk container
+        #  * Reads \b count points into memory from the disk container, reading at most 2 million elements at a time
+        #  * \param[in] start index of first point to read from disk
+        #  * \param[in] count offset of last point to read from disk
+        #  * \param[out] dst std::vector as destination for points read from disk into memory
+        #  */
+        # void readRange (const uint64_t start, const uint64_t count, AlignedPointTVector &dst);
+        # 
+        # void readRange (const uint64_t, const uint64_t, pcl::PCLPointCloud2::Ptr &dst);
+        # 
+        # /** \brief Reads the entire point contents from disk into \c output_cloud
+        #  *  \param[out] output_cloud
+        #  */
+        # int read (pcl::PCLPointCloud2::Ptr &output_cloud);
+        # 
+        # /** \brief  grab percent*count random points. points are \b not guaranteed to be
+        #  * unique (could have multiple identical points!)
+        #  * \param[in] start The starting index of points to select
+        #  * \param[in] count The length of the range of points from which to randomly sample 
+        #  *  (i.e. from start to start+count)
+        #  * \param[in] percent The percentage of count that is enough points to make up this random sample
+        #  * \param[out] dst std::vector as destination for randomly sampled points; size will 
+        #  * be percentage*count
+        #  */
+        # void readRangeSubSample (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector &dst);
+        # 
+        # /** \brief Use bernoulli trials to select points. All points selected will be unique.
+        #  * \param[in] start The starting index of points to select
+        #  * \param[in] count The length of the range of points from which to randomly sample 
+        #  *  (i.e. from start to start+count)
+        #  * \param[in] percent The percentage of count that is enough points to make up this random sample
+        #  * \param[out] dst std::vector as destination for randomly sampled points; size will 
+        #  * be percentage*count
+        #  */
+        # void readRangeSubSample_bernoulli (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector& dst);
+        # 
+        # /** \brief Returns the total number of points for which this container is responsible, \c filelen_ + points in \c writebuff_ that have not yet been flushed to the disk
+        #  */
+        # uint64_t size () const
+        # 
+        # /** \brief STL-like empty test
+        #  * \return true if container has no data on disk or waiting to be written in \c writebuff_ */
+        # inline bool empty () const
+        # 
+        # /** \brief Exposed functionality for manually flushing the write buffer during tree creation */
+        # void flush (const bool force_cache_dealloc)
+        # 
+        # /** \brief Returns this objects path name */
+        # inline std::string& path ()
+        # 
+        # inline void clear ()
+        # 
+        # /** \brief write points to disk as ascii
+        #  * \param[in] path
+        #  */
+        # void convertToXYZ (const boost::filesystem::path &path)
+        # 
+        # /** \brief Generate a universally unique identifier (UUID)
+        #  * A mutex lock happens to ensure uniquness
+        #  */
+        # static void getRandomUUIDString (std::string &s);
+        # 
+        # /** \brief Returns the number of points in the PCD file by reading the PCD header. */
+        # boost::uint64_t getDataSize () const;
+
+
+###
+
+# octree_ram_container.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeRamContainer
+    #  *  \brief Storage container class which the outofcore octree base is templated against
+    #  *  \note Code was adapted from the Urban Robotics out of core octree implementation. 
+    #  *  Contact Jacob Schloss <jacob.schloss@urbanrobotics.net> with any questions. 
+    #  *  http://www.urbanrobotics.net/
+    #  * 
+    #  *  \ingroup outofcore
+    #  *  \author Jacob Schloss (jacob.scloss@urbanrobotics.net)
+    #  */
+    # template<typename PointT>
+    # class OutofcoreOctreeRamContainer : public OutofcoreAbstractNodeContainer<PointT>
+    # {
+        # public:
+        # typedef typename OutofcoreAbstractNodeContainer<PointT>::AlignedPointTVector AlignedPointTVector;
+        # 
+        # /** \brief empty contructor (with a path parameter?)
+        #   */
+        # OutofcoreOctreeRamContainer (const boost::filesystem::path&) : container_ () { }
+        # 
+        # /** \brief inserts count number of points into container; uses the container_ type's insert function
+        #   * \param[in] start - address of first point in array
+        #   * \param[in] count - the maximum offset from start of points inserted 
+        #   */
+        # void insertRange (const PointT* start, const uint64_t count);
+        # 
+        # /** \brief inserts count points into container 
+        #   * \param[in] start - address of first point in array
+        #   * \param[in] count - the maximum offset from start of points inserted 
+        #   */
+        # void insertRange (const PointT* const * start, const uint64_t count);
+        # 
+        # void insertRange (AlignedPointTVector& /*p*/)
+        # 
+        # void insertRange (const AlignedPointTVector& /*p*/)
+        # 
+        # /** \brief 
+        #   * \param[in] start Index of first point to return from container
+        #   * \param[in] count Offset (start + count) of the last point to return from container
+        #   * \param[out] v Array of points read from the input range
+        #   */
+        # void readRange (const uint64_t start, const uint64_t count, AlignedPointTVector &v);
+        # 
+        # /** \brief grab percent*count random points. points are NOT
+        #   *   guaranteed to be unique (could have multiple identical points!)
+        #   * \param[in] start Index of first point in range to subsample
+        #   * \param[in] count Offset (start+count) of last point in range to subsample
+        #   * \param[in] percent Percentage of range to return
+        #   * \param[out] v Vector with percent*count uniformly random sampled 
+        #   * points from given input rangerange
+        #   */
+        # void readRangeSubSample (const uint64_t start, const uint64_t count, const double percent, AlignedPointTVector &v);
+        # 
+        # /** \brief returns the size of the vector of points stored in this class */
+        # inline uint64_t size () const
+        # 
+        # inline bool empty () const
+        # 
+        # 
+        # /** \brief clears the vector of points in this class */
+        # inline void clear ()
+        # 
+        # /** \brief Writes ascii x,y,z point data to path.string().c_str()
+        #   *  \param path The path/filename destination of the ascii xyz data
+        #   */
+        # void convertToXYZ (const boost::filesystem::path &path);
+        # 
+        # inline PointT operator[] (uint64_t index) const
+
+
+###
+
+# outofcore.h
+###
+
+
+# outofcore_base_data.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeBaseMetadata 
+    #  *  \brief Encapsulated class to read JSON metadata into memory,
+    #  *  and write the JSON metadata associated with the octree root
+    #  *  node. This is global information that is not the same as the
+    #  *  metadata for the root node. Inherits OutofcoreAbstractMetadata
+    #  *  interface for metadata in \b pcl_outofcore.
+    #  *  This class encapsulates the outofcore base metadata
+    #  *  serialization/deserialization. At the time it was written,
+    #  *  this depended on cJSON to write JSON objects to disk. This
+    #  *  class can be extended to have arbitrary JSON ascii metadata
+    #  *  fields saved to the metadata object file on disk. The class
+    #  *  has been encapuslated to abstract the detailso of the on-disk
+    #  *  format from the outofcore implementation. For example, the
+    #  *  format could be changed to XML/YAML, or any dynamic format at
+    #  *  some point.
+    #  *  The JSON file is formatted in the following way:
+    #  *  \verbatim
+    #  {
+    #    "name": "nameoftree",
+    #    "version": 3,
+    #    "pointtype": "urp",               #(needs to be changed*)
+    #    "lod": 3,                         #(depth of the tree
+    #    "numpts":  [X0, X1, X2, ..., XD], #total number of points at each LOD
+    #    "coord_system": "ECEF"            #the tree is not affected by this value
+    #  }
+    #  \endverbatim
+    #  *
+    #  *  Any properties not stored in the metadata file are computed
+    #  *  when the file is loaded. By convention, and for historical
+    #  *  reasons from the original Urban Robotics implementation, the
+    #  *  JSON file representing the overall tree is a JSON file named
+    #  *  with the ".octree" extension.
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  */
+    # class PCL_EXPORTS OutofcoreOctreeBaseMetadata : public OutofcoreAbstractMetadata
+        # public:
+        # /** \brief Empty constructor */
+        # OutofcoreOctreeBaseMetadata ();
+        # /** \brief Load metadata from disk 
+        #  *
+        #  *  \param[in] path_arg Location of JSON metadata file to load from disk
+        #  */
+        # OutofcoreOctreeBaseMetadata (const boost::filesystem::path& path_arg);
+        # /** \brief Default destructor*/
+        # ~OutofcoreOctreeBaseMetadata ();
+        # 
+        # /** \brief Copy constructor */
+        # OutofcoreOctreeBaseMetadata (const OutofcoreOctreeBaseMetadata& orig);
+        # 
+        # /** \brief et the outofcore version read from the "version" field of the JSON object */
+        # int getOutofcoreVersion () const;
+        # /** \brief Set the outofcore version stored in the "version" field of the JSON object */
+        # void setOutofcoreVersion (const int version);
+        # 
+        # /** \brief Gets the name of the JSON file */
+        # boost::filesystem::path getMetadataFilename () const;
+        # /** \brief Sets the name of the JSON file */
+        # void setMetadataFilename (const boost::filesystem::path& path_to_metadata);
+        #  
+        # /** \brief Writes the data to a JSON file located at \ref metadata_filename_ */
+        # virtual void serializeMetadataToDisk ();
+        # 
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # virtual int loadMetadataFromDisk ();
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # 
+        # virtual int loadMetadataFromDisk (const boost::filesystem::path& path_to_metadata);
+        # 
+        # /** \brief Returns the name of the tree; this is not the same as the filename */
+        # virtual std::string getOctreeName ();
+        # /** \brief Sets the name of the tree */
+        # virtual void setOctreeName (const std::string& name_arg);
+        # 
+        # virtual std::string getPointType ();
+        # /** \brief Sets a single string identifying the point type of this tree */
+        # virtual void setPointType (const std::string& point_type_arg);
+        # 
+        # virtual std::vector<boost::uint64_t>& getLODPoints ();
+        # virtual std::vector<boost::uint64_t> getLODPoints () const;
+        # /** \brief Get the number of points at the given depth */
+        # virtual boost::uint64_t getLODPoints (const boost::uint64_t& depth_index) const;
+        # 
+        # /** \brief Initialize the LOD vector with points all 0 */
+        # virtual void setLODPoints (const boost::uint64_t& depth);
+        # /** \brief Copy a vector of LOD points into this metadata (dangerous!)*/
+        # virtual void setLODPoints (std::vector<boost::uint64_t>& lod_points_arg);
+        # 
+        # /** \brief Set the number of points at lod_index_arg manually 
+        #  *  \param[in] lod_index_arg the depth at which this increments the number of LOD points
+        #  *  \param[in] num_points_arg The number of points to store at that LOD
+        #  *  \param[in] increment If true, increments the number of points at the LOD rather than overwriting the number of points
+        #  */
+        # virtual void setLODPoints (const boost::uint64_t& lod_index_arg, const boost::uint64_t& num_points_arg, const bool increment=true);
+        # 
+        # /** \brief Set information about the coordinate system */
+        # virtual void setCoordinateSystem (const std::string& coordinate_system);
+        # /** \brief Get metadata information about the coordinate system */
+        # virtual std::string getCoordinateSystem () const;
+        # 
+        # /** \brief Set the depth of the tree corresponding to JSON "lod:number". This should always be equal to LOD_num_points_.size()-1 */
+        # virtual void setDepth (const boost::uint64_t& depth_arg);
+        # virtual boost::uint64_t getDepth () const;
+        # 
+        # /** \brief Provide operator overload to stream ascii file data*/
+        # friend std::ostream& operator<<(std::ostream& os, const OutofcoreOctreeBaseMetadata& metadata_arg);
+
+
+###
+
+
+# outofcore_breadth_first_iterator.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreBreadthFirstIterator
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Justin Rosen (jmylesrosen@gmail.com)
+    #  *  \note Code adapted from \ref octree_iterator.h in Module \ref pcl::octree written by Julius Kammerl
+    #  */
+    # template<typename PointT=pcl::PointXYZ, typename ContainerT=OutofcoreOctreeDiskContainer<pcl::PointXYZ> >
+    # class OutofcoreBreadthFirstIterator : public OutofcoreIteratorBase<PointT, ContainerT>
+        # public:
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT> OctreeDisk;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> OctreeDiskNode;
+        # 
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> LeafNode;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> BranchNode;
+        # 
+        # explicit OutofcoreBreadthFirstIterator (OctreeDisk& octree_arg);
+        # virtual ~OutofcoreBreadthFirstIterator ();
+        # 
+        # OutofcoreBreadthFirstIterator& operator++ ();
+        # inline OutofcoreBreadthFirstIterator operator++ (int)
+        # 
+        # virtual inline void reset ()
+        # 
+        # void skipChildVoxels ()
+
+
+###
+
+
+# outofcore_depth_first_iterator.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreDepthFirstIterator
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  *  \note Code adapted from \ref octree_iterator.h in Module \ref pcl::octree written by Julius Kammerl
+    #  */
+    # template<typename PointT=pcl::PointXYZ, typename ContainerT=OutofcoreOctreeDiskContainer<pcl::PointXYZ> >
+    # class OutofcoreDepthFirstIterator : public OutofcoreIteratorBase<PointT, ContainerT>
+        # public:
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT> OctreeDisk;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> OctreeDiskNode;
+        # 
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> LeafNode;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> BranchNode;
+        # 
+        # explicit OutofcoreDepthFirstIterator (OctreeDisk& octree_arg);
+        # 
+        # virtual ~OutofcoreDepthFirstIterator ();
+        
+        OutofcoreDepthFirstIterator& operator++ ();
+        
+        inline OutofcoreDepthFirstIterator operator++ (int)
+        
+        void skipChildVoxels ();
+
+
+###
+
+# outofcore_impl.h
+###
+
+
+# outofcore_iterator_base.h
+# namespace pcl
+# namespace outofcore
+    # /** \brief Abstract octree iterator class
+    #  *  \note This class is based on the octree_iterator written by Julius Kammerl adapted to the outofcore octree. The interface is very similar, but it does \b not inherit the \ref pcl::octree iterator base.
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  */
+    # template<typename PointT, typename ContainerT>
+    # class OutofcoreIteratorBase : public std::iterator<std::forward_iterator_tag,     /*iterator type*/
+    #                                                   const OutofcoreOctreeBaseNode<ContainerT, PointT>,
+    #                                                    void,  /*no defined distance between iterator*/
+    #                                                    const OutofcoreOctreeBaseNode<ContainerT, PointT>*,/*Pointer type*/
+    #                                                    const OutofcoreOctreeBaseNode<ContainerT, PointT>&>/*Reference type*/
+        # public:
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT> OctreeDisk;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBaseNode<ContainerT, PointT> OctreeDiskNode;
+        # 
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT>::BranchNode BranchNode;
+        # typedef typename pcl::outofcore::OutofcoreOctreeBase<ContainerT, PointT>::LeafNode LeafNode;
+        # 
+        # typedef typename OctreeDisk::OutofcoreNodeType OutofcoreNodeType;
+        # 
+        # explicit OutofcoreIteratorBase (OctreeDisk& octree_arg) : octree_ (octree_arg), currentNode_ (NULL)
+        # virtual ~OutofcoreIteratorBase ()
+        # 
+        # OutofcoreIteratorBase (const OutofcoreIteratorBase& src) : octree_ (src.octree_), currentNode_ (src.currentNode_)
+        # 
+        # inline OutofcoreIteratorBase& operator = (const OutofcoreIteratorBase& src)
+        # 
+        # inline OutofcoreNodeType* operator* () const
+        # virtual inline OutofcoreNodeType* getCurrentOctreeNode () const
+        # 
+        # virtual inline void reset ()
+        # 
+        # inline void setMaxDepth (unsigned int max_depth)
+
+
+###
+
+# outofcore_node_data.h
+# namespace pcl
+# namespace outofcore
+    # /** \class OutofcoreOctreeNodeMetadata 
+    #  *
+    #  *  \brief Encapsulated class to read JSON metadata into memory, and write the JSON metadata for each
+    #  *  node. 
+    #  *
+    #  *  This class encapsulates the outofcore node metadata
+    #  *  serialization/deserialization. At the time it was written,
+    #  *  this depended on cJSON to write JSON objects to disk. This
+    #  *  class can be extended to have arbitrary ascii metadata fields
+    #  *  saved to the metadata object file on disk.
+    #  *
+    #  *  The JSON file is formatted in the following way:
+    #  *  \verbatim
+    #  {
+    #    "version": 3,
+    #    "bb_min":  [xxx,yyy,zzz],
+    #    "bb_max":  [xxx,yyy,zzz],
+    #    "bin":     "path_to_data.pcd"
+    #  }
+    #  \endverbatim
+    #  *
+    #  *  Any properties not stored in the metadata file are computed
+    #  *  when the file is loaded (e.g. \ref midpoint_xyz_). By
+    #  *  convention, the JSON files are stored on disk with .oct_idx
+    #  *  extension.
+    #  *
+    #  *  \ingroup outofcore
+    #  *  \author Stephen Fox (foxstephend@gmail.com)
+    #  */
+    # class PCL_EXPORTS OutofcoreOctreeNodeMetadata
+        # public:
+        # //public typedefs
+        # typedef boost::shared_ptr<OutofcoreOctreeNodeMetadata> Ptr;
+        # typedef boost::shared_ptr<const OutofcoreOctreeNodeMetadata> ConstPtr;
+        # 
+        # /** \brief Empty constructor */
+        # OutofcoreOctreeNodeMetadata ();
+        # ~OutofcoreOctreeNodeMetadata ();
+        # 
+        # /** \brief Copy constructor */
+        # OutofcoreOctreeNodeMetadata (const OutofcoreOctreeNodeMetadata& orig);
+        # 
+        # /** \brief Get the lower bounding box corner */
+        # const Eigen::Vector3d& getBoundingBoxMin () const;
+        # /** \brief Set the lower bounding box corner */
+        # void setBoundingBoxMin (const Eigen::Vector3d& min_bb);
+        # /** \brief Get the upper bounding box corner */
+        # const Eigen::Vector3d& getBoundingBoxMax () const;
+        # /** \brief Set the upper bounding box corner */
+        # void setBoundingBoxMax (const Eigen::Vector3d& max_bb);
+        # 
+        # /** \brief Get the lower and upper corners of the bounding box enclosing this node */
+        # void getBoundingBox (Eigen::Vector3d &min_bb, Eigen::Vector3d &max_bb) const;
+        # /** \brief Set the lower and upper corners of the bounding box */
+        # void setBoundingBox (const Eigen::Vector3d& min_bb, const Eigen::Vector3d& max_bb);
+        # 
+        # /** \brief Get the directory path name; this is the parent_path of  */
+        # const boost::filesystem::path& getDirectoryPathname () const;
+        # /** \brief Set the directory path name */
+        # void setDirectoryPathname (const boost::filesystem::path& directory_pathname);
+        # 
+        # /** \brief Get the path to the PCD file */
+        # const boost::filesystem::path& getPCDFilename () const;
+        # /** \brief Set the point filename; extension .pcd */
+        # void setPCDFilename (const boost::filesystem::path& point_filename);
+        # 
+        # /** \brief et the outofcore version read from the "version" field of the JSON object */
+        # int getOutofcoreVersion () const;
+        # /** \brief Set the outofcore version stored in the "version" field of the JSON object */
+        # void setOutofcoreVersion (const int version);
+        # 
+        # /** \brief Sets the name of the JSON file */
+        # const boost::filesystem::path& getMetadataFilename () const;
+        # /** \brief Gets the name of the JSON file */
+        # void setMetadataFilename (const boost::filesystem::path& path_to_metadata);
+        # 
+        # /** \brief Get the midpoint of this node's bounding box */
+        # const Eigen::Vector3d& getVoxelCenter () const;
+        # 
+        # /** \brief Writes the data to a JSON file located at \ref metadata_filename_ */
+        # void serializeMetadataToDisk ();
+        # 
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # int loadMetadataFromDisk ();
+        # /** \brief Loads the data from a JSON file located at \ref metadata_filename_ */
+        # int loadMetadataFromDisk (const boost::filesystem::path& path_to_metadata);
+        # 
+        # friend std::ostream& operator<<(std::ostream& os, const OutofcoreOctreeNodeMetadata& metadata_arg);
+        # 
+
+
+###
+
diff --git a/pcl/pcl_range_image.pxd b/pcl/pcl_range_image.pxd
new file mode 100644
index 0000000..0adea84
--- /dev/null
+++ b/pcl/pcl_range_image.pxd
@@ -0,0 +1,982 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+# Windows Only?
+# FW: Link time errors in RangeImage (with /clr)
+# http://www.pcl-users.org/FW-Link-time-errors-in-RangeImage-with-clr-td3581422.html
+# Linking errors using RangeImagePlanar (no use /clr)
+# http://www.pcl-users.org/Linking-errors-using-RangeImagePlanar-td4036511.html
+# range_image.h
+# class RangeImage : public pcl::PointCloud<PointWithRange>
+cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+    cdef cppclass RangeImage(cpp.PointCloud[cpp.PointWithRange]):
+        RangeImage()
+        # public:
+        
+        # // =====STATIC METHODS=====
+        # brief Get the size of a certain area when seen from the given pose
+        # param viewer_pose an affine matrix defining the pose of the viewer
+        # param center the center of the area
+        # param radius the radius of the area
+        # return the size of the area as viewed according to \a viewer_pose
+        # static inline float getMaxAngleSize (const Eigen::Affine3f& viewer_pose, const Eigen::Vector3f& center, float radius);
+        float getMaxAngleSize (eigen3.Affine3f& viewer_pose, const eigen3.Vector3f& center, float radius)
+        
+        # brief Get Eigen::Vector3f from PointWithRange
+        # param point the input point
+        # return an Eigen::Vector3f representation of the input point
+        # static inline Eigen::Vector3f getEigenVector3f (const PointWithRange& point);
+        eigen3.Vector3f getEigenVector3f (const cpp.PointWithRange& point)
+        
+        # brief Get the transformation that transforms the given coordinate frame into CAMERA_FRAME
+        # param coordinate_frame the input coordinate frame
+        # param transformation the resulting transformation that warps \a coordinate_frame into CAMERA_FRAME
+        # PCL_EXPORTS static void getCoordinateFrameTransformation (RangeImage::CoordinateFrame coordinate_frame, Eigen::Affine3f& transformation);
+        void getCoordinateFrameTransformation (CoordinateFrame2 coordinate_frame, eigen3.Affine3f& transformation)
+        
+        # brief Get the average viewpoint of a point cloud where each point carries viewpoint information as 
+        # vp_x, vp_y, vp_z
+        # param point_cloud the input point cloud
+        # return the average viewpoint (as an Eigen::Vector3f)
+        # template <typename PointCloudTypeWithViewpoints> static Eigen::Vector3f getAverageViewPoint (const PointCloudTypeWithViewpoints& point_cloud);
+        eigen3.Vector3f getAverageViewPoint (const cpp.PointCloud[cpp.PointWithRange]& point_cloud)
+        
+        # brief Check if the provided data includes far ranges and add them to far_ranges
+        # param point_cloud_data a PointCloud2 message containing the input cloud
+        # param far_ranges the resulting cloud containing those points with far ranges
+        # PCL_EXPORTS static void extractFarRanges (const sensor_msgs::PointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges);
+        # void extractFarRanges (const sensor_msgs::PointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges)
+        
+        # // =====METHODS=====
+        # brief Get a boost shared pointer of a copy of this
+        # inline Ptr makeShared () { return Ptr (new RangeImage (*this)); } 
+        # RangeImagePtr_t makeShared ()
+        
+        # brief Reset all values to an empty range image
+        # PCL_EXPORTS void reset ();
+        void reset ()
+        
+        ###
+        # brief Create the depth image from a point cloud
+        # param point_cloud the input point cloud
+        # param angular_resolution the angular difference (in radians) between the individual pixels in the image
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        #
+        # template <typename PointCloudType> void
+        # createFromPointCloud (const PointCloudType& point_cloud, float angular_resolution=pcl::deg2rad (0.5f),
+        #     float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
+        #     const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #     CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #     float min_range=0.0f, int border_size=0);
+        # use Template
+        void createFromPointCloud [PointCloudType](
+            const PointCloudType& point_cloud, 
+            float angular_resolution,
+            float max_angle_width, 
+            float max_angle_height,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame, 
+            float noise_level,
+            float min_range, 
+            int border_size)
+        ###
+        
+        # brief Create the depth image from a point cloud
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                   Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloud (const PointCloudType& point_cloud,
+        #   float angular_resolution_x=pcl::deg2rad (0.5f), float angular_resolution_y=pcl::deg2rad (0.5f),
+        #   float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
+        #   const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #   CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #   float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloud (
+            cpp.PointCloud_t& point_cloud, 
+            float angular_resolution_x,
+            float angular_resolution_y,
+            float max_angle_width, 
+            float max_angle_height,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame, 
+            float noise_level,
+            float min_range, 
+            int border_size)
+        
+        # void createFromPointCloud [PointCloudType](
+        #     cpp.PointCloud[PointCloudType]& point_cloud, 
+        #     float angular_resolution_x,
+        #     float angular_resolution_y,
+        #     float max_angle_width, 
+        #     float max_angle_height,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame, 
+        #     float noise_level,
+        #     float min_range, 
+        #     int border_size)
+        
+        # brief Create the depth image from a point cloud, getting a hint about the size of the scene for aster calculation.
+        # param point_cloud the input point cloud
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param point_cloud_center the center of bounding sphere
+        # param point_cloud_radius the radius of the bounding sphere
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                    Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithKnownSize (const PointCloudType& point_cloud, float angular_resolution,
+        #                                  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
+        #                                  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #                                  CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #                                  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloudWithKnownSize [PointCloudType](
+            PointCloudType& point_cloud,
+            float angular_resolution,
+            const eigen3.Vector3f& point_cloud_center, 
+            float point_cloud_radius,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level, 
+            float min_range, 
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, getting a hint about the size of the scene for 
+        # aster calculation.
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param point_cloud_center the center of bounding sphere
+        # param point_cloud_radius the radius of the bounding sphere
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                    Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithKnownSize (const PointCloudType& point_cloud,
+        #                                  float angular_resolution_x, float angular_resolution_y,
+        #                                  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
+        #                                  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #                                  CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #                                  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        # createFromPointCloudWithKnownSize (
+        #     cpp.PointCloud_t& point_cloud, 
+        #     float angular_resolution_x,
+        #     float angular_resolution_y,
+        #     const eigen3.Vector3f& point_cloud_center,
+        #     float point_cloud_radius,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame,
+        #     float noise_level, 
+        #     float min_range, 
+        #     int border_size)
+        void createFromPointCloudWithKnownSize [PointCloudType](
+            cpp.PointCloud[PointCloudType]& point_cloud, 
+            float angular_resolution_x, float angular_resolution_y,
+            const eigen3.Vector3f& point_cloud_center,
+            float point_cloud_radius,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level, 
+            float min_range, 
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, using the average viewpoint of the points 
+        # (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
+        # param point_cloud the input point cloud
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
+        # with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y 
+        # to the bottom and z to the front)
+        # template <typename PointCloudTypeWithViewpoints> 
+        # void createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud, float angular_resolution,
+        #                                   float max_angle_width, float max_angle_height,
+        #                                   CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                   float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloudWithViewpoints (
+            const cpp.PointCloud_PointWithViewpoint_t& point_cloud,
+            float angular_resolution,
+            float max_angle_width, 
+            float max_angle_height,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level,
+            float min_range,
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, using the average viewpoint of the points 
+        # (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
+        # with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y 
+        # to the bottom and z to the front)
+        # template <typename PointCloudTypeWithViewpoints> 
+        # void createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud,
+        #                                   float angular_resolution_x, float angular_resolution_y,
+        #                                   float max_angle_width, float max_angle_height,
+        #                                   CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                   float min_range=0.0f, int border_size=0);
+        ##
+        void createFromPointCloudWithViewpoints (
+            const cpp.PointCloud_PointWithViewpoint_t& point_cloud,
+            float angular_resolution_x,
+            float angular_resolution_y,
+            float max_angle_width,
+            float max_angle_height,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level,
+            float min_range, 
+            int border_size)
+        
+        # brief Create an empty depth image (filled with unobserved points)
+        # param[in] angular_resolution the angle (in radians) between each sample in the depth image
+        # param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to  Eigen::Affine3f::Identity () )
+        # param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
+        # param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
+        # void createEmpty (float angular_resolution, const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
+        #            RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
+        #            float angle_height=pcl::deg2rad (180.0f));
+        ##
+        void createEmpty (
+            float angular_resolution, 
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float angle_width,
+            float angle_height)
+        
+        # brief Create an empty depth image (filled with unobserved points)
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to  Eigen::Affine3f::Identity () )
+        # param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
+        # param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
+        # 
+        # void createEmpty (float angular_resolution_x, float angular_resolution_y,
+        #            const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
+        #            RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
+        #            float angle_height=pcl::deg2rad (180.0f));
+        ##
+        void createEmpty (
+            float angular_resolution_x, 
+            float angular_resolution_y,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float angle_width,
+            float angle_height)
+        
+        # brief Integrate the given point cloud into the current range image using a z-buffer
+        # param point_cloud the input point cloud
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range
+        # param top    returns the minimum y pixel position in the image where a point was added
+        # param right  returns the maximum x pixel position in the image where a point was added
+        # param bottom returns the maximum y pixel position in the image where a point was added
+        # param top returns the minimum y position in the image where a point was added
+        # param left   returns the minimum x pixel position in the image where a point was added
+        # 
+        # template <typename PointCloudType> void
+        # doZBuffer (const PointCloudType& point_cloud, float noise_level,
+        #            float min_range, int& top, int& right, int& bottom, int& left);
+        ##
+        void doZBuffer [PointCloudType](
+            cpp.PointCloud[PointCloudType]& point_cloud,
+            float noise_level,
+            float min_range, 
+            int& top, 
+            int& right, 
+            int& bottom,
+            int& left)
+        
+        # brief Integrates the given far range measurements into the range image */
+        # PCL_EXPORTS void integrateFarRanges (const PointCloud<PointWithViewpoint>& far_ranges);
+        # integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_t far_ranges)
+        # integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_Ptr_t &far_ranges)
+        void integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_t &far_ranges)
+        
+        # brief Cut the range image to the minimal size so that it still contains all actual range readings.
+        # param border_size allows increase from the minimal size by the specified number of pixels (defaults to 0)
+        # param top if positive, this value overrides the position of the top edge (defaults to -1)
+        # param right if positive, this value overrides the position of the right edge (defaults to -1)
+        # param bottom if positive, this value overrides the position of the bottom edge (defaults to -1)
+        # param left if positive, this value overrides the position of the left edge (defaults to -1)
+        # 
+        # PCL_EXPORTS void cropImage (int border_size=0, int top=-1, int right=-1, int bottom=-1, int left=-1);
+        void cropImage (int border_size, int top, int right, int bottom, int left)
+        
+        # brief Get all the range values in one float array of size width*height  
+        # return a pointer to a new float array containing the range values
+        # note This method allocates a new float array; the caller is responsible for freeing this memory.
+        # PCL_EXPORTS float* getRangesArray () const;
+        float* getRangesArray ()
+        
+        # Getter for the transformation from the world system into the range image system
+        # (the sensor coordinate frame)
+        # inline const Eigen::Affine3f& getTransformationToRangeImageSystem () const { return (to_range_image_system_); }
+        const eigen3.Affine3f& getTransformationToRangeImageSystem ()
+        
+        # Setter for the transformation from the range image system
+        # (the sensor coordinate frame) into the world system
+        # inline void setTransformationToRangeImageSystem (const Eigen::Affine3f& to_range_image_system);
+        void setTransformationToRangeImageSystem (eigen3.Affine3f& to_range_image_system)
+        
+        # Getter for the transformation from the range image system
+        # (the sensor coordinate frame) into the world system
+        # inline const Eigen::Affine3f& getTransformationToWorldSystem () const { return to_world_system_;}
+        const eigen3.Affine3f& getTransformationToWorldSystem ()
+        
+        # Getter for the angular resolution of the range image in x direction in radians per pixel.
+        # Provided for downwards compatability */
+        # inline float getAngularResolution () const { return angular_resolution_x_;}
+        float getAngularResolution ()
+        
+        # Getter for the angular resolution of the range image in x direction in radians per pixel.
+        # inline float getAngularResolutionX () const { return angular_resolution_x_;}
+        float getAngularResolutionX ()
+        
+        # Getter for the angular resolution of the range image in y direction in radians per pixel.
+        # inline float getAngularResolutionY () const { return angular_resolution_y_;}
+        float getAngularResolutionY ()
+        
+        # Getter for the angular resolution of the range image in x and y direction (in radians).
+        # inline void getAngularResolution (float& angular_resolution_x, float& angular_resolution_y) const;
+        void getAngularResolution (float& angular_resolution_x, float& angular_resolution_y)
+        
+        # brief Set the angular resolution of the range image
+        # param angular_resolution the new angular resolution in x and y direction (in radians per pixel)
+        # inline void setAngularResolution (float angular_resolution);
+        void setAngularResolution (float angular_resolution)
+        
+        # brief Set the angular resolution of the range image
+        # param angular_resolution_x the new angular resolution in x direction (in radians per pixel)
+        # param angular_resolution_y the new angular resolution in y direction (in radians per pixel)
+        # inline void setAngularResolution (float angular_resolution_x, float angular_resolution_y)
+        void setAngularResolution (float angular_resolution_x, float angular_resolution_y)
+        
+        # brief Return the 3D point with range at the given image position
+        # param image_x the x coordinate
+        # param image_y the y coordinate
+        # return the point at the specified location (returns unobserved_point if outside of the image bounds)
+        # inline const PointWithRange& getPoint (int image_x, int image_y) const;
+        const cpp.PointWithRange& getPoint (int image_x, int image_y)
+        
+        # brief Non-const-version of getPoint
+        # inline PointWithRange& getPoint (int image_x, int image_y);
+        
+        # Return the 3d point with range at the given image position
+        # inline const PointWithRange& getPoint (float image_x, float image_y) const;
+        const cpp.PointWithRange& getPoint (float image_x, float image_y)
+        
+        # Non-const-version of the above
+        # inline PointWithRange& getPoint (float image_x, float image_y);
+        
+        # brief Return the 3D point with range at the given image position.  This methd performs no error checking
+        # to make sure the specified image position is inside of the image!
+        # param image_x the x coordinate
+        # param image_y the y coordinate
+        # return the point at the specified location (program may fail if the location is outside of the image bounds)
+        # inline const PointWithRange& getPointNoCheck (int image_x, int image_y) const;
+        const cpp.PointWithRange& getPointNoCheck (int image_x, int image_y)
+        
+        # Non-const-version of getPointNoCheck
+        # inline PointWithRange& getPointNoCheck (int image_x, int image_y);
+        
+        # Same as above
+        # inline void getPoint (int image_x, int image_y, Eigen::Vector3f& point) const;
+        
+        # Same as above
+        # inline void getPoint (int index, Eigen::Vector3f& point) const;
+        
+        # Same as above
+        # inline const Eigen::Map<const Eigen::Vector3f>
+        # getEigenVector3f (int x, int y) const;
+        
+        # Same as above
+        # inline const Eigen::Map<const Eigen::Vector3f>
+        # getEigenVector3f (int index) const;
+        
+        # Return the 3d point with range at the given index (whereas index=y*width+x)
+        # inline const PointWithRange& getPoint (int index) const;
+        const cpp.PointWithRange& getPoint (int index)
+        
+        # Calculate the 3D point according to the given image point and range
+        # inline void calculate3DPoint (float image_x, float image_y, float range, PointWithRange& point) const;
+        void calculate3DPoint (float image_x, float image_y, float range, cpp.PointWithRange& point)
+        
+        # Calculate the 3D point according to the given image point and the range value at the closest pixel
+        # inline void calculate3DPoint (float image_x, float image_y, PointWithRange& point) const;
+        inline void calculate3DPoint (float image_x, float image_y, cpp.PointWithRange& point)
+        
+        # Calculate the 3D point according to the given image point and range
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        
+        # Calculate the 3D point according to the given image point and the range value at the closest pixel
+        # inline void calculate3DPoint (float image_x, float image_y, Eigen::Vector3f& point) const;
+        void calculate3DPoint (float image_x, float image_y, eigen3.Vector3f& point)
+        
+        # Recalculate all 3D point positions according to their pixel position and range
+        # PCL_EXPORTS void recalculate3DPointPositions ();
+        void recalculate3DPointPositions ()
+        
+        # Get imagePoint from 3D point in world coordinates
+        # inline virtual void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        # void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y, float& range) const;
+        void getImagePoint (const eigen3.Vector3f& point, int& image_x, int& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y) const;
+        void getImagePoint (const eigen3.Vector3f& point, float& image_x, float& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y) const;
+        void getImagePoint (const eigen3.Vector3f& point, int& image_x, int& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range) const;
+        void getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, float& image_x, float& image_y) const;
+        void getImagePoint (float x, float y, float z, float& image_x, float& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, int& image_x, int& image_y) const;
+        void getImagePoint (float x, float y, float z, int& image_x, int& image_y)
+        
+        # point_in_image will be the point in the image at the position the given point would be. Returns
+        # the range of the given point.
+        # inline float checkPoint (const Eigen::Vector3f& point, PointWithRange& point_in_image) const;
+        float checkPoint (const eigen3.Vector3f& point, cpp.PointWithRange& point_in_image)
+        
+        # Returns the difference in range between the given point and the range of the point in the image
+        # at the position the given point would be.
+        # (Return value is point_in_image.range-given_point.range)
+        # inline float getRangeDifference (const Eigen::Vector3f& point) const;
+        float getRangeDifference (const eigen3.Vector3f& point)
+        
+        # Get the image point corresponding to the given angles
+        # inline void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y) const;
+        void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y)
+        
+        # Get the angles corresponding to the given image point
+        # inline void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y) const;
+        void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y)
+        
+        # Transforms an image point in float values to an image point in int values
+        # inline void real2DToInt2D (float x, float y, int& xInt, int& yInt) const;
+        void real2DToInt2D (float x, float y, int& xInt, int& yInt)
+        
+        # Check if a point is inside of the image
+        # inline bool isInImage (int x, int y) const;
+        bool isInImage (int x, int y)
+        
+        # Check if a point is inside of the image and has a finite range
+        # inline bool isValid (int x, int y) const;
+        bool isValid (int x, int y)
+        
+        # Check if a point has a finite range
+        # inline bool isValid (int index) const;
+        bool isValid (int index)
+        
+        # Check if a point is inside of the image and has either a finite range or a max reading (range=INFINITY)
+        # inline bool isObserved (int x, int y) const;
+        bool isObserved (int x, int y)
+        
+        # Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first!
+        # inline bool isMaxRange (int x, int y) const;
+        bool isMaxRange (int x, int y)
+        
+        # Calculate the normal of an image point using the neighbors with a maximum pixel distance of radius.
+        # step_size determines how many pixels are used. 1 means all, 2 only every second, etc..
+        # Returns false if it was unable to calculate a normal.
+        # inline bool getNormal (int x, int y, int radius, Eigen::Vector3f& normal, int step_size=1) const;
+        bool getNormal (int x, int y, int radius, eigen3.Vector3f& normal, int step_size)
+        
+        # Same as above, but only the no_of_nearest_neighbors points closest to the given point are considered.
+        # inline bool getNormalForClosestNeighbors (int x, int y, int radius, const PointWithRange& point, int no_of_nearest_neighbors, Eigen::Vector3f& normal, int step_size=1) const;
+        bool getNormalForClosestNeighbors (int x, int y, int radius, const cpp.PointWithRange& point,
+                                           int no_of_nearest_neighbors, eigen3.Vector3f& normal, int step_size)
+        
+        # Same as above
+        # inline bool getNormalForClosestNeighbors (int x, int y, int radius, const Eigen::Vector3f& point, int no_of_nearest_neighbors, Eigen::Vector3f& normal, Eigen::Vector3f* point_on_plane=NULL, int step_size=1) const;
+        bool getNormalForClosestNeighbors (int x, int y, int radius, const eigen3.Vector3f& point, int no_of_nearest_neighbors, eigen3.Vector3f& normal, eigen3.Vector3f* point_on_plane, int step_size)
+        
+        # Same as above, using default values
+        # inline bool getNormalForClosestNeighbors (int x, int y, Eigen::Vector3f& normal, int radius=2) const;
+        bool getNormalForClosestNeighbors (int x, int y, eigen3.Vector3f& normal, int radius)
+        
+        # Same as above but extracts some more data and can also return the extracted
+        # information for all neighbors in radius if normal_all_neighbors is not NULL
+        # inline bool getSurfaceInformation (int x, int y, int radius, const Eigen::Vector3f& point,
+        #                        int no_of_closest_neighbors, int step_size,
+        #                        float& max_closest_neighbor_distance_squared,
+        #                        Eigen::Vector3f& normal, Eigen::Vector3f& mean, Eigen::Vector3f& eigen_values,
+        #                        Eigen::Vector3f* normal_all_neighbors=NULL,
+        #                        Eigen::Vector3f* mean_all_neighbors=NULL,
+        #                        Eigen::Vector3f* eigen_values_all_neighbors=NULL) const;
+        ##
+        bool getSurfaceInformation (
+            int x,
+            int y,
+            int radius,
+            const eigen3.Vector3f& point,
+            int no_of_closest_neighbors,
+            int step_size,
+            float& max_closest_neighbor_distance_squared,
+            eigen3.Vector3f& normal, 
+            eigen3.Vector3f& mean,
+            eigen3.Vector3f& eigen_values,
+            eigen3.Vector3f* normal_all_neighbors,
+            eigen3.Vector3f* mean_all_neighbors,
+            eigen3.Vector3f* eigen_values_all_neighbors) const;
+        
+        # // Return the squared distance to the n-th neighbors of the point at x,y
+        # inline float getSquaredDistanceOfNthNeighbor (int x, int y, int radius, int n, int step_size) const;
+        float getSquaredDistanceOfNthNeighbor (
+            int x, int y,
+            int radius,
+            int n, 
+            int step_size)
+        
+        # /** Calculate the impact angle based on the sensor position and the two given points - will return
+        #  * -INFINITY if one of the points is unobserved */
+        # inline float getImpactAngle (const PointWithRange& point1, const PointWithRange& point2) const;
+        float getImpactAngle (
+            const cpp.PointWithRange& point1, 
+            const cpp.PointWithRange& point2)
+        
+        # Same as above
+        # inline float getImpactAngle (int x1, int y1, int x2, int y2) const;
+        float getImpactAngle (int x1, int y1, int x2, int y2)
+        
+        # /** Extract a local normal (with a heuristic not to include background points) and calculate the impact
+        #  *  angle based on this */
+        # inline float getImpactAngleBasedOnLocalNormal (int x, int y, int radius) const;
+        float getImpactAngleBasedOnLocalNormal (int x, int y, int radius)
+        
+        # /** Uses the above function for every point in the image */
+        # PCL_EXPORTS float* getImpactAngleImageBasedOnLocalNormals (int radius) const;
+        float* getImpactAngleImageBasedOnLocalNormals (int radius)
+        
+        # /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
+        #  *  This uses getImpactAngleBasedOnLocalNormal
+        #  *  Will return -INFINITY if no normal could be calculated */
+        # inline float getNormalBasedAcutenessValue (int x, int y, int radius) const;
+        float getNormalBasedAcutenessValue (int x, int y, int radius)
+        
+        # /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
+        #  *  will return -INFINITY if one of the points is unobserved */
+        # inline float getAcutenessValue (const PointWithRange& point1, const PointWithRange& point2) const;
+        float getAcutenessValue (const cpp.PointWithRange& point1, const cpp.PointWithRange& point2)
+        
+        # Same as above
+        # inline float getAcutenessValue (int x1, int y1, int x2, int y2) const;
+        float getAcutenessValue (int x1, int y1, int x2, int y2)
+        
+        # /** Calculate getAcutenessValue for every point */
+        # PCL_EXPORTS void getAcutenessValueImages (int pixel_distance, float*& acuteness_value_image_x, float*& acuteness_value_image_y) const;
+        void getAcutenessValueImages (
+            int pixel_distance,
+            float*& acuteness_value_image_x,
+            float*& acuteness_value_image_y)
+        
+        # Calculates, how much the surface changes at a point. Pi meaning a flat suface and 0.0f would be a needle point
+        # //inline float
+        # //  getSurfaceChange (const PointWithRange& point, const PointWithRange& neighbor1,
+        # //                   const PointWithRange& neighbor2) const;
+        
+        # Calculates, how much the surface changes at a point. 1 meaning a 90deg angle and 0 a flat suface
+        # PCL_EXPORTS float getSurfaceChange (int x, int y, int radius) const;
+        float getSurfaceChange (int x, int y, int radius)
+        
+        # Uses the above function for every point in the image
+        # PCL_EXPORTS float* getSurfaceChangeImage (int radius) const;
+        float* getSurfaceChangeImage (int radius)
+        
+        # Calculates, how much the surface changes at a point. Returns an angle [0.0f, PI] for x and y direction.
+        # A return value of -INFINITY means that a point was unobserved.
+        # inline void getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y) const;
+        void getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y)
+        
+        # Uses the above function for every point in the image
+        # PCL_EXPORTS void getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y) const;
+        void getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y)
+        
+        # Calculates the curvature in a point using pca
+        # inline float getCurvature (int x, int y, int radius, int step_size) const;
+        float getCurvature (int x, int y, int radius, int step_size)
+        
+        # Get the sensor position
+        # inline const Eigen::Vector3f getSensorPos () const;
+        eigen3.Vector3f getSensorPos ()
+        
+        # Sets all -INFINITY values to INFINITY
+        # PCL_EXPORTS void setUnseenToMaxRange ();
+        void setUnseenToMaxRange ()
+        
+        # Getter for image_offset_x_
+        # inline int getImageOffsetX () const
+        # Getter for image_offset_y_
+        # inline int getImageOffsetY () const
+        int getImageOffsetX ()
+        int getImageOffsetY ()
+        
+        # Setter for image offsets
+        # inline void setImageOffsets (int offset_x, int offset_y)
+        # Get a sub part of the complete image as a new range image.
+        # param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
+        #                        This is always according to absolute 0,0 meaning -180,-90
+        #                        and it is already in the system of the new image, so the
+        #                        actual pixel used in the original image is
+        #                        combine_pixels* (image_offset_x-image_offset_x_)
+        # param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
+        # param sub_image_width - width of the new image
+        # param sub_image_height - height of the new image
+        # param combine_pixels - shrinking factor, meaning the new angular resolution
+        #                        is combine_pixels times the old one
+        # param sub_image - the output image
+        # virtual void getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
+        # NG(LNK2001)
+        # void getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage& sub_image)
+        
+        # Get a range image with half the resolution
+        # virtual void getHalfImage (RangeImage& half_image) const;
+        # NG(LNK2001)
+        # void getHalfImage (RangeImage& half_image)
+        
+        # Find the minimum and maximum range in the image
+        # PCL_EXPORTS void getMinMaxRanges (float& min_range, float& max_range) const;
+        void getMinMaxRanges (float& min_range, float& max_range)
+        
+        # This function sets the sensor pose to 0 and transforms all point positions to this local coordinate frame
+        # PCL_EXPORTS void change3dPointsToLocalCoordinateFrame ();
+        void change3dPointsToLocalCoordinateFrame ()
+        
+        # /** Calculate a range patch as the z values of the coordinate frame given by pose.
+        #  *  The patch will have size pixel_size x pixel_size and each pixel
+        #  *  covers world_size/pixel_size meters in the world
+        #  *  You are responsible for deleting the structure afterwards! */
+        # PCL_EXPORTS float* getInterpolatedSurfaceProjection (const Eigen::Affine3f& pose, int pixel_size, float world_size) const;
+        float* getInterpolatedSurfaceProjection (const eigen3.Affine3f& pose, int pixel_size, float world_size)
+        
+        # Same as above, but using the local coordinate frame defined by point and the viewing direction
+        # PCL_EXPORTS float* getInterpolatedSurfaceProjection (const Eigen::Vector3f& point, int pixel_size, float world_size) const;
+        float* getInterpolatedSurfaceProjection (const eigen3.Vector3f& point, int pixel_size, float world_size)
+        
+        # Get the local coordinate frame with 0,0,0 in point, upright and Z as the viewing direction
+        # inline Eigen::Affine3f getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point) const;
+        eigen3.Affine3f getTransformationToViewerCoordinateFrame (const eigen3.Vector3f& point)
+        
+        # Same as above, using a reference for the retrurn value
+        # inline void getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
+        void getTransformationToViewerCoordinateFrame (const eigen3.Vector3f& point, eigen3.Affine3f& transformation)
+        
+        # Same as above, but only returning the rotation
+        # inline void getRotationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
+        void getRotationToViewerCoordinateFrame (const eigen3.Vector3f& point, eigen3.Affine3f& transformation)
+        
+        # Get a local coordinate frame at the given point based on the normal.
+        # PCL_EXPORTS bool getNormalBasedUprightTransformation (const Eigen::Vector3f& point, float max_dist, Eigen::Affine3f& transformation) const;
+        bool getNormalBasedUprightTransformation (const eigen3.Vector3f& point, float max_dist, eigen3.Affine3f& transformation)
+        
+        # Get the integral image of the range values (used for fast blur operations).
+        # You are responsible for deleting it after usage!
+        # PCL_EXPORTS void getIntegralImage (float*& integral_image, int*& valid_points_num_image) const;
+        # void getIntegralImage (float*& integral_image, int*& valid_points_num_image)
+        
+        # /** Get a blurred version of the range image using box filters on the provided integral image*/
+        # PCL_EXPORTS void getBlurredImageUsingIntegralImage (int blur_radius, float* integral_image, int* valid_points_num_image, RangeImage& range_image) const;
+        # void getBlurredImageUsingIntegralImage (int blur_radius, float* integral_image, int* valid_points_num_image, RangeImage& range_image)
+        
+        # /** Get a blurred version of the range image using box filters */
+        # PCL_EXPORTS void getBlurredImage (int blur_radius, RangeImage& range_image) const;
+        # void getBlurredImage (int blur_radius, RangeImage& range_image)
+        
+        # /** Get the squared euclidean distance between the two image points.
+        #  *  Returns -INFINITY if one of the points was not observed */
+        # inline float getEuclideanDistanceSquared (int x1, int y1, int x2, int y2) const;
+        # float getEuclideanDistanceSquared (int x1, int y1, int x2, int y2)
+        
+        # Doing the above for some steps in the given direction and averaging
+        # inline float getAverageEuclideanDistance (int x, int y, int offset_x, int offset_y, int max_steps) const;
+        float getAverageEuclideanDistance (int x, int y, int offset_x, int offset_y, int max_steps)
+        
+        # Project all points on the local plane approximation, thereby smoothing the surface of the scan
+        # PCL_EXPORTS void getRangeImageWithSmoothedSurface (int radius, RangeImage& smoothed_range_image) const;
+        # void getRangeImageWithSmoothedSurface (int radius, RangeImage& smoothed_range_image)
+        
+        # //void getLocalNormals (int radius) const;
+        
+        # /** Calculates the average 3D position of the no_of_points points described by the start
+        #  *  point x,y in the direction delta.
+        #  *  Returns a max range point (range=INFINITY) if the first point is max range and an
+        #  *  unobserved point (range=-INFINITY) if non of the points is observed. */
+        # inline void get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points, PointWithRange& average_point) const;
+        void get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points, cpp.PointWithRange& average_point)
+        
+        # /** Calculates the overlap of two range images given the relative transformation
+        #  *  (from the given image to *this) */
+        # PCL_EXPORTS float getOverlap (const RangeImage& other_range_image, const Eigen::Affine3f& relative_transformation, int search_radius, float max_distance, int pixel_step=1) const;
+        
+        # /** Get the viewing direction for the given point */
+        # inline bool getViewingDirection (int x, int y, Eigen::Vector3f& viewing_direction) const;
+        # bool getViewingDirection (int x, int y, Eigen::Vector3f& viewing_direction) const;
+        
+        # /** Get the viewing direction for the given point */
+        # inline void getViewingDirection (const Eigen::Vector3f& point, Eigen::Vector3f& viewing_direction) const;
+        # void getViewingDirection (const Eigen::Vector3f& point, Eigen::Vector3f& viewing_direction) const;
+        
+        # /** Return a newly created Range image.
+        #  *  Can be reimplmented in derived classes like RangeImagePlanar to return an image of the same type. */
+        # virtual RangeImage* getNew () const { return new RangeImage; }
+        
+        # // =====MEMBER VARIABLES=====
+        # // BaseClass:
+        # //   roslib::Header header;
+        # //   std::vector<PointT> points;
+        # //   uint32_t width;
+        # //   uint32_t height;
+        # //   bool is_dense;
+        # static bool debug; /**< Just for... well... debugging purposes. :-) */
+
+
+ctypedef RangeImage RangeImage_t
+ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+###
+
+# range_image_planar.h
+# class RangeImagePlanar : public RangeImage
+cdef extern from "pcl/range_image/range_image_planar.h" namespace "pcl":
+    cdef cppclass RangeImagePlanar(RangeImage):
+        RangeImagePlanar()
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef RangeImage BaseClass;
+        # typedef boost::shared_ptr<RangeImagePlanar> Ptr;
+        # typedef boost::shared_ptr<const RangeImagePlanar> ConstPtr;
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # PCL_EXPORTS RangeImagePlanar ();
+        # /** Destructor */
+        # PCL_EXPORTS ~RangeImagePlanar ();
+        # /** Return a newly created RangeImagePlanar.
+        #  *  Reimplmentation to return an image of the same type. */
+        # virtual RangeImage*  getNew () const { return new RangeImagePlanar; }
+        
+        # // =====PUBLIC METHODS=====
+        # brief Get a boost shared pointer of a copy of this
+        # inline Ptr makeShared () { return Ptr (new RangeImagePlanar (*this)); } 
+        
+        # brief Create the image from an existing disparity image.
+        # param disparity_image the input disparity image data
+        # param di_width the disparity image width
+        # param di_height the disparity image height
+        # param focal_length the focal length of the primary camera that generated the disparity image
+        # param base_line the baseline of the stereo pair that generated the disparity image
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel. 
+        # 
+        # PCL_EXPORTS void setDisparityImage (const float* disparity_image, int di_width, int di_height, float focal_length, float base_line, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing depth image.
+        # param depth_image the input depth image data as float values
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel.
+        # 
+        # PCL_EXPORTS void
+        # setDepthImage (const float* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
+        #                float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing depth image.
+        # param depth_image the input disparity image data as short values describing millimeters
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel.
+        # 
+        # PCL_EXPORTS void
+        # setDepthImage (const unsigned short* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
+        #                float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing point cloud.
+        # param point_cloud the source point cloud
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param sensor_pose the pose of the virtual depth camera
+        # param coordinate_frame the used coordinate frame of the point cloud
+        # param noise_level what is the typical noise of the sensor - is used for averaging in the z-buffer
+        # param min_range minimum range to consifder points
+        # 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithFixedSize (const PointCloudType& point_cloud,
+        #                                    int di_width, int di_height, float di_center_x, float di_center_y,
+        #                                    float di_focal_length_x, float di_focal_length_y,
+        #                                    const Eigen::Affine3f& sensor_pose,
+        #                                    CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                    float min_range=0.0f);
+        ##
+        
+        # // Since we reimplement some of these overloaded functions, we have to do the following:
+        # using RangeImage::calculate3DPoint;
+        # using RangeImage::getImagePoint;
+        
+        # brief Calculate the 3D point according to the given image point and range
+        # param image_x the x image position
+        # param image_y the y image position
+        # param range the range
+        # param point the resulting 3D point
+        # note Implementation according to planar range images (compared to spherical as in the original)
+        # 
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        ##
+        
+        # brief Calculate the image point and range from the given 3D point
+        # param point the resulting 3D point
+        # param image_x the resulting x image position
+        # param image_y the resulting y image position
+        # param range the resulting range
+        # note Implementation according to planar range images (compared to spherical as in the original)
+        # 
+        # virtual inline void  getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        ##
+        
+        # Get a sub part of the complete image as a new range image.
+        # param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
+        #                         This is always according to absolute 0,0 meaning(-180, -90)
+        #                         and it is already in the system of the new image, so the
+        #                         actual pixel used in the original image is
+        #                         combine_pixels* (image_offset_x-image_offset_x_)
+        # param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
+        # param sub_image_width - width of the new image
+        # param sub_image_height - height of the new image
+        # param combine_pixels - shrinking factor, meaning the new angular resolution
+        #                        is combine_pixels times the old one
+        # param sub_image - the output image
+        # 
+        # PCL_EXPORTS virtual void
+        # getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width,
+        #              int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
+        ##
+        
+        # Get a range image with half the resolution
+        # PCL_EXPORTS virtual void getHalfImage (RangeImage& half_image) const;
+
+
+ctypedef RangeImagePlanar RangeImagePlanar_t
+ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+# enum CoordinateFrame
+# CAMERA_FRAME = 0,
+# LASER_FRAME = 1
+cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+    ctypedef enum CoordinateFrame2 "pcl::RangeImage::CoordinateFrame":
+        COORDINATEFRAME_CAMERA "pcl::RangeImage::CAMERA_FRAME"
+        COORDINATEFRAME_LASER "pcl::RangeImage::LASER_FRAME"
+
+
diff --git a/pcl/pcl_range_image_172.pxd b/pcl/pcl_range_image_172.pxd
new file mode 100644
index 0000000..2e4f64e
--- /dev/null
+++ b/pcl/pcl_range_image_172.pxd
@@ -0,0 +1,1113 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+# FW: Link time errors in RangeImage (with /clr)
+# http://www.pcl-users.org/FW-Link-time-errors-in-RangeImage-with-clr-td3581422.html
+# Linking errors using RangeImagePlanar (no use /clr)
+# http://www.pcl-users.org/Linking-errors-using-RangeImagePlanar-td4036511.html
+# range_image.h
+# class RangeImage : public pcl::PointCloud<PointWithRange>
+cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+    cdef cppclass RangeImage(cpp.PointCloud[cpp.PointWithRange]):
+        RangeImage()
+        # public:
+        
+        # // =====STATIC METHODS=====
+        # brief Get the size of a certain area when seen from the given pose
+        # param viewer_pose an affine matrix defining the pose of the viewer
+        # param center the center of the area
+        # param radius the radius of the area
+        # return the size of the area as viewed according to \a viewer_pose
+        # static inline float getMaxAngleSize (const Eigen::Affine3f& viewer_pose, const Eigen::Vector3f& center, float radius);
+        float getMaxAngleSize (eigen3.Affine3f& viewer_pose, const eigen3.Vector3f& center, float radius)
+        
+        # brief Get Eigen::Vector3f from PointWithRange
+        # param point the input point
+        # return an Eigen::Vector3f representation of the input point
+        # static inline Eigen::Vector3f getEigenVector3f (const PointWithRange& point);
+        eigen3.Vector3f getEigenVector3f (const cpp.PointWithRange& point)
+        
+        # brief Get the transformation that transforms the given coordinate frame into CAMERA_FRAME
+        # param coordinate_frame the input coordinate frame
+        # param transformation the resulting transformation that warps \a coordinate_frame into CAMERA_FRAME
+        # PCL_EXPORTS static void getCoordinateFrameTransformation (RangeImage::CoordinateFrame coordinate_frame, Eigen::Affine3f& transformation);
+        void getCoordinateFrameTransformation (CoordinateFrame2 coordinate_frame, eigen3.Affine3f& transformation)
+        
+        # brief Get the average viewpoint of a point cloud where each point carries viewpoint information as 
+        # vp_x, vp_y, vp_z
+        # param point_cloud the input point cloud
+        # return the average viewpoint (as an Eigen::Vector3f)
+        # template <typename PointCloudTypeWithViewpoints> static Eigen::Vector3f getAverageViewPoint (const PointCloudTypeWithViewpoints& point_cloud);
+        eigen3.Vector3f getAverageViewPoint (const cpp.PointCloud[cpp.PointWithRange]& point_cloud)
+        
+        # brief Check if the provided data includes far ranges and add them to far_ranges
+        # param point_cloud_data a PointCloud2 message containing the input cloud
+        # param far_ranges the resulting cloud containing those points with far ranges
+        # PCL_EXPORTS static void extractFarRanges (const sensor_msgs::PointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges);
+        # void extractFarRanges (const sensor_msgs::PointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges)
+        
+        # // =====METHODS=====
+        # brief Get a boost shared pointer of a copy of this
+        # inline Ptr makeShared () { return Ptr (new RangeImage (*this)); } 
+        # RangeImagePtr_t makeShared ()
+        
+        # brief Reset all values to an empty range image
+        # PCL_EXPORTS void reset ();
+        void reset ()
+        
+        ###
+        # brief Create the depth image from a point cloud
+        # param point_cloud the input point cloud
+        # param angular_resolution the angular difference (in radians) between the individual pixels in the image
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        #
+        # template <typename PointCloudType> void
+        # createFromPointCloud (const PointCloudType& point_cloud, float angular_resolution=pcl::deg2rad (0.5f),
+        #     float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
+        #     const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #     CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #     float min_range=0.0f, int border_size=0);
+        # use Template
+        void createFromPointCloud [PointCloudType](
+            const PointCloudType& point_cloud, 
+            float angular_resolution,
+            float max_angle_width, 
+            float max_angle_height,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame, 
+            float noise_level,
+            float min_range, 
+            int border_size)
+        
+        # void createFromPointCloud (
+        #     cpp.PointCloud_t& point_cloud, 
+        #     float angular_resolution,
+        #     float max_angle_width, 
+        #     float max_angle_height,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame, 
+        #     float noise_level,
+        #     float min_range, 
+        #     int border_size)
+        # 
+        # void createFromPointCloud (
+        #     const cpp.PointCloud_PointXYZI_t& point_cloud, 
+        #     float angular_resolution,
+        #     float max_angle_width, 
+        #     float max_angle_height,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame, 
+        #     float noise_level,
+        #     float min_range, 
+        #     int border_size)
+        # 
+        # void createFromPointCloud (
+        #     const cpp.PointCloud_PointXYZRGBA_t& point_cloud, 
+        #     float angular_resolution,
+        #     float max_angle_width, 
+        #     float max_angle_height,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame, 
+        #     float noise_level,
+        #     float min_range, 
+        #     int border_size)
+        # 
+        # void createFromPointCloud (
+        #     const cpp.PointCloud_PointXYZRGB_t& point_cloud, 
+        #     float angular_resolution,
+        #     float max_angle_width, 
+        #     float max_angle_height,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame, 
+        #     float noise_level,
+        #     float min_range, 
+        #     int border_size)
+        ###
+        
+        # brief Create the depth image from a point cloud
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                   Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloud (const PointCloudType& point_cloud,
+        #   float angular_resolution_x=pcl::deg2rad (0.5f), float angular_resolution_y=pcl::deg2rad (0.5f),
+        #   float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
+        #   const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #   CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #   float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloud (
+            cpp.PointCloud_t& point_cloud, 
+            float angular_resolution_x,
+            float angular_resolution_y,
+            float max_angle_width, 
+            float max_angle_height,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame, 
+            float noise_level,
+            float min_range, 
+            int border_size)
+        
+        # void createFromPointCloud [PointCloudType](
+        #     cpp.PointCloud[PointCloudType]& point_cloud, 
+        #     float angular_resolution_x,
+        #     float angular_resolution_y,
+        #     float max_angle_width, 
+        #     float max_angle_height,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame, 
+        #     float noise_level,
+        #     float min_range, 
+        #     int border_size)
+        
+        # brief Create the depth image from a point cloud, getting a hint about the size of the scene for aster calculation.
+        # param point_cloud the input point cloud
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param point_cloud_center the center of bounding sphere
+        # param point_cloud_radius the radius of the bounding sphere
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                    Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithKnownSize (const PointCloudType& point_cloud, float angular_resolution,
+        #                                  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
+        #                                  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #                                  CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #                                  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloudWithKnownSize [PointCloudType](
+            PointCloudType& point_cloud,
+            float angular_resolution,
+            const eigen3.Vector3f& point_cloud_center, 
+            float point_cloud_radius,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level, 
+            float min_range, 
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, getting a hint about the size of the scene for 
+        # aster calculation.
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param point_cloud_center the center of bounding sphere
+        # param point_cloud_radius the radius of the bounding sphere
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                    Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithKnownSize (const PointCloudType& point_cloud,
+        #                                  float angular_resolution_x, float angular_resolution_y,
+        #                                  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
+        #                                  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #                                  CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #                                  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        # createFromPointCloudWithKnownSize (
+        #     cpp.PointCloud_t& point_cloud, 
+        #     float angular_resolution_x,
+        #     float angular_resolution_y,
+        #     const eigen3.Vector3f& point_cloud_center,
+        #     float point_cloud_radius,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame,
+        #     float noise_level, 
+        #     float min_range, 
+        #     int border_size)
+        void createFromPointCloudWithKnownSize [PointCloudType](
+            cpp.PointCloud[PointCloudType]& point_cloud, 
+            float angular_resolution_x, float angular_resolution_y,
+            const eigen3.Vector3f& point_cloud_center,
+            float point_cloud_radius,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level, 
+            float min_range, 
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, using the average viewpoint of the points 
+        # (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
+        # param point_cloud the input point cloud
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
+        # with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y 
+        # to the bottom and z to the front)
+        # template <typename PointCloudTypeWithViewpoints> 
+        # void createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud, float angular_resolution,
+        #                                   float max_angle_width, float max_angle_height,
+        #                                   CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                   float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloudWithViewpoints (
+            const cpp.PointCloud_PointWithViewpoint_t& point_cloud,
+            float angular_resolution,
+            float max_angle_width, 
+            float max_angle_height,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level,
+            float min_range,
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, using the average viewpoint of the points 
+        # (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
+        # with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y 
+        # to the bottom and z to the front)
+        # template <typename PointCloudTypeWithViewpoints> 
+        # void createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud,
+        #                                   float angular_resolution_x, float angular_resolution_y,
+        #                                   float max_angle_width, float max_angle_height,
+        #                                   CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                   float min_range=0.0f, int border_size=0);
+        ##
+        void createFromPointCloudWithViewpoints (
+            const cpp.PointCloud_PointWithViewpoint_t& point_cloud,
+            float angular_resolution_x,
+            float angular_resolution_y,
+            float max_angle_width,
+            float max_angle_height,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level,
+            float min_range, 
+            int border_size)
+        
+        # brief Create an empty depth image (filled with unobserved points)
+        # param[in] angular_resolution the angle (in radians) between each sample in the depth image
+        # param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to  Eigen::Affine3f::Identity () )
+        # param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
+        # param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
+        # void createEmpty (float angular_resolution, const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
+        #            RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
+        #            float angle_height=pcl::deg2rad (180.0f));
+        ##
+        void createEmpty (
+            float angular_resolution, 
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float angle_width,
+            float angle_height)
+        
+        # brief Create an empty depth image (filled with unobserved points)
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to  Eigen::Affine3f::Identity () )
+        # param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
+        # param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
+        # 
+        # void createEmpty (float angular_resolution_x, float angular_resolution_y,
+        #            const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
+        #            RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
+        #            float angle_height=pcl::deg2rad (180.0f));
+        ##
+        void createEmpty (
+            float angular_resolution_x, 
+            float angular_resolution_y,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float angle_width,
+            float angle_height)
+        
+        # brief Integrate the given point cloud into the current range image using a z-buffer
+        # param point_cloud the input point cloud
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range
+        # param top    returns the minimum y pixel position in the image where a point was added
+        # param right  returns the maximum x pixel position in the image where a point was added
+        # param bottom returns the maximum y pixel position in the image where a point was added
+        # param top returns the minimum y position in the image where a point was added
+        # param left   returns the minimum x pixel position in the image where a point was added
+        # 
+        # template <typename PointCloudType> void
+        # doZBuffer (const PointCloudType& point_cloud, float noise_level,
+        #            float min_range, int& top, int& right, int& bottom, int& left);
+        ##
+        void doZBuffer [PointCloudType](
+            cpp.PointCloud[PointCloudType]& point_cloud,
+            float noise_level,
+            float min_range, 
+            int& top, 
+            int& right, 
+            int& bottom,
+            int& left)
+        
+        # brief Integrates the given far range measurements into the range image */
+        # PCL_EXPORTS void integrateFarRanges (const PointCloud<PointWithViewpoint>& far_ranges);
+        # integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_t far_ranges)
+        # integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_Ptr_t &far_ranges)
+        void integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_t &far_ranges)
+        
+        # brief Cut the range image to the minimal size so that it still contains all actual range readings.
+        # param border_size allows increase from the minimal size by the specified number of pixels (defaults to 0)
+        # param top if positive, this value overrides the position of the top edge (defaults to -1)
+        # param right if positive, this value overrides the position of the right edge (defaults to -1)
+        # param bottom if positive, this value overrides the position of the bottom edge (defaults to -1)
+        # param left if positive, this value overrides the position of the left edge (defaults to -1)
+        # 
+        # PCL_EXPORTS void cropImage (int border_size=0, int top=-1, int right=-1, int bottom=-1, int left=-1);
+        void cropImage (int border_size, int top, int right, int bottom, int left)
+        
+        # brief Get all the range values in one float array of size width*height  
+        # return a pointer to a new float array containing the range values
+        # note This method allocates a new float array; the caller is responsible for freeing this memory.
+        # PCL_EXPORTS float* getRangesArray () const;
+        float* getRangesArray ()
+        
+        # Getter for the transformation from the world system into the range image system
+        # (the sensor coordinate frame)
+        # inline const Eigen::Affine3f& getTransformationToRangeImageSystem () const { return (to_range_image_system_); }
+        const eigen3.Affine3f& getTransformationToRangeImageSystem ()
+        
+        # Setter for the transformation from the range image system
+        # (the sensor coordinate frame) into the world system
+        # inline void setTransformationToRangeImageSystem (const Eigen::Affine3f& to_range_image_system);
+        void setTransformationToRangeImageSystem (eigen3.Affine3f& to_range_image_system)
+        
+        # Getter for the transformation from the range image system
+        # (the sensor coordinate frame) into the world system
+        # inline const Eigen::Affine3f& getTransformationToWorldSystem () const { return to_world_system_;}
+        const eigen3.Affine3f& getTransformationToWorldSystem ()
+        
+        # Getter for the angular resolution of the range image in x direction in radians per pixel.
+        # Provided for downwards compatability */
+        # inline float getAngularResolution () const { return angular_resolution_x_;}
+        float getAngularResolution ()
+        
+        # Getter for the angular resolution of the range image in x direction in radians per pixel.
+        # inline float getAngularResolutionX () const { return angular_resolution_x_;}
+        float getAngularResolutionX ()
+        
+        # Getter for the angular resolution of the range image in y direction in radians per pixel.
+        # inline float getAngularResolutionY () const { return angular_resolution_y_;}
+        float getAngularResolutionY ()
+        
+        # Getter for the angular resolution of the range image in x and y direction (in radians).
+        # inline void getAngularResolution (float& angular_resolution_x, float& angular_resolution_y) const;
+        void getAngularResolution (float& angular_resolution_x, float& angular_resolution_y)
+        
+        # brief Set the angular resolution of the range image
+        # param angular_resolution the new angular resolution in x and y direction (in radians per pixel)
+        # inline void setAngularResolution (float angular_resolution);
+        void setAngularResolution (float angular_resolution)
+        
+        # brief Set the angular resolution of the range image
+        # param angular_resolution_x the new angular resolution in x direction (in radians per pixel)
+        # param angular_resolution_y the new angular resolution in y direction (in radians per pixel)
+        # inline void setAngularResolution (float angular_resolution_x, float angular_resolution_y)
+        void setAngularResolution (float angular_resolution_x, float angular_resolution_y)
+        
+        # brief Return the 3D point with range at the given image position
+        # param image_x the x coordinate
+        # param image_y the y coordinate
+        # return the point at the specified location (returns unobserved_point if outside of the image bounds)
+        # inline const PointWithRange& getPoint (int image_x, int image_y) const;
+        const cpp.PointWithRange& getPoint (int image_x, int image_y)
+        
+        # brief Non-const-version of getPoint
+        # inline PointWithRange& getPoint (int image_x, int image_y);
+        
+        # Return the 3d point with range at the given image position
+        # inline const PointWithRange& getPoint (float image_x, float image_y) const;
+        const cpp.PointWithRange& getPoint (float image_x, float image_y)
+        
+        # Non-const-version of the above
+        # inline PointWithRange& getPoint (float image_x, float image_y);
+        
+        # brief Return the 3D point with range at the given image position.  This methd performs no error checking
+        # to make sure the specified image position is inside of the image!
+        # param image_x the x coordinate
+        # param image_y the y coordinate
+        # return the point at the specified location (program may fail if the location is outside of the image bounds)
+        # inline const PointWithRange& getPointNoCheck (int image_x, int image_y) const;
+        const cpp.PointWithRange& getPointNoCheck (int image_x, int image_y)
+        
+        # Non-const-version of getPointNoCheck
+        # inline PointWithRange& getPointNoCheck (int image_x, int image_y);
+        
+        # Same as above
+        # inline void getPoint (int image_x, int image_y, Eigen::Vector3f& point) const;
+        
+        # Same as above
+        # inline void getPoint (int index, Eigen::Vector3f& point) const;
+        
+        # Same as above
+        # inline const Eigen::Map<const Eigen::Vector3f>
+        # getEigenVector3f (int x, int y) const;
+        
+        # Same as above
+        # inline const Eigen::Map<const Eigen::Vector3f>
+        # getEigenVector3f (int index) const;
+        
+        # Return the 3d point with range at the given index (whereas index=y*width+x)
+        # inline const PointWithRange& getPoint (int index) const;
+        const cpp.PointWithRange& getPoint (int index)
+        
+        # Calculate the 3D point according to the given image point and range
+        # inline void calculate3DPoint (float image_x, float image_y, float range, PointWithRange& point) const;
+        void calculate3DPoint (float image_x, float image_y, float range, cpp.PointWithRange& point)
+        
+        # Calculate the 3D point according to the given image point and the range value at the closest pixel
+        # inline void calculate3DPoint (float image_x, float image_y, PointWithRange& point) const;
+        inline void calculate3DPoint (float image_x, float image_y, cpp.PointWithRange& point)
+        
+        # Calculate the 3D point according to the given image point and range
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        
+        # Calculate the 3D point according to the given image point and the range value at the closest pixel
+        # inline void calculate3DPoint (float image_x, float image_y, Eigen::Vector3f& point) const;
+        void calculate3DPoint (float image_x, float image_y, eigen3.Vector3f& point)
+        
+        # Recalculate all 3D point positions according to their pixel position and range
+        # PCL_EXPORTS void recalculate3DPointPositions ();
+        void recalculate3DPointPositions ()
+        
+        # Get imagePoint from 3D point in world coordinates
+        # inline virtual void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        # void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y, float& range) const;
+        void getImagePoint (const eigen3.Vector3f& point, int& image_x, int& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y) const;
+        void getImagePoint (const eigen3.Vector3f& point, float& image_x, float& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y) const;
+        void getImagePoint (const eigen3.Vector3f& point, int& image_x, int& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range) const;
+        void getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, float& image_x, float& image_y) const;
+        void getImagePoint (float x, float y, float z, float& image_x, float& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, int& image_x, int& image_y) const;
+        void getImagePoint (float x, float y, float z, int& image_x, int& image_y)
+        
+        # point_in_image will be the point in the image at the position the given point would be. Returns
+        # the range of the given point.
+        # inline float checkPoint (const Eigen::Vector3f& point, PointWithRange& point_in_image) const;
+        float checkPoint (const eigen3.Vector3f& point, cpp.PointWithRange& point_in_image)
+        
+        # Returns the difference in range between the given point and the range of the point in the image
+        # at the position the given point would be.
+        # (Return value is point_in_image.range-given_point.range)
+        # inline float getRangeDifference (const Eigen::Vector3f& point) const;
+        float getRangeDifference (const eigen3.Vector3f& point)
+        
+        # Get the image point corresponding to the given angles
+        # inline void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y) const;
+        void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y)
+        
+        # Get the angles corresponding to the given image point
+        # inline void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y) const;
+        void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y)
+        
+        # Transforms an image point in float values to an image point in int values
+        # inline void real2DToInt2D (float x, float y, int& xInt, int& yInt) const;
+        void real2DToInt2D (float x, float y, int& xInt, int& yInt)
+        
+        # Check if a point is inside of the image
+        # inline bool isInImage (int x, int y) const;
+        bool isInImage (int x, int y)
+        
+        # Check if a point is inside of the image and has a finite range
+        # inline bool isValid (int x, int y) const;
+        bool isValid (int x, int y)
+        
+        # Check if a point has a finite range
+        # inline bool isValid (int index) const;
+        bool isValid (int index)
+        
+        # Check if a point is inside of the image and has either a finite range or a max reading (range=INFINITY)
+        # inline bool isObserved (int x, int y) const;
+        bool isObserved (int x, int y)
+        
+        # Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first!
+        # inline bool isMaxRange (int x, int y) const;
+        bool isMaxRange (int x, int y)
+        
+        # Calculate the normal of an image point using the neighbors with a maximum pixel distance of radius.
+        # step_size determines how many pixels are used. 1 means all, 2 only every second, etc..
+        # Returns false if it was unable to calculate a normal.
+        # inline bool getNormal (int x, int y, int radius, Eigen::Vector3f& normal, int step_size=1) const;
+        bool getNormal (int x, int y, int radius, eigen3.Vector3f& normal, int step_size)
+        
+        # Same as above, but only the no_of_nearest_neighbors points closest to the given point are considered.
+        # inline bool getNormalForClosestNeighbors (int x, int y, int radius, const PointWithRange& point, int no_of_nearest_neighbors, Eigen::Vector3f& normal, int step_size=1) const;
+        bool getNormalForClosestNeighbors (int x, int y, int radius, const cpp.PointWithRange& point,
+                                           int no_of_nearest_neighbors, eigen3.Vector3f& normal, int step_size)
+        
+        # Same as above
+        # inline bool getNormalForClosestNeighbors (int x, int y, int radius, const Eigen::Vector3f& point, int no_of_nearest_neighbors, Eigen::Vector3f& normal, Eigen::Vector3f* point_on_plane=NULL, int step_size=1) const;
+        bool getNormalForClosestNeighbors (int x, int y, int radius, const eigen3.Vector3f& point, int no_of_nearest_neighbors, eigen3.Vector3f& normal, eigen3.Vector3f* point_on_plane, int step_size)
+        
+        # Same as above, using default values
+        # inline bool getNormalForClosestNeighbors (int x, int y, Eigen::Vector3f& normal, int radius=2) const;
+        bool getNormalForClosestNeighbors (int x, int y, eigen3.Vector3f& normal, int radius)
+        
+        # Same as above but extracts some more data and can also return the extracted
+        # information for all neighbors in radius if normal_all_neighbors is not NULL
+        # inline bool getSurfaceInformation (int x, int y, int radius, const Eigen::Vector3f& point,
+        #                        int no_of_closest_neighbors, int step_size,
+        #                        float& max_closest_neighbor_distance_squared,
+        #                        Eigen::Vector3f& normal, Eigen::Vector3f& mean, Eigen::Vector3f& eigen_values,
+        #                        Eigen::Vector3f* normal_all_neighbors=NULL,
+        #                        Eigen::Vector3f* mean_all_neighbors=NULL,
+        #                        Eigen::Vector3f* eigen_values_all_neighbors=NULL) const;
+        ##
+        bool getSurfaceInformation (
+            int x,
+            int y,
+            int radius,
+            const eigen3.Vector3f& point,
+            int no_of_closest_neighbors,
+            int step_size,
+            float& max_closest_neighbor_distance_squared,
+            eigen3.Vector3f& normal, 
+            eigen3.Vector3f& mean,
+            eigen3.Vector3f& eigen_values,
+            eigen3.Vector3f* normal_all_neighbors,
+            eigen3.Vector3f* mean_all_neighbors,
+            eigen3.Vector3f* eigen_values_all_neighbors) const;
+        
+        # // Return the squared distance to the n-th neighbors of the point at x,y
+        # inline float getSquaredDistanceOfNthNeighbor (int x, int y, int radius, int n, int step_size) const;
+        float getSquaredDistanceOfNthNeighbor (
+            int x, int y,
+            int radius,
+            int n, 
+            int step_size)
+        
+        # /** Calculate the impact angle based on the sensor position and the two given points - will return
+        #  * -INFINITY if one of the points is unobserved */
+        # inline float getImpactAngle (const PointWithRange& point1, const PointWithRange& point2) const;
+        float getImpactAngle (
+            const cpp.PointWithRange& point1, 
+            const cpp.PointWithRange& point2)
+        
+        # Same as above
+        # inline float getImpactAngle (int x1, int y1, int x2, int y2) const;
+        float getImpactAngle (int x1, int y1, int x2, int y2)
+        
+        # /** Extract a local normal (with a heuristic not to include background points) and calculate the impact
+        #  *  angle based on this */
+        # inline float getImpactAngleBasedOnLocalNormal (int x, int y, int radius) const;
+        float getImpactAngleBasedOnLocalNormal (int x, int y, int radius)
+        
+        # /** Uses the above function for every point in the image */
+        # PCL_EXPORTS float* getImpactAngleImageBasedOnLocalNormals (int radius) const;
+        float* getImpactAngleImageBasedOnLocalNormals (int radius)
+        
+        # /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
+        #  *  This uses getImpactAngleBasedOnLocalNormal
+        #  *  Will return -INFINITY if no normal could be calculated */
+        # inline float getNormalBasedAcutenessValue (int x, int y, int radius) const;
+        float getNormalBasedAcutenessValue (int x, int y, int radius)
+        
+        # /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
+        #  *  will return -INFINITY if one of the points is unobserved */
+        # inline float getAcutenessValue (const PointWithRange& point1, const PointWithRange& point2) const;
+        float getAcutenessValue (const cpp.PointWithRange& point1, const cpp.PointWithRange& point2)
+        
+        # Same as above
+        # inline float getAcutenessValue (int x1, int y1, int x2, int y2) const;
+        float getAcutenessValue (int x1, int y1, int x2, int y2)
+        
+        # /** Calculate getAcutenessValue for every point */
+        # PCL_EXPORTS void getAcutenessValueImages (int pixel_distance, float*& acuteness_value_image_x, float*& acuteness_value_image_y) const;
+        void getAcutenessValueImages (
+            int pixel_distance,
+            float*& acuteness_value_image_x,
+            float*& acuteness_value_image_y)
+        
+        # Calculates, how much the surface changes at a point. Pi meaning a flat suface and 0.0f would be a needle point
+        # //inline float
+        # //  getSurfaceChange (const PointWithRange& point, const PointWithRange& neighbor1,
+        # //                   const PointWithRange& neighbor2) const;
+        
+        # Calculates, how much the surface changes at a point. 1 meaning a 90deg angle and 0 a flat suface
+        # PCL_EXPORTS float getSurfaceChange (int x, int y, int radius) const;
+        float getSurfaceChange (int x, int y, int radius)
+        
+        # Uses the above function for every point in the image
+        # PCL_EXPORTS float* getSurfaceChangeImage (int radius) const;
+        float* getSurfaceChangeImage (int radius)
+        
+        # Calculates, how much the surface changes at a point. Returns an angle [0.0f, PI] for x and y direction.
+        # A return value of -INFINITY means that a point was unobserved.
+        # inline void getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y) const;
+        void getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y)
+        
+        # Uses the above function for every point in the image
+        # PCL_EXPORTS void getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y) const;
+        void getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y)
+        
+        # Calculates the curvature in a point using pca
+        # inline float getCurvature (int x, int y, int radius, int step_size) const;
+        float getCurvature (int x, int y, int radius, int step_size)
+        
+        # Get the sensor position
+        # inline const Eigen::Vector3f getSensorPos () const;
+        eigen3.Vector3f getSensorPos ()
+        
+        # Sets all -INFINITY values to INFINITY
+        # PCL_EXPORTS void setUnseenToMaxRange ();
+        void setUnseenToMaxRange ()
+        
+        # Getter for image_offset_x_
+        # inline int getImageOffsetX () const
+        # Getter for image_offset_y_
+        # inline int getImageOffsetY () const
+        int getImageOffsetX ()
+        int getImageOffsetY ()
+        
+        # Setter for image offsets
+        # inline void setImageOffsets (int offset_x, int offset_y)
+        # Get a sub part of the complete image as a new range image.
+        # param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
+        #                        This is always according to absolute 0,0 meaning -180,-90
+        #                        and it is already in the system of the new image, so the
+        #                        actual pixel used in the original image is
+        #                        combine_pixels* (image_offset_x-image_offset_x_)
+        # param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
+        # param sub_image_width - width of the new image
+        # param sub_image_height - height of the new image
+        # param combine_pixels - shrinking factor, meaning the new angular resolution
+        #                        is combine_pixels times the old one
+        # param sub_image - the output image
+        # virtual void getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
+        # NG(LNK2001)
+        # void getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage& sub_image)
+        
+        # Get a range image with half the resolution
+        # virtual void getHalfImage (RangeImage& half_image) const;
+        # NG(LNK2001)
+        # void getHalfImage (RangeImage& half_image)
+        
+        # Find the minimum and maximum range in the image
+        # PCL_EXPORTS void getMinMaxRanges (float& min_range, float& max_range) const;
+        void getMinMaxRanges (float& min_range, float& max_range)
+        
+        # This function sets the sensor pose to 0 and transforms all point positions to this local coordinate frame
+        # PCL_EXPORTS void change3dPointsToLocalCoordinateFrame ();
+        void change3dPointsToLocalCoordinateFrame ()
+        
+        # /** Calculate a range patch as the z values of the coordinate frame given by pose.
+        #  *  The patch will have size pixel_size x pixel_size and each pixel
+        #  *  covers world_size/pixel_size meters in the world
+        #  *  You are responsible for deleting the structure afterwards! */
+        # PCL_EXPORTS float* getInterpolatedSurfaceProjection (const Eigen::Affine3f& pose, int pixel_size, float world_size) const;
+        float* getInterpolatedSurfaceProjection (const eigen3.Affine3f& pose, int pixel_size, float world_size)
+        
+        # Same as above, but using the local coordinate frame defined by point and the viewing direction
+        # PCL_EXPORTS float* getInterpolatedSurfaceProjection (const Eigen::Vector3f& point, int pixel_size, float world_size) const;
+        float* getInterpolatedSurfaceProjection (const eigen3.Vector3f& point, int pixel_size, float world_size)
+        
+        # Get the local coordinate frame with 0,0,0 in point, upright and Z as the viewing direction
+        # inline Eigen::Affine3f getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point) const;
+        eigen3.Affine3f getTransformationToViewerCoordinateFrame (const eigen3.Vector3f& point)
+        
+        # Same as above, using a reference for the retrurn value
+        # inline void getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
+        void getTransformationToViewerCoordinateFrame (const eigen3.Vector3f& point, eigen3.Affine3f& transformation)
+        
+        # Same as above, but only returning the rotation
+        # inline void getRotationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
+        void getRotationToViewerCoordinateFrame (const eigen3.Vector3f& point, eigen3.Affine3f& transformation)
+        
+        # Get a local coordinate frame at the given point based on the normal.
+        # PCL_EXPORTS bool getNormalBasedUprightTransformation (const Eigen::Vector3f& point, float max_dist, Eigen::Affine3f& transformation) const;
+        bool getNormalBasedUprightTransformation (const eigen3.Vector3f& point, float max_dist, eigen3.Affine3f& transformation)
+        
+        # Get the integral image of the range values (used for fast blur operations).
+        # You are responsible for deleting it after usage!
+        # PCL_EXPORTS void getIntegralImage (float*& integral_image, int*& valid_points_num_image) const;
+        
+        # /** Get a blurred version of the range image using box filters on the provided integral image*/
+        # PCL_EXPORTS void getBlurredImageUsingIntegralImage (int blur_radius, float* integral_image, int* valid_points_num_image, RangeImage& range_image) const;
+        
+        # /** Get a blurred version of the range image using box filters */
+        # PCL_EXPORTS void getBlurredImage (int blur_radius, RangeImage& range_image) const;
+        
+        # /** Get the squared euclidean distance between the two image points.
+        #  *  Returns -INFINITY if one of the points was not observed */
+        # inline float getEuclideanDistanceSquared (int x1, int y1, int x2, int y2) const;
+        
+        # Doing the above for some steps in the given direction and averaging
+        # inline float getAverageEuclideanDistance (int x, int y, int offset_x, int offset_y, int max_steps) const;
+        
+        # Project all points on the local plane approximation, thereby smoothing the surface of the scan
+        # PCL_EXPORTS void getRangeImageWithSmoothedSurface (int radius, RangeImage& smoothed_range_image) const;
+        
+        # //void getLocalNormals (int radius) const;
+        
+        # /** Calculates the average 3D position of the no_of_points points described by the start
+        #  *  point x,y in the direction delta.
+        #  *  Returns a max range point (range=INFINITY) if the first point is max range and an
+        #  *  unobserved point (range=-INFINITY) if non of the points is observed. */
+        # inline void get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points, PointWithRange& average_point) const;
+        void get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points, cpp.PointWithRange& average_point)
+        
+        # /** Calculates the overlap of two range images given the relative transformation
+        #  *  (from the given image to *this) */
+        # PCL_EXPORTS float getOverlap (const RangeImage& other_range_image, const Eigen::Affine3f& relative_transformation, int search_radius, float max_distance, int pixel_step=1) const;
+        
+        # /** Get the viewing direction for the given point */
+        # inline bool getViewingDirection (int x, int y, Eigen::Vector3f& viewing_direction) const;
+        
+        # /** Get the viewing direction for the given point */
+        # inline void getViewingDirection (const Eigen::Vector3f& point, Eigen::Vector3f& viewing_direction) const;
+        
+        # /** Return a newly created Range image.
+        #  *  Can be reimplmented in derived classes like RangeImagePlanar to return an image of the same type. */
+        # virtual RangeImage* getNew () const { return new RangeImage; }
+        
+        # // =====MEMBER VARIABLES=====
+        # // BaseClass:
+        # //   roslib::Header header;
+        # //   std::vector<PointT> points;
+        # //   uint32_t width;
+        # //   uint32_t height;
+        # //   bool is_dense;
+        # static bool debug; /**< Just for... well... debugging purposes. :-) */
+
+
+ctypedef RangeImage RangeImage_t
+ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+###
+
+# range_image_planar.h
+# class RangeImagePlanar : public RangeImage
+cdef extern from "pcl/range_image/range_image_planar.h" namespace "pcl":
+    cdef cppclass RangeImagePlanar(RangeImage):
+        RangeImagePlanar()
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef RangeImage BaseClass;
+        # typedef boost::shared_ptr<RangeImagePlanar> Ptr;
+        # typedef boost::shared_ptr<const RangeImagePlanar> ConstPtr;
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # PCL_EXPORTS RangeImagePlanar ();
+        # /** Destructor */
+        # PCL_EXPORTS ~RangeImagePlanar ();
+        # /** Return a newly created RangeImagePlanar.
+        #  *  Reimplmentation to return an image of the same type. */
+        # virtual RangeImage*  getNew () const { return new RangeImagePlanar; }
+        
+        # // =====PUBLIC METHODS=====
+        # brief Get a boost shared pointer of a copy of this
+        # inline Ptr makeShared () { return Ptr (new RangeImagePlanar (*this)); } 
+        
+        # brief Create the image from an existing disparity image.
+        # param disparity_image the input disparity image data
+        # param di_width the disparity image width
+        # param di_height the disparity image height
+        # param focal_length the focal length of the primary camera that generated the disparity image
+        # param base_line the baseline of the stereo pair that generated the disparity image
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel. 
+        # 
+        # PCL_EXPORTS void setDisparityImage (const float* disparity_image, int di_width, int di_height, float focal_length, float base_line, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing depth image.
+        # param depth_image the input depth image data as float values
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel.
+        # 
+        # PCL_EXPORTS void
+        # setDepthImage (const float* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
+        #                float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing depth image.
+        # param depth_image the input disparity image data as short values describing millimeters
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel.
+        # 
+        # PCL_EXPORTS void
+        # setDepthImage (const unsigned short* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
+        #                float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing point cloud.
+        # param point_cloud the source point cloud
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param sensor_pose the pose of the virtual depth camera
+        # param coordinate_frame the used coordinate frame of the point cloud
+        # param noise_level what is the typical noise of the sensor - is used for averaging in the z-buffer
+        # param min_range minimum range to consifder points
+        # 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithFixedSize (const PointCloudType& point_cloud,
+        #                                    int di_width, int di_height, float di_center_x, float di_center_y,
+        #                                    float di_focal_length_x, float di_focal_length_y,
+        #                                    const Eigen::Affine3f& sensor_pose,
+        #                                    CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                    float min_range=0.0f);
+        ##
+        
+        # // Since we reimplement some of these overloaded functions, we have to do the following:
+        # using RangeImage::calculate3DPoint;
+        # using RangeImage::getImagePoint;
+        
+        # brief Calculate the 3D point according to the given image point and range
+        # param image_x the x image position
+        # param image_y the y image position
+        # param range the range
+        # param point the resulting 3D point
+        # note Implementation according to planar range images (compared to spherical as in the original)
+        # 
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        ##
+        
+        # brief Calculate the image point and range from the given 3D point
+        # param point the resulting 3D point
+        # param image_x the resulting x image position
+        # param image_y the resulting y image position
+        # param range the resulting range
+        # note Implementation according to planar range images (compared to spherical as in the original)
+        # 
+        # virtual inline void  getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        ##
+        
+        # Get a sub part of the complete image as a new range image.
+        # param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
+        #                         This is always according to absolute 0,0 meaning(-180, -90)
+        #                         and it is already in the system of the new image, so the
+        #                         actual pixel used in the original image is
+        #                         combine_pixels* (image_offset_x-image_offset_x_)
+        # param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
+        # param sub_image_width - width of the new image
+        # param sub_image_height - height of the new image
+        # param combine_pixels - shrinking factor, meaning the new angular resolution
+        #                        is combine_pixels times the old one
+        # param sub_image - the output image
+        # 
+        # PCL_EXPORTS virtual void
+        # getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width,
+        #              int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
+        ##
+        
+        # Get a range image with half the resolution
+        # PCL_EXPORTS virtual void getHalfImage (RangeImage& half_image) const;
+
+
+ctypedef RangeImagePlanar RangeImagePlanar_t
+ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+# enum CoordinateFrame
+# CAMERA_FRAME = 0,
+# LASER_FRAME = 1
+cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+    ctypedef enum CoordinateFrame2 "pcl::RangeImage::CoordinateFrame":
+        COORDINATEFRAME_CAMERA "pcl::RangeImage::CAMERA_FRAME"
+        COORDINATEFRAME_LASER "pcl::RangeImage::LASER_FRAME"
+
+
+# bearing_angle_image.h
+# namespace pcl
+# /** \brief class BearingAngleImage is used as an interface to generate Bearing Angle(BA) image.
+# * \author: Qinghua Li (qinghua__li@163.com)
+# */
+# class BearingAngleImage : public pcl::PointCloud<PointXYZRGBA>
+        # public:
+        # // ===== TYPEDEFS =====
+        # typedef pcl::PointCloud<PointXYZRGBA> BaseClass;
+        # 
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # BearingAngleImage ();
+        # /** Destructor */
+        # virtual ~BearingAngleImage ();
+        # 
+        # public:
+        # /** \brief Reset all values to an empty Bearing Angle image */
+        # void reset ();
+        # 
+        # /** \brief Calculate the angle between the laser beam and the segment joining two consecutive
+        #  * measurement points.
+        #  * \param point1
+        #  * \param point2
+        #  */
+        # double getAngle (const PointXYZ &point1, const PointXYZ &point2);
+        # 
+        # /** \brief Transform 3D point cloud into a 2D Bearing Angle(BA) image */
+        # void generateBAImage (PointCloud<PointXYZ>& point_cloud);
+
+
+###
+
+# range_image_spherical.h
+# namespace pcl
+# /** \brief @b RangeImageSpherical is derived from the original range image and uses a slightly different
+# * spherical projection. In the original range image, the image will appear more and more
+# * "scaled down" along the y axis, the further away from the mean line of the image a point is.
+# * This class removes this scaling, which makes it especially suitable for spinning LIDAR sensors
+# * that capure a 360 view, since a rotation of the sensor will now simply correspond to a shift of the
+# * range image. (This class is similar to RangeImagePlanar, but changes less of the behaviour of the base class.)
+# * \author Andreas Muetzel
+# * \ingroup range_image
+# */
+# class RangeImageSpherical : public RangeImage
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef RangeImage BaseClass;
+        # typedef boost::shared_ptr<RangeImageSpherical> Ptr;
+        # typedef boost::shared_ptr<const RangeImageSpherical> ConstPtr;
+        # 
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # PCL_EXPORTS RangeImageSpherical () {}
+        # /** Destructor */
+        # PCL_EXPORTS virtual ~RangeImageSpherical () {}
+        # 
+        # /** Return a newly created RangeImagePlanar.
+        # *  Reimplmentation to return an image of the same type. */
+        # virtual RangeImage* getNew () const { return new RangeImageSpherical; }
+        # 
+        # // =====PUBLIC METHODS=====
+        # /** \brief Get a boost shared pointer of a copy of this */
+        # inline Ptr makeShared () { return Ptr (new RangeImageSpherical (*this)); }
+        # 
+        # // Since we reimplement some of these overloaded functions, we have to do the following:
+        # using RangeImage::calculate3DPoint;
+        # using RangeImage::getImagePoint;
+        # 
+        # /** \brief Calculate the 3D point according to the given image point and range
+        #  * \param image_x the x image position
+        #  * \param image_y the y image position
+        #  * \param range the range
+        #  * \param point the resulting 3D point
+        #  * \note Implementation according to planar range images (compared to spherical as in the original)
+        #  */
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        # 
+        # /** \brief Calculate the image point and range from the given 3D point
+        #  * \param point the resulting 3D point
+        #  * \param image_x the resulting x image position
+        #  * \param image_y the resulting y image position
+        #  * \param range the resulting range
+        #  * \note Implementation according to planar range images (compared to spherical as in the original)
+        #  */
+        # virtual inline void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        # 
+        # /** Get the angles corresponding to the given image point */
+        # inline void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y) const;
+        # 
+        # /** Get the image point corresponding to the given ranges */
+        # inline void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y) const;
+
+
+###
+
diff --git a/pcl/pcl_range_image_180.pxd b/pcl/pcl_range_image_180.pxd
new file mode 100644
index 0000000..5d63fa5
--- /dev/null
+++ b/pcl/pcl_range_image_180.pxd
@@ -0,0 +1,1077 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+cimport eigen as eigen3
+
+# FW: Link time errors in RangeImage (with /clr)
+# http://www.pcl-users.org/FW-Link-time-errors-in-RangeImage-with-clr-td3581422.html
+# Linking errors using RangeImagePlanar (no use /clr)
+# http://www.pcl-users.org/Linking-errors-using-RangeImagePlanar-td4036511.html
+# range_image.h
+# class RangeImage : public pcl::PointCloud<PointWithRange>
+cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+    cdef cppclass RangeImage(cpp.PointCloud[cpp.PointWithRange]):
+        RangeImage()
+        # public:
+        
+        # // =====STATIC METHODS=====
+        # brief Get the size of a certain area when seen from the given pose
+        # param viewer_pose an affine matrix defining the pose of the viewer
+        # param center the center of the area
+        # param radius the radius of the area
+        # return the size of the area as viewed according to \a viewer_pose
+        # static inline float getMaxAngleSize (const Eigen::Affine3f& viewer_pose, const Eigen::Vector3f& center, float radius);
+        float getMaxAngleSize (eigen3.Affine3f& viewer_pose, const eigen3.Vector3f& center, float radius)
+        
+        # brief Get Eigen::Vector3f from PointWithRange
+        # param point the input point
+        # return an Eigen::Vector3f representation of the input point
+        # static inline Eigen::Vector3f getEigenVector3f (const PointWithRange& point);
+        eigen3.Vector3f getEigenVector3f (const cpp.PointWithRange& point)
+        
+        # brief Get the transformation that transforms the given coordinate frame into CAMERA_FRAME
+        # param coordinate_frame the input coordinate frame
+        # param transformation the resulting transformation that warps \a coordinate_frame into CAMERA_FRAME
+        # PCL_EXPORTS static void getCoordinateFrameTransformation (RangeImage::CoordinateFrame coordinate_frame, Eigen::Affine3f& transformation);
+        void getCoordinateFrameTransformation (CoordinateFrame2 coordinate_frame, eigen3.Affine3f& transformation)
+        
+        # brief Get the average viewpoint of a point cloud where each point carries viewpoint information as 
+        # vp_x, vp_y, vp_z
+        # param point_cloud the input point cloud
+        # return the average viewpoint (as an Eigen::Vector3f)
+        # template <typename PointCloudTypeWithViewpoints> static Eigen::Vector3f getAverageViewPoint (const PointCloudTypeWithViewpoints& point_cloud);
+        eigen3.Vector3f getAverageViewPoint (const cpp.PointCloud[cpp.PointWithRange]& point_cloud)
+        
+        # brief Check if the provided data includes far ranges and add them to far_ranges
+        # param point_cloud_data a PointCloud2 message containing the input cloud
+        # param far_ranges the resulting cloud containing those points with far ranges
+        # PCL_EXPORTS static void extractFarRanges (const sensor_msgs::PointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges);
+        # void extractFarRanges (const sensor_msgs::PointCloud2& point_cloud_data, PointCloud<PointWithViewpoint>& far_ranges)
+        
+        # // =====METHODS=====
+        # brief Get a boost shared pointer of a copy of this
+        # inline Ptr makeShared () { return Ptr (new RangeImage (*this)); } 
+        # RangeImagePtr_t makeShared ()
+        
+        # brief Reset all values to an empty range image
+        # PCL_EXPORTS void reset ();
+        void reset ()
+        
+        ###
+        # brief Create the depth image from a point cloud
+        # param point_cloud the input point cloud
+        # param angular_resolution the angular difference (in radians) between the individual pixels in the image
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        #
+        # template <typename PointCloudType> void
+        # createFromPointCloud (const PointCloudType& point_cloud, float angular_resolution=pcl::deg2rad (0.5f),
+        #     float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
+        #     const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #     CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #     float min_range=0.0f, int border_size=0);
+        # use Template
+        void createFromPointCloud [PointCloudType](
+            const PointCloudType& point_cloud, 
+            float angular_resolution,
+            float max_angle_width, 
+            float max_angle_height,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame, 
+            float noise_level,
+            float min_range, 
+            int border_size)
+        ###
+        
+        # brief Create the depth image from a point cloud
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                   Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloud (const PointCloudType& point_cloud,
+        #   float angular_resolution_x=pcl::deg2rad (0.5f), float angular_resolution_y=pcl::deg2rad (0.5f),
+        #   float max_angle_width=pcl::deg2rad (360.0f), float max_angle_height=pcl::deg2rad (180.0f),
+        #   const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #   CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #   float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloud (
+            cpp.PointCloud_t& point_cloud, 
+            float angular_resolution_x,
+            float angular_resolution_y,
+            float max_angle_width, 
+            float max_angle_height,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame, 
+            float noise_level,
+            float min_range, 
+            int border_size)
+        
+        # void createFromPointCloud [PointCloudType](
+        #     cpp.PointCloud[PointCloudType]& point_cloud, 
+        #     float angular_resolution_x,
+        #     float angular_resolution_y,
+        #     float max_angle_width, 
+        #     float max_angle_height,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame, 
+        #     float noise_level,
+        #     float min_range, 
+        #     int border_size)
+        
+        # brief Create the depth image from a point cloud, getting a hint about the size of the scene for aster calculation.
+        # param point_cloud the input point cloud
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param point_cloud_center the center of bounding sphere
+        # param point_cloud_radius the radius of the bounding sphere
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                    Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithKnownSize (const PointCloudType& point_cloud, float angular_resolution,
+        #                                  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
+        #                                  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #                                  CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #                                  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloudWithKnownSize [PointCloudType](
+            PointCloudType& point_cloud,
+            float angular_resolution,
+            const eigen3.Vector3f& point_cloud_center, 
+            float point_cloud_radius,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level, 
+            float min_range, 
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, getting a hint about the size of the scene for 
+        # aster calculation.
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param point_cloud_center the center of bounding sphere
+        # param point_cloud_radius the radius of the bounding sphere
+        # param sensor_pose an affine matrix defining the pose of the sensor (defaults to
+        #                    Eigen::Affine3f::Identity () )
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # -- 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithKnownSize (const PointCloudType& point_cloud,
+        #                                  float angular_resolution_x, float angular_resolution_y,
+        #                                  const Eigen::Vector3f& point_cloud_center, float point_cloud_radius,
+        #                                  const Eigen::Affine3f& sensor_pose = Eigen::Affine3f::Identity (),
+        #                                  CoordinateFrame coordinate_frame=CAMERA_FRAME,
+        #                                  float noise_level=0.0f, float min_range=0.0f, int border_size=0);
+        ## 
+        # createFromPointCloudWithKnownSize (
+        #     cpp.PointCloud_t& point_cloud, 
+        #     float angular_resolution_x,
+        #     float angular_resolution_y,
+        #     const eigen3.Vector3f& point_cloud_center,
+        #     float point_cloud_radius,
+        #     const eigen3.Affine3f& sensor_pose,
+        #     CoordinateFrame2 coordinate_frame,
+        #     float noise_level, 
+        #     float min_range, 
+        #     int border_size)
+        void createFromPointCloudWithKnownSize [PointCloudType](
+            cpp.PointCloud[PointCloudType]& point_cloud, 
+            float angular_resolution_x, float angular_resolution_y,
+            const eigen3.Vector3f& point_cloud_center,
+            float point_cloud_radius,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level, 
+            float min_range, 
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, using the average viewpoint of the points 
+        # (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
+        # param point_cloud the input point cloud
+        # param angular_resolution the angle (in radians) between each sample in the depth image
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
+        # with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y 
+        # to the bottom and z to the front)
+        # template <typename PointCloudTypeWithViewpoints> 
+        # void createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud, float angular_resolution,
+        #                                   float max_angle_width, float max_angle_height,
+        #                                   CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                   float min_range=0.0f, int border_size=0);
+        ## 
+        void createFromPointCloudWithViewpoints (
+            const cpp.PointCloud_PointWithViewpoint_t& point_cloud,
+            float angular_resolution,
+            float max_angle_width, 
+            float max_angle_height,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level,
+            float min_range,
+            int border_size)
+        
+        # brief Create the depth image from a point cloud, using the average viewpoint of the points 
+        # (vp_x,vp_y,vp_z in the point type) in the point cloud as sensor pose (assuming a rotation of (0,0,0)).
+        # param point_cloud the input point cloud
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param max_angle_width an angle (in radians) defining the horizontal bounds of the sensor
+        # param max_angle_height an angle (in radians) defining the vertical bounds of the sensor
+        # param coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range (defaults to 0)
+        # param border_size the border size (defaults to 0)
+        # note If wrong_coordinate_system is true, the sensor pose will be rotated to change from a coordinate frame
+        # with x to the front, y to the left and z to the top to the coordinate frame we use here (x to the right, y 
+        # to the bottom and z to the front)
+        # template <typename PointCloudTypeWithViewpoints> 
+        # void createFromPointCloudWithViewpoints (const PointCloudTypeWithViewpoints& point_cloud,
+        #                                   float angular_resolution_x, float angular_resolution_y,
+        #                                   float max_angle_width, float max_angle_height,
+        #                                   CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                   float min_range=0.0f, int border_size=0);
+        ##
+        void createFromPointCloudWithViewpoints (
+            const cpp.PointCloud_PointWithViewpoint_t& point_cloud,
+            float angular_resolution_x,
+            float angular_resolution_y,
+            float max_angle_width,
+            float max_angle_height,
+            CoordinateFrame2 coordinate_frame,
+            float noise_level,
+            float min_range, 
+            int border_size)
+        
+        # brief Create an empty depth image (filled with unobserved points)
+        # param[in] angular_resolution the angle (in radians) between each sample in the depth image
+        # param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to  Eigen::Affine3f::Identity () )
+        # param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
+        # param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
+        # void createEmpty (float angular_resolution, const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
+        #            RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
+        #            float angle_height=pcl::deg2rad (180.0f));
+        ##
+        void createEmpty (
+            float angular_resolution, 
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float angle_width,
+            float angle_height)
+        
+        # brief Create an empty depth image (filled with unobserved points)
+        # param angular_resolution_x the angular difference (in radians) between the
+        #                            individual pixels in the image in the x-direction
+        # param angular_resolution_y the angular difference (in radians) between the
+        #                            individual pixels in the image in the y-direction
+        # param[in] sensor_pose an affine matrix defining the pose of the sensor (defaults to  Eigen::Affine3f::Identity () )
+        # param[in] coordinate_frame the coordinate frame (defaults to CAMERA_FRAME)
+        # param[in] angle_width an angle (in radians) defining the horizontal bounds of the sensor (defaults to 2*pi (360deg))
+        # param[in] angle_height an angle (in radians) defining the vertical bounds of the sensor (defaults to pi (180deg))
+        # 
+        # void createEmpty (float angular_resolution_x, float angular_resolution_y,
+        #            const Eigen::Affine3f& sensor_pose=Eigen::Affine3f::Identity (),
+        #            RangeImage::CoordinateFrame coordinate_frame=CAMERA_FRAME, float angle_width=pcl::deg2rad (360.0f),
+        #            float angle_height=pcl::deg2rad (180.0f));
+        ##
+        void createEmpty (
+            float angular_resolution_x, 
+            float angular_resolution_y,
+            const eigen3.Affine3f& sensor_pose,
+            CoordinateFrame2 coordinate_frame,
+            float angle_width,
+            float angle_height)
+        
+        # brief Integrate the given point cloud into the current range image using a z-buffer
+        # param point_cloud the input point cloud
+        # param noise_level - The distance in meters inside of which the z-buffer will not use the minimum,
+        #                     but the mean of the points. If 0.0 it is equivalent to a normal z-buffer and
+        #                     will always take the minimum per cell.
+        # param min_range the minimum visible range
+        # param top    returns the minimum y pixel position in the image where a point was added
+        # param right  returns the maximum x pixel position in the image where a point was added
+        # param bottom returns the maximum y pixel position in the image where a point was added
+        # param top returns the minimum y position in the image where a point was added
+        # param left   returns the minimum x pixel position in the image where a point was added
+        # 
+        # template <typename PointCloudType> void
+        # doZBuffer (const PointCloudType& point_cloud, float noise_level,
+        #            float min_range, int& top, int& right, int& bottom, int& left);
+        ##
+        void doZBuffer [PointCloudType](
+            cpp.PointCloud[PointCloudType]& point_cloud,
+            float noise_level,
+            float min_range, 
+            int& top, 
+            int& right, 
+            int& bottom,
+            int& left)
+        
+        # brief Integrates the given far range measurements into the range image */
+        # PCL_EXPORTS void integrateFarRanges (const PointCloud<PointWithViewpoint>& far_ranges);
+        # integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_t far_ranges)
+        # integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_Ptr_t &far_ranges)
+        void integrateFarRanges (const cpp.PointCloud_PointWithViewpoint_t &far_ranges)
+        
+        # brief Cut the range image to the minimal size so that it still contains all actual range readings.
+        # param border_size allows increase from the minimal size by the specified number of pixels (defaults to 0)
+        # param top if positive, this value overrides the position of the top edge (defaults to -1)
+        # param right if positive, this value overrides the position of the right edge (defaults to -1)
+        # param bottom if positive, this value overrides the position of the bottom edge (defaults to -1)
+        # param left if positive, this value overrides the position of the left edge (defaults to -1)
+        # 
+        # PCL_EXPORTS void cropImage (int border_size=0, int top=-1, int right=-1, int bottom=-1, int left=-1);
+        void cropImage (int border_size, int top, int right, int bottom, int left)
+        
+        # brief Get all the range values in one float array of size width*height  
+        # return a pointer to a new float array containing the range values
+        # note This method allocates a new float array; the caller is responsible for freeing this memory.
+        # PCL_EXPORTS float* getRangesArray () const;
+        float* getRangesArray ()
+        
+        # Getter for the transformation from the world system into the range image system
+        # (the sensor coordinate frame)
+        # inline const Eigen::Affine3f& getTransformationToRangeImageSystem () const { return (to_range_image_system_); }
+        const eigen3.Affine3f& getTransformationToRangeImageSystem ()
+        
+        # Setter for the transformation from the range image system
+        # (the sensor coordinate frame) into the world system
+        # inline void setTransformationToRangeImageSystem (const Eigen::Affine3f& to_range_image_system);
+        void setTransformationToRangeImageSystem (eigen3.Affine3f& to_range_image_system)
+        
+        # Getter for the transformation from the range image system
+        # (the sensor coordinate frame) into the world system
+        # inline const Eigen::Affine3f& getTransformationToWorldSystem () const { return to_world_system_;}
+        const eigen3.Affine3f& getTransformationToWorldSystem ()
+        
+        # Getter for the angular resolution of the range image in x direction in radians per pixel.
+        # Provided for downwards compatability */
+        # inline float getAngularResolution () const { return angular_resolution_x_;}
+        float getAngularResolution ()
+        
+        # Getter for the angular resolution of the range image in x direction in radians per pixel.
+        # inline float getAngularResolutionX () const { return angular_resolution_x_;}
+        float getAngularResolutionX ()
+        
+        # Getter for the angular resolution of the range image in y direction in radians per pixel.
+        # inline float getAngularResolutionY () const { return angular_resolution_y_;}
+        float getAngularResolutionY ()
+        
+        # Getter for the angular resolution of the range image in x and y direction (in radians).
+        # inline void getAngularResolution (float& angular_resolution_x, float& angular_resolution_y) const;
+        void getAngularResolution (float& angular_resolution_x, float& angular_resolution_y)
+        
+        # brief Set the angular resolution of the range image
+        # param angular_resolution the new angular resolution in x and y direction (in radians per pixel)
+        # inline void setAngularResolution (float angular_resolution);
+        void setAngularResolution (float angular_resolution)
+        
+        # brief Set the angular resolution of the range image
+        # param angular_resolution_x the new angular resolution in x direction (in radians per pixel)
+        # param angular_resolution_y the new angular resolution in y direction (in radians per pixel)
+        # inline void setAngularResolution (float angular_resolution_x, float angular_resolution_y)
+        void setAngularResolution (float angular_resolution_x, float angular_resolution_y)
+        
+        # brief Return the 3D point with range at the given image position
+        # param image_x the x coordinate
+        # param image_y the y coordinate
+        # return the point at the specified location (returns unobserved_point if outside of the image bounds)
+        # inline const PointWithRange& getPoint (int image_x, int image_y) const;
+        const cpp.PointWithRange& getPoint (int image_x, int image_y)
+        
+        # brief Non-const-version of getPoint
+        # inline PointWithRange& getPoint (int image_x, int image_y);
+        
+        # Return the 3d point with range at the given image position
+        # inline const PointWithRange& getPoint (float image_x, float image_y) const;
+        const cpp.PointWithRange& getPoint (float image_x, float image_y)
+        
+        # Non-const-version of the above
+        # inline PointWithRange& getPoint (float image_x, float image_y);
+        
+        # brief Return the 3D point with range at the given image position.  This methd performs no error checking
+        # to make sure the specified image position is inside of the image!
+        # param image_x the x coordinate
+        # param image_y the y coordinate
+        # return the point at the specified location (program may fail if the location is outside of the image bounds)
+        # inline const PointWithRange& getPointNoCheck (int image_x, int image_y) const;
+        const cpp.PointWithRange& getPointNoCheck (int image_x, int image_y)
+        
+        # Non-const-version of getPointNoCheck
+        # inline PointWithRange& getPointNoCheck (int image_x, int image_y);
+        
+        # Same as above
+        # inline void getPoint (int image_x, int image_y, Eigen::Vector3f& point) const;
+        
+        # Same as above
+        # inline void getPoint (int index, Eigen::Vector3f& point) const;
+        
+        # Same as above
+        # inline const Eigen::Map<const Eigen::Vector3f>
+        # getEigenVector3f (int x, int y) const;
+        
+        # Same as above
+        # inline const Eigen::Map<const Eigen::Vector3f>
+        # getEigenVector3f (int index) const;
+        
+        # Return the 3d point with range at the given index (whereas index=y*width+x)
+        # inline const PointWithRange& getPoint (int index) const;
+        const cpp.PointWithRange& getPoint (int index)
+        
+        # Calculate the 3D point according to the given image point and range
+        # inline void calculate3DPoint (float image_x, float image_y, float range, PointWithRange& point) const;
+        void calculate3DPoint (float image_x, float image_y, float range, cpp.PointWithRange& point)
+        
+        # Calculate the 3D point according to the given image point and the range value at the closest pixel
+        # inline void calculate3DPoint (float image_x, float image_y, PointWithRange& point) const;
+        inline void calculate3DPoint (float image_x, float image_y, cpp.PointWithRange& point)
+        
+        # Calculate the 3D point according to the given image point and range
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        
+        # Calculate the 3D point according to the given image point and the range value at the closest pixel
+        # inline void calculate3DPoint (float image_x, float image_y, Eigen::Vector3f& point) const;
+        void calculate3DPoint (float image_x, float image_y, eigen3.Vector3f& point)
+        
+        # Recalculate all 3D point positions according to their pixel position and range
+        # PCL_EXPORTS void recalculate3DPointPositions ();
+        void recalculate3DPointPositions ()
+        
+        # Get imagePoint from 3D point in world coordinates
+        # inline virtual void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        # void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y, float& range) const;
+        void getImagePoint (const eigen3.Vector3f& point, int& image_x, int& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y) const;
+        void getImagePoint (const eigen3.Vector3f& point, float& image_x, float& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (const Eigen::Vector3f& point, int& image_x, int& image_y) const;
+        void getImagePoint (const eigen3.Vector3f& point, int& image_x, int& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range) const;
+        void getImagePoint (float x, float y, float z, float& image_x, float& image_y, float& range)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, float& image_x, float& image_y) const;
+        void getImagePoint (float x, float y, float z, float& image_x, float& image_y)
+        
+        # Same as above
+        # inline void getImagePoint (float x, float y, float z, int& image_x, int& image_y) const;
+        void getImagePoint (float x, float y, float z, int& image_x, int& image_y)
+        
+        # point_in_image will be the point in the image at the position the given point would be. Returns
+        # the range of the given point.
+        # inline float checkPoint (const Eigen::Vector3f& point, PointWithRange& point_in_image) const;
+        float checkPoint (const eigen3.Vector3f& point, cpp.PointWithRange& point_in_image)
+        
+        # Returns the difference in range between the given point and the range of the point in the image
+        # at the position the given point would be.
+        # (Return value is point_in_image.range-given_point.range)
+        # inline float getRangeDifference (const Eigen::Vector3f& point) const;
+        float getRangeDifference (const eigen3.Vector3f& point)
+        
+        # Get the image point corresponding to the given angles
+        # inline void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y) const;
+        void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y)
+        
+        # Get the angles corresponding to the given image point
+        # inline void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y) const;
+        void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y)
+        
+        # Transforms an image point in float values to an image point in int values
+        # inline void real2DToInt2D (float x, float y, int& xInt, int& yInt) const;
+        void real2DToInt2D (float x, float y, int& xInt, int& yInt)
+        
+        # Check if a point is inside of the image
+        # inline bool isInImage (int x, int y) const;
+        bool isInImage (int x, int y)
+        
+        # Check if a point is inside of the image and has a finite range
+        # inline bool isValid (int x, int y) const;
+        bool isValid (int x, int y)
+        
+        # Check if a point has a finite range
+        # inline bool isValid (int index) const;
+        bool isValid (int index)
+        
+        # Check if a point is inside of the image and has either a finite range or a max reading (range=INFINITY)
+        # inline bool isObserved (int x, int y) const;
+        bool isObserved (int x, int y)
+        
+        # Check if a point is a max range (range=INFINITY) - please check isInImage or isObserved first!
+        # inline bool isMaxRange (int x, int y) const;
+        bool isMaxRange (int x, int y)
+        
+        # Calculate the normal of an image point using the neighbors with a maximum pixel distance of radius.
+        # step_size determines how many pixels are used. 1 means all, 2 only every second, etc..
+        # Returns false if it was unable to calculate a normal.
+        # inline bool getNormal (int x, int y, int radius, Eigen::Vector3f& normal, int step_size=1) const;
+        bool getNormal (int x, int y, int radius, eigen3.Vector3f& normal, int step_size)
+        
+        # Same as above, but only the no_of_nearest_neighbors points closest to the given point are considered.
+        # inline bool getNormalForClosestNeighbors (int x, int y, int radius, const PointWithRange& point, int no_of_nearest_neighbors, Eigen::Vector3f& normal, int step_size=1) const;
+        bool getNormalForClosestNeighbors (int x, int y, int radius, const cpp.PointWithRange& point,
+                                           int no_of_nearest_neighbors, eigen3.Vector3f& normal, int step_size)
+        
+        # Same as above
+        # inline bool getNormalForClosestNeighbors (int x, int y, int radius, const Eigen::Vector3f& point, int no_of_nearest_neighbors, Eigen::Vector3f& normal, Eigen::Vector3f* point_on_plane=NULL, int step_size=1) const;
+        bool getNormalForClosestNeighbors (int x, int y, int radius, const eigen3.Vector3f& point, int no_of_nearest_neighbors, eigen3.Vector3f& normal, eigen3.Vector3f* point_on_plane, int step_size)
+        
+        # Same as above, using default values
+        # inline bool getNormalForClosestNeighbors (int x, int y, Eigen::Vector3f& normal, int radius=2) const;
+        bool getNormalForClosestNeighbors (int x, int y, eigen3.Vector3f& normal, int radius)
+        
+        # Same as above but extracts some more data and can also return the extracted
+        # information for all neighbors in radius if normal_all_neighbors is not NULL
+        # inline bool getSurfaceInformation (int x, int y, int radius, const Eigen::Vector3f& point,
+        #                        int no_of_closest_neighbors, int step_size,
+        #                        float& max_closest_neighbor_distance_squared,
+        #                        Eigen::Vector3f& normal, Eigen::Vector3f& mean, Eigen::Vector3f& eigen_values,
+        #                        Eigen::Vector3f* normal_all_neighbors=NULL,
+        #                        Eigen::Vector3f* mean_all_neighbors=NULL,
+        #                        Eigen::Vector3f* eigen_values_all_neighbors=NULL) const;
+        ##
+        bool getSurfaceInformation (
+            int x,
+            int y,
+            int radius,
+            const eigen3.Vector3f& point,
+            int no_of_closest_neighbors,
+            int step_size,
+            float& max_closest_neighbor_distance_squared,
+            eigen3.Vector3f& normal, 
+            eigen3.Vector3f& mean,
+            eigen3.Vector3f& eigen_values,
+            eigen3.Vector3f* normal_all_neighbors,
+            eigen3.Vector3f* mean_all_neighbors,
+            eigen3.Vector3f* eigen_values_all_neighbors) const;
+        
+        # // Return the squared distance to the n-th neighbors of the point at x,y
+        # inline float getSquaredDistanceOfNthNeighbor (int x, int y, int radius, int n, int step_size) const;
+        float getSquaredDistanceOfNthNeighbor (
+            int x, int y,
+            int radius,
+            int n, 
+            int step_size)
+        
+        # /** Calculate the impact angle based on the sensor position and the two given points - will return
+        #  * -INFINITY if one of the points is unobserved */
+        # inline float getImpactAngle (const PointWithRange& point1, const PointWithRange& point2) const;
+        float getImpactAngle (
+            const cpp.PointWithRange& point1, 
+            const cpp.PointWithRange& point2)
+        
+        # Same as above
+        # inline float getImpactAngle (int x1, int y1, int x2, int y2) const;
+        float getImpactAngle (int x1, int y1, int x2, int y2)
+        
+        # /** Extract a local normal (with a heuristic not to include background points) and calculate the impact
+        #  *  angle based on this */
+        # inline float getImpactAngleBasedOnLocalNormal (int x, int y, int radius) const;
+        float getImpactAngleBasedOnLocalNormal (int x, int y, int radius)
+        
+        # /** Uses the above function for every point in the image */
+        # PCL_EXPORTS float* getImpactAngleImageBasedOnLocalNormals (int radius) const;
+        float* getImpactAngleImageBasedOnLocalNormals (int radius)
+        
+        # /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
+        #  *  This uses getImpactAngleBasedOnLocalNormal
+        #  *  Will return -INFINITY if no normal could be calculated */
+        # inline float getNormalBasedAcutenessValue (int x, int y, int radius) const;
+        float getNormalBasedAcutenessValue (int x, int y, int radius)
+        
+        # /** Calculate a score [0,1] that tells how acute the impact angle is (1.0f - getImpactAngle/90deg)
+        #  *  will return -INFINITY if one of the points is unobserved */
+        # inline float getAcutenessValue (const PointWithRange& point1, const PointWithRange& point2) const;
+        float getAcutenessValue (const cpp.PointWithRange& point1, const cpp.PointWithRange& point2)
+        
+        # Same as above
+        # inline float getAcutenessValue (int x1, int y1, int x2, int y2) const;
+        float getAcutenessValue (int x1, int y1, int x2, int y2)
+        
+        # /** Calculate getAcutenessValue for every point */
+        # PCL_EXPORTS void getAcutenessValueImages (int pixel_distance, float*& acuteness_value_image_x, float*& acuteness_value_image_y) const;
+        void getAcutenessValueImages (
+            int pixel_distance,
+            float*& acuteness_value_image_x,
+            float*& acuteness_value_image_y)
+        
+        # Calculates, how much the surface changes at a point. Pi meaning a flat suface and 0.0f would be a needle point
+        # //inline float
+        # //  getSurfaceChange (const PointWithRange& point, const PointWithRange& neighbor1,
+        # //                   const PointWithRange& neighbor2) const;
+        
+        # Calculates, how much the surface changes at a point. 1 meaning a 90deg angle and 0 a flat suface
+        # PCL_EXPORTS float getSurfaceChange (int x, int y, int radius) const;
+        float getSurfaceChange (int x, int y, int radius)
+        
+        # Uses the above function for every point in the image
+        # PCL_EXPORTS float* getSurfaceChangeImage (int radius) const;
+        float* getSurfaceChangeImage (int radius)
+        
+        # Calculates, how much the surface changes at a point. Returns an angle [0.0f, PI] for x and y direction.
+        # A return value of -INFINITY means that a point was unobserved.
+        # inline void getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y) const;
+        void getSurfaceAngleChange (int x, int y, int radius, float& angle_change_x, float& angle_change_y)
+        
+        # Uses the above function for every point in the image
+        # PCL_EXPORTS void getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y) const;
+        void getSurfaceAngleChangeImages (int radius, float*& angle_change_image_x, float*& angle_change_image_y)
+        
+        # Calculates the curvature in a point using pca
+        # inline float getCurvature (int x, int y, int radius, int step_size) const;
+        float getCurvature (int x, int y, int radius, int step_size)
+        
+        # Get the sensor position
+        # inline const Eigen::Vector3f getSensorPos () const;
+        eigen3.Vector3f getSensorPos ()
+        
+        # Sets all -INFINITY values to INFINITY
+        # PCL_EXPORTS void setUnseenToMaxRange ();
+        void setUnseenToMaxRange ()
+        
+        # Getter for image_offset_x_
+        # inline int getImageOffsetX () const
+        # Getter for image_offset_y_
+        # inline int getImageOffsetY () const
+        int getImageOffsetX ()
+        int getImageOffsetY ()
+        
+        # Setter for image offsets
+        # inline void setImageOffsets (int offset_x, int offset_y)
+        # Get a sub part of the complete image as a new range image.
+        # param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
+        #                        This is always according to absolute 0,0 meaning -180,-90
+        #                        and it is already in the system of the new image, so the
+        #                        actual pixel used in the original image is
+        #                        combine_pixels* (image_offset_x-image_offset_x_)
+        # param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
+        # param sub_image_width - width of the new image
+        # param sub_image_height - height of the new image
+        # param combine_pixels - shrinking factor, meaning the new angular resolution
+        #                        is combine_pixels times the old one
+        # param sub_image - the output image
+        # virtual void getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
+        # NG(LNK2001)
+        # void getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width, int sub_image_height, int combine_pixels, RangeImage& sub_image)
+        
+        # Get a range image with half the resolution
+        # virtual void getHalfImage (RangeImage& half_image) const;
+        # NG(LNK2001)
+        # void getHalfImage (RangeImage& half_image)
+        
+        # Find the minimum and maximum range in the image
+        # PCL_EXPORTS void getMinMaxRanges (float& min_range, float& max_range) const;
+        void getMinMaxRanges (float& min_range, float& max_range)
+        
+        # This function sets the sensor pose to 0 and transforms all point positions to this local coordinate frame
+        # PCL_EXPORTS void change3dPointsToLocalCoordinateFrame ();
+        void change3dPointsToLocalCoordinateFrame ()
+        
+        # /** Calculate a range patch as the z values of the coordinate frame given by pose.
+        #  *  The patch will have size pixel_size x pixel_size and each pixel
+        #  *  covers world_size/pixel_size meters in the world
+        #  *  You are responsible for deleting the structure afterwards! */
+        # PCL_EXPORTS float* getInterpolatedSurfaceProjection (const Eigen::Affine3f& pose, int pixel_size, float world_size) const;
+        float* getInterpolatedSurfaceProjection (const eigen3.Affine3f& pose, int pixel_size, float world_size)
+        
+        # Same as above, but using the local coordinate frame defined by point and the viewing direction
+        # PCL_EXPORTS float* getInterpolatedSurfaceProjection (const Eigen::Vector3f& point, int pixel_size, float world_size) const;
+        float* getInterpolatedSurfaceProjection (const eigen3.Vector3f& point, int pixel_size, float world_size)
+        
+        # Get the local coordinate frame with 0,0,0 in point, upright and Z as the viewing direction
+        # inline Eigen::Affine3f getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point) const;
+        eigen3.Affine3f getTransformationToViewerCoordinateFrame (const eigen3.Vector3f& point)
+        
+        # Same as above, using a reference for the retrurn value
+        # inline void getTransformationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
+        void getTransformationToViewerCoordinateFrame (const eigen3.Vector3f& point, eigen3.Affine3f& transformation)
+        
+        # Same as above, but only returning the rotation
+        # inline void getRotationToViewerCoordinateFrame (const Eigen::Vector3f& point, Eigen::Affine3f& transformation) const;
+        void getRotationToViewerCoordinateFrame (const eigen3.Vector3f& point, eigen3.Affine3f& transformation)
+        
+        # Get a local coordinate frame at the given point based on the normal.
+        # PCL_EXPORTS bool getNormalBasedUprightTransformation (const Eigen::Vector3f& point, float max_dist, Eigen::Affine3f& transformation) const;
+        bool getNormalBasedUprightTransformation (const eigen3.Vector3f& point, float max_dist, eigen3.Affine3f& transformation)
+        
+        # Get the integral image of the range values (used for fast blur operations).
+        # You are responsible for deleting it after usage!
+        # PCL_EXPORTS void getIntegralImage (float*& integral_image, int*& valid_points_num_image) const;
+        # void getIntegralImage (float*& integral_image, int*& valid_points_num_image)
+        
+        # /** Get a blurred version of the range image using box filters on the provided integral image*/
+        # PCL_EXPORTS void getBlurredImageUsingIntegralImage (int blur_radius, float* integral_image, int* valid_points_num_image, RangeImage& range_image) const;
+        # void getBlurredImageUsingIntegralImage (int blur_radius, float* integral_image, int* valid_points_num_image, RangeImage& range_image)
+        
+        # /** Get a blurred version of the range image using box filters */
+        # PCL_EXPORTS void getBlurredImage (int blur_radius, RangeImage& range_image) const;
+        # void getBlurredImage (int blur_radius, RangeImage& range_image)
+        
+        # /** Get the squared euclidean distance between the two image points.
+        #  *  Returns -INFINITY if one of the points was not observed */
+        # inline float getEuclideanDistanceSquared (int x1, int y1, int x2, int y2) const;
+        # float getEuclideanDistanceSquared (int x1, int y1, int x2, int y2)
+        
+        # Doing the above for some steps in the given direction and averaging
+        # inline float getAverageEuclideanDistance (int x, int y, int offset_x, int offset_y, int max_steps) const;
+        float getAverageEuclideanDistance (int x, int y, int offset_x, int offset_y, int max_steps)
+        
+        # Project all points on the local plane approximation, thereby smoothing the surface of the scan
+        # PCL_EXPORTS void getRangeImageWithSmoothedSurface (int radius, RangeImage& smoothed_range_image) const;
+        # void getRangeImageWithSmoothedSurface (int radius, RangeImage& smoothed_range_image)
+        
+        # //void getLocalNormals (int radius) const;
+        
+        # /** Calculates the average 3D position of the no_of_points points described by the start
+        #  *  point x,y in the direction delta.
+        #  *  Returns a max range point (range=INFINITY) if the first point is max range and an
+        #  *  unobserved point (range=-INFINITY) if non of the points is observed. */
+        # inline void get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points, PointWithRange& average_point) const;
+        void get1dPointAverage (int x, int y, int delta_x, int delta_y, int no_of_points, cpp.PointWithRange& average_point)
+        
+        # /** Calculates the overlap of two range images given the relative transformation
+        #  *  (from the given image to *this) */
+        # PCL_EXPORTS float getOverlap (const RangeImage& other_range_image, const Eigen::Affine3f& relative_transformation, int search_radius, float max_distance, int pixel_step=1) const;
+        
+        # /** Get the viewing direction for the given point */
+        # inline bool getViewingDirection (int x, int y, Eigen::Vector3f& viewing_direction) const;
+        # bool getViewingDirection (int x, int y, Eigen::Vector3f& viewing_direction) const;
+        
+        # /** Get the viewing direction for the given point */
+        # inline void getViewingDirection (const Eigen::Vector3f& point, Eigen::Vector3f& viewing_direction) const;
+        # void getViewingDirection (const Eigen::Vector3f& point, Eigen::Vector3f& viewing_direction) const;
+        
+        # /** Return a newly created Range image.
+        #  *  Can be reimplmented in derived classes like RangeImagePlanar to return an image of the same type. */
+        # virtual RangeImage* getNew () const { return new RangeImage; }
+        
+        # // =====MEMBER VARIABLES=====
+        # // BaseClass:
+        # //   roslib::Header header;
+        # //   std::vector<PointT> points;
+        # //   uint32_t width;
+        # //   uint32_t height;
+        # //   bool is_dense;
+        # static bool debug; /**< Just for... well... debugging purposes. :-) */
+
+
+ctypedef RangeImage RangeImage_t
+ctypedef shared_ptr[RangeImage] RangeImagePtr_t
+ctypedef shared_ptr[const RangeImage] RangeImageConstPtr_t
+###
+
+# range_image_planar.h
+# class RangeImagePlanar : public RangeImage
+cdef extern from "pcl/range_image/range_image_planar.h" namespace "pcl":
+    cdef cppclass RangeImagePlanar(RangeImage):
+        RangeImagePlanar()
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef RangeImage BaseClass;
+        # typedef boost::shared_ptr<RangeImagePlanar> Ptr;
+        # typedef boost::shared_ptr<const RangeImagePlanar> ConstPtr;
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # PCL_EXPORTS RangeImagePlanar ();
+        # /** Destructor */
+        # PCL_EXPORTS ~RangeImagePlanar ();
+        # /** Return a newly created RangeImagePlanar.
+        #  *  Reimplmentation to return an image of the same type. */
+        # virtual RangeImage*  getNew () const { return new RangeImagePlanar; }
+        
+        # // =====PUBLIC METHODS=====
+        # brief Get a boost shared pointer of a copy of this
+        # inline Ptr makeShared () { return Ptr (new RangeImagePlanar (*this)); } 
+        
+        # brief Create the image from an existing disparity image.
+        # param disparity_image the input disparity image data
+        # param di_width the disparity image width
+        # param di_height the disparity image height
+        # param focal_length the focal length of the primary camera that generated the disparity image
+        # param base_line the baseline of the stereo pair that generated the disparity image
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel. 
+        # 
+        # PCL_EXPORTS void setDisparityImage (const float* disparity_image, int di_width, int di_height, float focal_length, float base_line, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing depth image.
+        # param depth_image the input depth image data as float values
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel.
+        # 
+        # PCL_EXPORTS void
+        # setDepthImage (const float* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
+        #                float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing depth image.
+        # param depth_image the input disparity image data as short values describing millimeters
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param desired_angular_resolution If this is set, the system will skip as many pixels as necessary to get as
+        #        close to this angular resolution as possible while not going over this value (the density will not be
+        #        lower than this value). The value is in radians per pixel.
+        # 
+        # PCL_EXPORTS void
+        # setDepthImage (const unsigned short* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
+        #                float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
+        ##
+        
+        # Create the image from an existing point cloud.
+        # param point_cloud the source point cloud
+        # param di_width the disparity image width 
+        # param di_height the disparity image height
+        # param di_center_x the x-coordinate of the camera's center of projection
+        # param di_center_y the y-coordinate of the camera's center of projection
+        # param di_focal_length_x the camera's focal length in the horizontal direction
+        # param di_focal_length_y the camera's focal length in the vertical direction
+        # param sensor_pose the pose of the virtual depth camera
+        # param coordinate_frame the used coordinate frame of the point cloud
+        # param noise_level what is the typical noise of the sensor - is used for averaging in the z-buffer
+        # param min_range minimum range to consifder points
+        # 
+        # template <typename PointCloudType> void
+        # createFromPointCloudWithFixedSize (const PointCloudType& point_cloud,
+        #                                    int di_width, int di_height, float di_center_x, float di_center_y,
+        #                                    float di_focal_length_x, float di_focal_length_y,
+        #                                    const Eigen::Affine3f& sensor_pose,
+        #                                    CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
+        #                                    float min_range=0.0f);
+        ##
+        
+        # // Since we reimplement some of these overloaded functions, we have to do the following:
+        # using RangeImage::calculate3DPoint;
+        # using RangeImage::getImagePoint;
+        
+        # brief Calculate the 3D point according to the given image point and range
+        # param image_x the x image position
+        # param image_y the y image position
+        # param range the range
+        # param point the resulting 3D point
+        # note Implementation according to planar range images (compared to spherical as in the original)
+        # 
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        ##
+        
+        # brief Calculate the image point and range from the given 3D point
+        # param point the resulting 3D point
+        # param image_x the resulting x image position
+        # param image_y the resulting y image position
+        # param range the resulting range
+        # note Implementation according to planar range images (compared to spherical as in the original)
+        # 
+        # virtual inline void  getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        ##
+        
+        # Get a sub part of the complete image as a new range image.
+        # param sub_image_image_offset_x - The x coordinate of the top left pixel of the sub image.
+        #                         This is always according to absolute 0,0 meaning(-180, -90)
+        #                         and it is already in the system of the new image, so the
+        #                         actual pixel used in the original image is
+        #                         combine_pixels* (image_offset_x-image_offset_x_)
+        # param sub_image_image_offset_y - Same as image_offset_x for the y coordinate
+        # param sub_image_width - width of the new image
+        # param sub_image_height - height of the new image
+        # param combine_pixels - shrinking factor, meaning the new angular resolution
+        #                        is combine_pixels times the old one
+        # param sub_image - the output image
+        # 
+        # PCL_EXPORTS virtual void
+        # getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width,
+        #              int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
+        ##
+        
+        # Get a range image with half the resolution
+        # PCL_EXPORTS virtual void getHalfImage (RangeImage& half_image) const;
+
+
+ctypedef RangeImagePlanar RangeImagePlanar_t
+ctypedef shared_ptr[RangeImagePlanar] RangeImagePlanarPtr_t
+ctypedef shared_ptr[const RangeImagePlanar] RangeImagePlanarConstPtr_t
+###
+
+
+###############################################################################
+# Enum
+###############################################################################
+
+# enum CoordinateFrame
+# CAMERA_FRAME = 0,
+# LASER_FRAME = 1
+cdef extern from "pcl/range_image/range_image.h" namespace "pcl":
+    ctypedef enum CoordinateFrame2 "pcl::RangeImage::CoordinateFrame":
+        COORDINATEFRAME_CAMERA "pcl::RangeImage::CAMERA_FRAME"
+        COORDINATEFRAME_LASER "pcl::RangeImage::LASER_FRAME"
+
+
+# bearing_angle_image.h
+# namespace pcl
+# /** \brief class BearingAngleImage is used as an interface to generate Bearing Angle(BA) image.
+# * \author: Qinghua Li (qinghua__li@163.com)
+# */
+# class BearingAngleImage : public pcl::PointCloud<PointXYZRGBA>
+        # public:
+        # // ===== TYPEDEFS =====
+        # typedef pcl::PointCloud<PointXYZRGBA> BaseClass;
+        # 
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # BearingAngleImage ();
+        # /** Destructor */
+        # virtual ~BearingAngleImage ();
+        # 
+        # public:
+        # /** \brief Reset all values to an empty Bearing Angle image */
+        # void reset ();
+        # 
+        # /** \brief Calculate the angle between the laser beam and the segment joining two consecutive
+        #  * measurement points.
+        #  * \param point1
+        #  * \param point2
+        #  */
+        # double getAngle (const PointXYZ &point1, const PointXYZ &point2);
+        # 
+        # /** \brief Transform 3D point cloud into a 2D Bearing Angle(BA) image */
+        # void generateBAImage (PointCloud<PointXYZ>& point_cloud);
+
+
+###
+
+# range_image_spherical.h
+# namespace pcl
+# /** \brief @b RangeImageSpherical is derived from the original range image and uses a slightly different
+# * spherical projection. In the original range image, the image will appear more and more
+# * "scaled down" along the y axis, the further away from the mean line of the image a point is.
+# * This class removes this scaling, which makes it especially suitable for spinning LIDAR sensors
+# * that capure a 360 view, since a rotation of the sensor will now simply correspond to a shift of the
+# * range image. (This class is similar to RangeImagePlanar, but changes less of the behaviour of the base class.)
+# * \author Andreas Muetzel
+# * \ingroup range_image
+# */
+# class RangeImageSpherical : public RangeImage
+        # public:
+        # // =====TYPEDEFS=====
+        # typedef RangeImage BaseClass;
+        # typedef boost::shared_ptr<RangeImageSpherical> Ptr;
+        # typedef boost::shared_ptr<const RangeImageSpherical> ConstPtr;
+        # 
+        # // =====CONSTRUCTOR & DESTRUCTOR=====
+        # /** Constructor */
+        # PCL_EXPORTS RangeImageSpherical () {}
+        # /** Destructor */
+        # PCL_EXPORTS virtual ~RangeImageSpherical () {}
+        # 
+        # /** Return a newly created RangeImagePlanar.
+        # *  Reimplmentation to return an image of the same type. */
+        # virtual RangeImage* getNew () const { return new RangeImageSpherical; }
+        # 
+        # // =====PUBLIC METHODS=====
+        # /** \brief Get a boost shared pointer of a copy of this */
+        # inline Ptr makeShared () { return Ptr (new RangeImageSpherical (*this)); }
+        # 
+        # // Since we reimplement some of these overloaded functions, we have to do the following:
+        # using RangeImage::calculate3DPoint;
+        # using RangeImage::getImagePoint;
+        # 
+        # /** \brief Calculate the 3D point according to the given image point and range
+        #  * \param image_x the x image position
+        #  * \param image_y the y image position
+        #  * \param range the range
+        #  * \param point the resulting 3D point
+        #  * \note Implementation according to planar range images (compared to spherical as in the original)
+        #  */
+        # virtual inline void calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
+        # 
+        # /** \brief Calculate the image point and range from the given 3D point
+        #  * \param point the resulting 3D point
+        #  * \param image_x the resulting x image position
+        #  * \param image_y the resulting y image position
+        #  * \param range the resulting range
+        #  * \note Implementation according to planar range images (compared to spherical as in the original)
+        #  */
+        # virtual inline void getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
+        # 
+        # /** Get the angles corresponding to the given image point */
+        # inline void getAnglesFromImagePoint (float image_x, float image_y, float& angle_x, float& angle_y) const;
+        # 
+        # /** Get the image point corresponding to the given ranges */
+        # inline void getImagePointFromAngles (float angle_x, float angle_y, float& image_x, float& image_y) const;
+
+
+###
+
diff --git a/pcl/pcl_registration_160.pxd b/pcl/pcl_registration_160.pxd
new file mode 100644
index 0000000..a4c7579
--- /dev/null
+++ b/pcl/pcl_registration_160.pxd
@@ -0,0 +1,2368 @@
+# -*- coding: utf-8 -*-
+
+from libcpp cimport bool
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# main
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+# Cython - limits.pxd
+# from libcpp cimport numeric_limits
+
+# base
+from eigen cimport Matrix4f
+
+# registration.h
+# template <typename PointSource, typename PointTarget>
+# class Registration : public PCLBase<PointSource>
+cdef extern from "pcl/registration/registration.h" namespace "pcl" nogil:
+    cdef cppclass Registration[Source, Target](cpp.PCLBase[Source]):
+        Registration()
+        # override?
+        void setInputCloud(cpp.PointCloudPtr_t ptcloud) except +
+        # void setInputSource(cpp.PointCloudPtr2_t pt2cloud) except +
+        # public:
+        # using PCLBase<PointSource>::initCompute;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        void setInputTarget(cpp.PointCloudPtr_t ptcloud) except +
+        # void setInputTarget2(cpp.PointCloudPtr_t pt2cloud) except +
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudTargetConstPtr const getInputTarget ()
+        cpp.PointCloudPtr_t getInputTarget ()
+        
+        # brief Get the final transformation matrix estimated by the registration method.
+        Matrix4f getFinalTransformation ()
+        
+        # /** \brief Get the last incremental transformation matrix estimated by the registration method. */
+        Matrix4f getLastIncrementalTransformation ()
+        
+        # Set the maximum number of iterations the internal optimization should run for.
+        # param nr_iterations the maximum number of iterations the internal optimization should run for
+        void setMaximumIterations (int nr_iterations) except +
+        
+        # /** \brief Get the maximum number of iterations the internal optimization should run for, as set by the user. */
+        int getMaximumIterations () 
+        
+        # /** \brief Set the number of iterations RANSAC should run for.
+        #   * \param[in] ransac_iterations is the number of iterations RANSAC should run for
+        #   */
+        void setRANSACIterations (int ransac_iterations)
+        
+        # /** \brief Get the number of iterations RANSAC should run for, as set by the user. */
+        # inline double getRANSACIterations ()
+        double getRANSACIterations ()
+        
+        # /** \brief Set the inlier distance threshold for the internal RANSAC outlier rejection loop.
+        #   * The method considers a point to be an inlier, if the distance between the target data index and the transformed 
+        #   * source index is smaller than the given inlier distance threshold. 
+        #   * The value is set by default to 0.05m.
+        #   * \param[in] inlier_threshold the inlier distance threshold for the internal RANSAC outlier rejection loop
+        #   */
+        # inline void setRANSACOutlierRejectionThreshold (double inlier_threshold) { inlier_threshold_ = inlier_threshold; }
+        void setRANSACOutlierRejectionThreshold (double inlier_threshold)
+        
+        # /** \brief Get the inlier distance threshold for the internal outlier rejection loop as set by the user. */
+        # inline double getRANSACOutlierRejectionThreshold ()
+        double getRANSACOutlierRejectionThreshold ()
+        
+        # /** \brief Set the maximum distance threshold between two correspondent points in source <-> target. If the 
+        #   * distance is larger than this threshold, the points will be ignored in the alignment process.
+        #   * \param[in] distance_threshold the maximum distance threshold between a point and its nearest neighbor 
+        #   * correspondent in order to be considered in the alignment process
+        #   */
+        # inline void setMaxCorrespondenceDistance (double distance_threshold)
+        void setMaxCorrespondenceDistance (double distance_threshold)
+        
+        # /** \brief Get the maximum distance threshold between two correspondent points in source <-> target. If the 
+        #   * distance is larger than this threshold, the points will be ignored in the alignment process.
+        #   */
+        # inline double getMaxCorrespondenceDistance ()
+        double getMaxCorrespondenceDistance ()
+        
+        # /** \brief Set the transformation epsilon (maximum allowable difference between two consecutive 
+        #   * transformations) in order for an optimization to be considered as having converged to the final 
+        #   * solution.
+        #   * \param[in] epsilon the transformation epsilon in order for an optimization to be considered as having 
+        #   * converged to the final solution.
+        #   */
+        # inline void setTransformationEpsilon (double epsilon)
+        void setTransformationEpsilon (double epsilon)
+        
+        # /** \brief Get the transformation epsilon (maximum allowable difference between two consecutive 
+        #   * transformations) as set by the user.
+        #   */
+        # inline double getTransformationEpsilon ()
+        double getTransformationEpsilon ()
+        
+        # /** \brief Set the maximum allowed Euclidean error between two consecutive steps in the ICP loop, before 
+        #   * the algorithm is considered to have converged. 
+        #   * The error is estimated as the sum of the differences between correspondences in an Euclidean sense, 
+        #   * divided by the number of correspondences.
+        #   * \param[in] epsilon the maximum allowed distance error before the algorithm will be considered to have
+        #   * converged
+        #   */
+        # inline void setEuclideanFitnessEpsilon (double epsilon)
+        void setEuclideanFitnessEpsilon (double epsilon)
+        
+        # /** \brief Get the maximum allowed distance error before the algorithm will be considered to have converged,
+        #   * as set by the user. See \ref setEuclideanFitnessEpsilon
+        #   */
+        # inline double getEuclideanFitnessEpsilon ()
+        double getEuclideanFitnessEpsilon ()
+        
+        # 
+        # /** \brief Provide a boost shared pointer to the PointRepresentation to be used when comparing points
+        #   * \param[in] point_representation the PointRepresentation to be used by the k-D tree
+        #   */
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # 
+        # /** \brief Register the user callback function which will be called from registration thread
+        #  * in order to update point cloud obtained after each iteration
+        #  * \param[in] visualizerCallback reference of the user callback function
+        #  */
+        # template<typename FunctionSignature> inline bool registerVisualizationCallback (boost::function<FunctionSignature> &visualizerCallback)
+        
+        # /** \brief Obtain the Euclidean fitness score (e.g., sum of squared distances from the source to the target)
+        #   * \param[in] max_range maximum allowable distance between a point and its correspondence in the target 
+        #   * (default: double::max)
+        #   */
+        # double getFitnessScore (double max_range = numeric_limits[double]::max ());
+        double getFitnessScore() except +
+        
+        # /** \brief Obtain the Euclidean fitness score (e.g., sum of squared distances from the source to the target)
+        #   * from two sets of correspondence distances (distances between source and target points)
+        #   * \param[in] distances_a the first set of distances between correspondences
+        #   * \param[in] distances_b the second set of distances between correspondences
+        #   */
+        # inline double getFitnessScore (const std::vector<float> &distances_a, const std::vector<float> &distances_b);
+        double getFitnessScore (const vector[float] &distances_a, const vector[float] &distances_b)
+        
+        # /** \brief Return the state of convergence after the last align run */
+        # inline bool hasConverged ()
+        bool hasConverged ()
+        
+        # /** \brief Call the registration algorithm which estimates the transformation and returns the transformed source 
+        #   * (input) as \a output.
+        #   * \param[out] output the resultant input transfomed point cloud dataset
+        #   */
+        # inline void align (PointCloudSource &output);
+        void align(cpp.PointCloud[Source] &) except +
+        
+        # /** \brief Call the registration algorithm which estimates the transformation and returns the transformed source 
+        #   * (input) as \a output.
+        #   * \param[out] output the resultant input transfomed point cloud dataset
+        #   * \param[in] guess the initial gross estimation of the transformation
+        #   */
+        # inline void align (PointCloudSource &output, const Matrix4f& guess);
+        void align (cpp.PointCloud[Source] &output, const Matrix4f& guess)
+        
+        # /** \brief Abstract class get name method. */
+        # inline const std::string& getClassName () const
+        string& getClassName ()
+        
+        # /** \brief Internal computation initalization. */
+        # bool initCompute ();
+        bool initCompute ()
+        
+        # /** \brief Internal computation when reciprocal lookup is needed */
+        # bool initComputeReciprocal ();
+        bool initComputeReciprocal ()
+        
+        # /** \brief Add a new correspondence rejector to the list
+        #   * \param[in] rejector the new correspondence rejector to concatenate
+        # inline void addCorrespondenceRejector (const CorrespondenceRejectorPtr &rejector)
+        # void addCorrespondenceRejector (const CorrespondenceRejectorPtr &rejector)
+        
+        # /** \brief Get the list of correspondence rejectors. */
+        # inline std::vector<CorrespondenceRejectorPtr> getCorrespondenceRejectors ()
+        # vector[CorrespondenceRejectorPtr] getCorrespondenceRejectors ()
+        
+        # /** \brief Remove the i-th correspondence rejector in the list
+        #   * \param[in] i the position of the correspondence rejector in the list to remove
+        # inline bool removeCorrespondenceRejector (unsigned int i)
+        bool removeCorrespondenceRejector (unsigned int i)
+        
+        # /** \brief Clear the list of correspondence rejectors. */
+        # inline void clearCorrespondenceRejectors ()
+        void clearCorrespondenceRejectors ()
+
+
+###
+
+# warp_point_rigid.h
+# template <class PointSourceT, class PointTargetT>
+# class WarpPointRigid
+cdef extern from "pcl/registration/warp_point_rigid.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid[Source, Target]:
+        WarpPointRigid (int nr_dim)
+        # public:
+        # virtual void setParam (const Eigen::VectorXf& p) = 0;
+        # void warpPoint (const PointSourceT& pnt_in, PointSourceT& pnt_out) const
+        # int getDimension () const {return nr_dim_;}
+        # const Eigen::Matrix4f& getTransform () const { return transform_matrix_; }
+
+
+###
+
+# correspondence_rejection.h
+# class CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejector:
+        CorrespondenceRejector()
+        # /** \brief Provide a pointer to the vector of the input correspondences.
+        #   * \param[in] correspondences the const boost shared pointer to a correspondence vector
+        #   */
+        # virtual inline void setInputCorrespondences (const CorrespondencesConstPtr &correspondences) 
+        
+        # /** \brief Get a pointer to the vector of the input correspondences.
+        #   * \return correspondences the const boost shared pointer to a correspondence vector
+        #   */
+        # inline CorrespondencesConstPtr getInputCorrespondences ()
+        # CorrespondencesConstPtr getInputCorrespondences ()
+        
+        # /** \brief Run correspondence rejection
+        #   * \param[out] correspondences Vector of correspondences that have not been rejected.
+        #   */
+        # inline void getCorrespondences (pcl::Correspondences &correspondences)
+        # void getCorrespondences (pcl::Correspondences &correspondences)
+        
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * Pure virtual. Compared to \a getCorrespondences this function is
+        #   * stateless, i.e., input correspondences do not need to be provided beforehand,
+        #   * but are directly provided in the function call.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # virtual inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences) = 0;
+        
+        # /** \brief Determine the indices of query points of
+        #   * correspondences that have been rejected, i.e., the difference
+        #   * between the input correspondences (set via \a setInputCorrespondences)
+        #   * and the given correspondence vector.
+        #   * \param[in] correspondences Vector of correspondences after rejection
+        #   * \param[out] indices Vector of query point indices of those correspondences
+        #   * that have been rejected.
+        #   */
+        # inline void getRejectedQueryIndices (const pcl::Correspondences &correspondences, std::vector<int>& indices)
+
+
+###
+
+# namespace pcl
+# namespace registration
+# correspondence_rejection.h
+# /** @b DataContainerInterface provides a generic interface for computing correspondence scores between correspondent
+#   * points in the input and target clouds
+#   * \ingroup registration
+#   */
+# class DataContainerInterface
+# cdef extern from "pcl/registration/correspondence_rejection.h" namespace "pcl::registration" nogil:
+#     cdef cppclass DataContainerInterface:
+#         DataContainerInterface()
+#         public:
+#         virtual ~DataContainerInterface () {}
+#         virtual double getCorrespondenceScore (int index) = 0;
+#         virtual double getCorrespondenceScore (const pcl::Correspondence &) = 0;
+# 
+# 
+# ###
+
+# # /** @b DataContainer is a container for the input and target point clouds and implements the interface 
+# #   * to compute correspondence scores between correspondent points in the input and target clouds ingroup registration
+# #   */
+# # template <typename PointT, typename NormalT=pcl::PointNormal>
+# # class DataContainer : public DataContainerInterface
+# cdef extern from "pcl/registration/correspondence_rejection.h" namespace "pcl::registration" nogil:
+#     cdef cppclass DataContainer[PointT, NormalT](DataContainerInterface):
+#         DataContainer()
+#         # typedef typename pcl::PointCloud<PointT>::ConstPtr PointCloudConstPtr;
+#         # typedef typename pcl::KdTree<PointT>::Ptr KdTreePtr;
+#         # typedef typename pcl::PointCloud<NormalT>::ConstPtr NormalsPtr;
+#         # public:
+#         # /** \brief Empty constructor. */
+#         # DataContainer ()
+#         # 
+#         # /** \brief Provide a source point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.  
+#         #  * \param[in] cloud a cloud containing XYZ data
+#         #  */
+#         # inline void setInputCloud (const PointCloudConstPtr &cloud)
+#         void setInputCloud (const cpp.PointCloud[PointT] &cloud)
+#         
+#         # /** \brief Provide a target point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.  
+#         #  * \param[in] target a cloud containing XYZ data
+#         #  */
+#         # inline void setInputTarget (const PointCloudConstPtr &target)
+#         void setInputTarget (const cpp.PointCloud[PointT] &target)
+#         
+#         # /** \brief Set the normals computed on the input point cloud
+#         #   * \param[in] normals the normals computed for the input cloud
+#         #   */
+#         # inline void setInputNormals (const NormalsPtr &normals)
+#         void setInputNormals (const NormalsPtr &normals)
+#         
+#         # /** \brief Set the normals computed on the target point cloud
+#         #   * \param[in] normals the normals computed for the input cloud
+#         #   */
+#         # inline void setTargetNormals (const NormalsPtr &normals)
+#         void setTargetNormals (const cpp.PointCloudNormals[PointT] &normals)
+#         
+#         # /** \brief Get the normals computed on the input point cloud */
+#         # inline NormalsPtr getInputNormals ()
+#         cpp.NormalsPtr getInputNormals ()
+#         
+#         # /** \brief Get the normals computed on the target point cloud */
+#         # inline NormalsPtr getTargetNormals ()
+#         cpp.NormalsPtr getTargetNormals ()
+#         
+#         # /** \brief Get the correspondence score for a point in the input cloud
+#         #  *  \param[index] index of the point in the input cloud
+#         #  */
+#         # inline double getCorrespondenceScore (int index)
+#         # 
+#         # /** \brief Get the correspondence score for a given pair of correspondent points
+#         #  *  \param[corr] Correspondent points
+#         #  */
+#         # inline double getCorrespondenceScore (const pcl::Correspondence &corr)
+#         # 
+#         # /** \brief Get the correspondence score for a given pair of correspondent points based on the angle betweeen the normals. 
+#         #   * The normmals for the in put and target clouds must be set before using this function
+#         #   * \param[in] corr Correspondent points
+#         #   */
+#         # double getCorrespondenceScoreFromNormals (const pcl::Correspondence &corr)
+# 
+# 
+###
+
+# correspondence_estimation.h
+# template <typename PointSource, typename PointTarget>
+# class CorrespondenceEstimation : public PCLBase<PointSource>
+cdef extern from "pcl/registration/correspondence_estimation.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimation[Source, Target](cpp.PCLBase[Source]):
+        CorrespondenceEstimation()
+        # public:
+        # using PCLBase<PointSource>::initCompute;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # typedef typename pcl::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # 
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the 
+        #   * input source to)
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # virtual inline void setInputTarget (const PointCloudTargetConstPtr &cloud);
+        # 
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudTargetConstPtr const getInputTarget () { return (target_ ); }
+        # 
+        # /** \brief Provide a boost shared pointer to the PointRepresentation to be used when comparing points
+        #   * \param[in] point_representation the PointRepresentation to be used by the k-D tree
+        #   */
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # 
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum distance between correspondences
+        #   */
+        # virtual void determineCorrespondences (pcl::Correspondences &correspondences, float max_distance = std::numeric_limits<float>::max ());
+        # 
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query and target point, distance)
+        #   */
+        # virtual void determineReciprocalCorrespondences (pcl::Correspondences &correspondences);
+
+
+###
+
+### Inheritance ###
+
+# icp.h
+# template <typename PointSource, typename PointTarget>
+# class IterativeClosestPoint : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/icp.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPoint[Source, Target](Registration[Source, Target]):
+        IterativeClosestPoint() except +
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+
+
+ctypedef IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] IterativeClosestPoint_t
+ctypedef IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] IterativeClosestPoint_PointXYZI_t
+ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] IterativeClosestPoint_PointXYZRGB_t
+ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] IterativeClosestPoint_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] IterativeClosestPointPtr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] IterativeClosestPoint_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] IterativeClosestPoint_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] IterativeClosestPoint_PointXYZRGBA_Ptr_t
+###
+
+# gicp.h
+cdef extern from "pcl/registration/gicp.h" namespace "pcl" nogil:
+    cdef cppclass GeneralizedIterativeClosestPoint[Source, Target](Registration[Source, Target]):
+        GeneralizedIterativeClosestPoint() except +
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # typedef typename pcl::KdTree<PointSource> InputKdTree;
+        # typedef typename pcl::KdTree<PointSource>::Ptr InputKdTreePtr;
+        # typedef Eigen::Matrix<double, 6, 1> Vector6d;
+        # public:
+        # /** \brief Provide a pointer to the input dataset
+        #  * \param cloud the const boost shared pointer to a PointCloud message
+        #  */
+        # void setInputCloud (cpp.PointCloudPtr_t ptcloud)
+        # void setInputCloud (cpp.PointCloudPtr_t ptcloud)
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #  * \param[in] target the input point cloud target
+        #  */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &target)
+        # void setInputTarget (const PointCloudTargetConstPtr &target)
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using an iterative
+        #  * non-linear Levenberg-Marquardt approach.
+        #  * \param[in] cloud_src the source point cloud dataset
+        #  * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #  * \param[in] cloud_tgt the target point cloud dataset
+        #  * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #  * \param[out] transformation_matrix the resultant transformation matrix
+        #  */
+        # void estimateRigidTransformationBFGS (
+        #                                const PointCloudSource &cloud_src,
+        #                                const std::vector<int> &indices_src,
+        #                                const PointCloudTarget &cloud_tgt,
+        #                                const std::vector<int> &indices_tgt,
+        #                                Eigen::Matrix4f &transformation_matrix);
+        # void estimateRigidTransformationBFGS (
+        #                                 const PointCloudSource &cloud_src,
+        #                                 const std::vector<int> &indices_src,
+        #                                 const PointCloudTarget &cloud_tgt,
+        #                                 const vector[int] &indices_tgt, 
+        #                                 Matrix4f &transformation_matrix);
+        
+        # /** \brief \return Mahalanobis distance matrix for the given point index */
+        # inline const Eigen::Matrix3d& mahalanobis(size_t index) const
+        # const Matrix3d& mahalanobis(size_t index)
+        
+        # /** \brief Computes rotation matrix derivative.
+        #  * rotation matrix is obtainded from rotation angles x[3], x[4] and x[5]
+        #  * \return d/d_rx, d/d_ry and d/d_rz respectively in g[3], g[4] and g[5]
+        #  * param x array representing 3D transformation
+        #  * param R rotation matrix
+        #  * param g gradient vector
+        #  */
+        # void computeRDerivative(const Vector6d &x, const Eigen::Matrix3d &R, Vector6d &g) const;
+        # void computeRDerivative(const Vector6d &x, const Matrix3d &R, Vector6d &g)
+        
+        # /** \brief Set the rotation epsilon (maximum allowable difference between two 
+        #  * consecutive rotations) in order for an optimization to be considered as having 
+        #  * converged to the final solution.
+        #  * \param epsilon the rotation epsilon
+        #  */
+        # inline void setRotationEpsilon (double epsilon)
+        void setRotationEpsilon (double epsilon)
+        
+        # /** \brief Get the rotation epsilon (maximum allowable difference between two 
+        #  * consecutive rotations) as set by the user.
+        #  */
+        # inline double getRotationEpsilon ()
+        double getRotationEpsilon ()
+        
+        # /** \brief Set the number of neighbors used when selecting a point neighbourhood
+        #   * to compute covariances. 
+        #   * A higher value will bring more accurate covariance matrix but will make 
+        #   * covariances computation slower.
+        #   * \param k the number of neighbors to use when computing covariances
+        #   */
+        void setCorrespondenceRandomness (int k)
+        
+        # /** \brief Get the number of neighbors used when computing covariances as set by the user 
+        #   */
+        int getCorrespondenceRandomness ()
+        
+        # /** set maximum number of iterations at the optimization step
+        #  * \param[in] max maximum number of iterations for the optimizer
+        #  */
+        void setMaximumOptimizerIterations (int max)
+        
+        # ///\return maximum number of iterations at the optimization step
+        int getMaximumOptimizerIterations ()
+
+
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] GeneralizedIterativeClosestPoint_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] GeneralizedIterativeClosestPoint_PointXYZI_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] GeneralizedIterativeClosestPoint_PointXYZRGBA_Ptr_t
+###
+
+# icp_nl.h
+# template <typename PointSource, typename PointTarget>
+# class IterativeClosestPointNonLinear : public IterativeClosestPoint<PointSource, PointTarget>
+#   cdef cppclass IterativeClosestPointNonLinear[Source, Target](Registration[Source, Target]):
+cdef extern from "pcl/registration/icp_nl.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPointNonLinear[Source, Target](IterativeClosestPoint[Source, Target]):
+        IterativeClosestPointNonLinear() except +
+
+
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ] IterativeClosestPointNonLinear_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI] IterativeClosestPointNonLinear_PointXYZI_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB] IterativeClosestPointNonLinear_PointXYZRGB_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA] IterativeClosestPointNonLinear_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ]] IterativeClosestPointNonLinearPtr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB]] IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] IterativeClosestPointNonLinear_PointXYZRGBA_Ptr_t
+###
+
+# bfgs.h
+# template< typename _Scalar >
+# PolynomialSolver is Eigen llibrary
+# Eigen\include\unsupported\Eigen\src\Polynomials\PolynomialSolver.h(29,12)  [SJIS]:  *  \class PolynomialSolverBase.
+# class PolynomialSolver<_Scalar,2> : public PolynomialSolverBase<_Scalar,2>
+# cdef extern from "pcl/registration/bfgs.h" namespace "Eigen" nogil:
+#     cdef cppclass PolynomialSolver[_Scalar, 2](PolynomialSolverBase[_Scalar, 2]):
+#         PolynomialSolver (int nr_dim)
+        # public:
+        # typedef PolynomialSolverBase<_Scalar,2>    PS_Base;
+        # EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES( PS_Base )
+        
+        # public:
+        # template< typename OtherPolynomial > inline PolynomialSolver( const OtherPolynomial& poly, bool& hasRealRoot )
+        # /** Computes the complex roots of a new polynomial. */
+        # template< typename OtherPolynomial > void compute( const OtherPolynomial& poly, bool& hasRealRoot)
+        # template< typename OtherPolynomial > void compute( const OtherPolynomial& poly)
+
+
+###
+
+# bfgs.h
+# template<typename _Scalar, int NX=Eigen::Dynamic>
+# struct BFGSDummyFunctor
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+    # cdef struct BFGSDummyFunctor[_Scalar, NX]:
+        # BFGSDummyFunctor ()
+        # BFGSDummyFunctor(int inputs)
+        # typedef _Scalar Scalar;
+        # enum { InputsAtCompileTime = NX };
+        
+        # typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> VectorType;
+        # const int m_inputs;
+        
+        # int inputs() const { return m_inputs; }
+        # virtual double operator() (const VectorType &x) = 0;
+        # virtual void  df(const VectorType &x, VectorType &df) = 0;
+        # virtual void fdf(const VectorType &x, Scalar &f, VectorType &df) = 0;
+
+
+###
+
+# bfgs.h
+# namespace BFGSSpace {
+#   enum Status {
+#     NegativeGradientEpsilon = -3,
+#     NotStarted = -2,
+#     Running = -1,
+#     Success = 0,
+#     NoProgress = 1
+#   };
+# }
+# 
+###
+
+# bfgs.h
+# /**
+#  * BFGS stands for Broydenletcheroldfarbhanno (BFGS) method for solving 
+#  * unconstrained nonlinear optimization problems. 
+#  * For further details please visit: http://en.wikipedia.org/wiki/BFGS_method
+#  * The method provided here is almost similar to the one provided by GSL.
+#  * It reproduces Fletcher's original algorithm in Practical Methods of Optimization
+#  * algorithms : 2.6.2 and 2.6.4 and uses the same politics in GSL with cubic 
+#  * interpolation whenever it is possible else falls to quadratic interpolation for 
+#  * alpha parameter.
+#  */
+# template<typename FunctorType>
+# class BFGS
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+#     cdef cppclass BFGS[FunctorType]:
+#         # BFGS (FunctorType &_functor) 
+# public:
+#   typedef typename FunctorType::Scalar Scalar;
+#   typedef typename FunctorType::VectorType FVectorType;
+# 
+#   typedef Eigen::DenseIndex Index;
+# 
+#   struct Parameters {
+#     Parameters()
+#     : max_iters(400)
+#       , bracket_iters(100)
+#       , section_iters(100)
+#       , rho(0.01)
+#       , sigma(0.01)
+#       , tau1(9)
+#       , tau2(0.05)
+#       , tau3(0.5)
+#       , step_size(1)
+#       , order(3) {}
+#     Index max_iters;   // maximum number of function evaluation
+#     Index bracket_iters;
+#     Index section_iters;
+#     Scalar rho;
+#     Scalar sigma;
+#     Scalar tau1;
+#     Scalar tau2;
+#     Scalar tau3;
+#     Scalar step_size;
+#     Index order;
+# 
+#   BFGSSpace::Status minimize(FVectorType &x);
+#   BFGSSpace::Status minimizeInit(FVectorType &x);
+#   BFGSSpace::Status minimizeOneStep(FVectorType &x);
+#   BFGSSpace::Status testGradient(Scalar epsilon);
+#   void resetParameters(void) { parameters = Parameters(); }
+#   
+#   Parameters parameters;
+#   Scalar f;
+#   FVectorType gradient;
+# 
+#
+# template<typename FunctorType> void
+# BFGS<FunctorType>::checkExtremum(const Eigen::Matrix<Scalar, 4, 1>& coefficients, Scalar x, Scalar& xmin, Scalar& fmin)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::moveTo(Scalar alpha)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::slope()
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::applyF(Scalar alpha)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::applyDF(Scalar alpha)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::applyFDF(Scalar alpha, Scalar& f, Scalar& df)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::updatePosition (Scalar alpha, FVectorType &x, Scalar &f, FVectorType &g)
+#
+# template<typename FunctorType> void
+# BFGS<FunctorType>::changeDirection ()
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimize(FVectorType  &x)
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimizeInit(FVectorType  &x)
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimizeOneStep(FVectorType  &x)
+# 
+# template<typename FunctorType> typename BFGSSpace::Status 
+# BFGS<FunctorType>::testGradient(Scalar epsilon)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar 
+# BFGS<FunctorType>::interpolate (Scalar a, Scalar fa, Scalar fpa,
+#                                 Scalar b, Scalar fb, Scalar fpb, 
+#                                 Scalar xmin, Scalar xmax,
+#                                 int order)
+# 
+# template<typename FunctorType> BFGSSpace::Status 
+# BFGS<FunctorType>::lineSearch(Scalar rho, Scalar sigma, 
+#                               Scalar tau1, Scalar tau2, Scalar tau3,
+#                               int order, Scalar alpha1, Scalar &alpha_new)
+###
+
+# correspondence_estimation_normal_shooting.h
+# template <typename PointSource, typename PointTarget, typename NormalT>
+# class CorrespondenceEstimationNormalShooting : public CorrespondenceEstimation <PointSource, PointTarget>
+cdef extern from "pcl/registration/correspondence_estimation_normal_shooting.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationNormalShooting[Source, Target, NormalT](CorrespondenceEstimation[Source, Target]):
+        CorrespondenceEstimationNormalShooting()
+        # 
+        # /** \brief Set the normals computed on the input point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        #   */
+        # inline void setSourceNormals (const NormalsPtr &normals)
+        # 
+        # /** \brief Get the normals of the input point cloud
+        #   */
+        # inline NormalsPtr getSourceNormals () const
+        # 
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum distance between the normal on the source point cloud and the corresponding point in the target
+        #   * point cloud
+        #   */
+        # void determineCorrespondences (pcl::Correspondences &correspondences, float max_distance = std::numeric_limits<float>::max ());
+        # 
+        # /** \brief Set the number of nearest neighbours to be considered in the target point cloud
+        #   * \param[in] k the number of nearest neighbours to be considered
+        #   */
+        # inline void setKSearch (unsigned int k)
+        # 
+        # /** \brief Get the number of nearest neighbours considered in the target point cloud for computing correspondence
+        #   */
+        # inline void getKSearch ()
+
+
+###
+
+# correspondence_rejection_distance.h
+# class CorrespondenceRejectorDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorDistance(CorrespondenceRejector):
+        CorrespondenceRejectorDistance()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Set the maximum distance used for thresholding in correspondence rejection.
+        #   * \param[in] distance Distance to be used as maximum distance between correspondences. 
+        #   * Correspondences with larger distances are rejected.
+        #   * \note Internally, the distance will be stored squared.
+        #   */
+        # virtual inline void setMaximumDistance (float distance)
+        # 
+        # /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+        # inline float getMaximumDistance ()
+        # 
+        # /** \brief Provide a source point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # 
+        # /** \brief Provide a target point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+
+
+###
+
+# correspondence_rejection_features.h
+# class CorrespondenceRejectorFeatures: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorFeatures(CorrespondenceRejector):
+        CorrespondenceRejectorFeatures()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] source_feature a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setSourceFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &source_feature, const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setSourceFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr getSourceFeature (const std::string &key);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] target_feature a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setTargetFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &target_feature, const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setTargetFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr getTargetFeature (const std::string &key);
+        # 
+        # /** \brief Set a hard distance threshold in the feature \a FeatureT space, between source and target
+        #   * features. Any feature correspondence that is above this threshold will be considered bad and will be
+        #   * filtered out.
+        #   * \param[in] thresh the distance threshold
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setDistanceThreshold (double thresh, const std::string &key);
+        # 
+        # /** \brief Test that all features are valid (i.e., does each key have a valid source cloud, target cloud, 
+        #   * and search method)
+        #   */
+        # inline bool hasValidFeatures ();
+        # 
+        # /** \brief Provide a boost shared pointer to a PointRepresentation to be used when comparing features
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   * \param[in] fr the point feature representation to be used 
+        #   */
+        # template <typename FeatureT> inline void setFeatureRepresentation (const typename pcl::PointRepresentation<FeatureT>::ConstPtr &fr, const std::string &key);
+
+
+###
+
+# correspondence_rejection_median_distance.h
+# class CorrespondenceRejectorMedianDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_median_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorMedianDistance(CorrespondenceRejector):
+        CorrespondenceRejectorMedianDistance()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       public:
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void 
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                      pcl::Correspondences& remaining_correspondences);
+# 
+#         /** \brief Get the median distance used for thresholding in correspondence rejection. */
+#         inline double getMedianDistance () const
+# 
+#         /** \brief Provide a source point cloud dataset (must contain XYZ
+#           * data!), used to compute the correspondence distance.  
+#           * \param[in] cloud a cloud containing XYZ data
+#           */
+#         template <typename PointT> inline void 
+#         setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+# 
+#         /** \brief Provide a target point cloud dataset (must contain XYZ
+#           * data!), used to compute the correspondence distance.  
+#           * \param[in] target a cloud containing XYZ data
+#           */
+#         template <typename PointT> inline void 
+#         setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+# 
+#         /** \brief Set the factor for correspondence rejection. Points with distance greater than median times factor
+#          *  will be rejected
+#          *  \param[in] factor value
+#          */
+#         inline void setMedianFactor (double factor)
+# 
+#         /** \brief Get the factor used for thresholding in correspondence rejection. */
+#         inline double getMedianFactor () const { return factor_; };
+# 
+###
+
+# correspondence_rejection_one_to_one.h
+# class CorrespondenceRejectorOneToOne: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_one_to_one.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorOneToOne(CorrespondenceRejector):
+        CorrespondenceRejectorOneToOne()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       public:
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void 
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                      pcl::Correspondences& remaining_correspondences);
+# 
+#       protected:
+#         /** \brief Apply the rejection algorithm.
+#           * \param[out] correspondences the set of resultant correspondences.
+#           */
+#         inline void 
+#         applyRejection (pcl::Correspondences &correspondences)
+#         {
+#           getRemainingCorrespondences (*input_correspondences_, correspondences);
+#         }
+#     };
+
+# 
+###
+ 
+# correspondence_rejection_sample_consensus.h
+# template <typename PointT>
+# class CorrespondenceRejectorSampleConsensus: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_sample_consensus.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSampleConsensus[T](CorrespondenceRejector):
+        CorrespondenceRejectorSampleConsensus()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       public:
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void 
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                      pcl::Correspondences& remaining_correspondences);
+# 
+#         /** \brief Provide a source point cloud dataset (must contain XYZ data!)
+#           * \param[in] cloud a cloud containing XYZ data
+#           */
+#         virtual inline void 
+#         setInputCloud (const PointCloudConstPtr &cloud) { input_ = cloud; }
+# 
+#         /** \brief Provide a target point cloud dataset (must contain XYZ data!)
+#           * \param[in] cloud a cloud containing XYZ data
+#           */
+#         virtual inline void 
+#         setTargetCloud (const PointCloudConstPtr &cloud) { target_ = cloud; }
+# 
+#         /** \brief Set the maximum distance between corresponding points.
+#           * Correspondences with distances below the threshold are considered as inliers.
+#           * \param[in] threshold Distance threshold in the same dimension as source and target data sets.
+#           */
+#         inline void 
+#         setInlierThreshold (double threshold) { inlier_threshold_ = threshold; };
+# 
+#         /** \brief Get the maximum distance between corresponding points.
+#           * \return Distance threshold in the same dimension as source and target data sets.
+#           */
+#         inline double 
+#         getInlierThreshold() { return inlier_threshold_; };
+# 
+#         /** \brief Set the maximum number of iterations.
+#           * \param[in] max_iterations Maximum number if iterations to run
+#           */
+#         inline void 
+#         setMaxIterations (int max_iterations) {max_iterations_ = std::max(max_iterations, 0); };
+# 
+#         /** \brief Get the maximum number of iterations.
+#           * \return max_iterations Maximum number if iterations to run
+#           */
+#         inline int 
+#         getMaxIterations () { return max_iterations_; };
+# 
+#         /** \brief Get the best transformation after RANSAC rejection.
+#           * \return The homogeneous 4x4 transformation yielding the largest number of inliers.
+#           */
+#         inline Eigen::Matrix4f 
+#         getBestTransformation () { return best_transformation_; };
+# 
+###
+
+# correspondence_rejection_surface_normal.h
+# class CorrespondenceRejectorSurfaceNormal : public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_surface_normal.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSurfaceNormal(CorrespondenceRejector):
+        CorrespondenceRejectorSurfaceNormal()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       public:
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void 
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                      pcl::Correspondences& remaining_correspondences);
+# 
+#         /** \brief Set the thresholding angle between the normals for correspondence rejection. 
+#           * \param[in] threshold cosine of the thresholding angle between the normals for rejection
+#           */
+#         inline void
+#         setThreshold (double threshold) { threshold_ = threshold; };
+# 
+#         /** \brief Get the thresholding angle between the normals for correspondence rejection. */
+#         inline double
+#         getThreshold () const { return threshold_; };
+# 
+#         /** \brief Initialize the data container object for the point type and the normal type
+#           */
+#         template <typename PointT, typename NormalT> inline void 
+#         initializeDataContainer ()
+#
+#         /** \brief Provide a source point cloud dataset (must contain XYZ
+#           * data!), used to compute the correspondence distance.  
+#           * \param[in] cloud a cloud containing XYZ data
+#           */
+#         template <typename PointT> inline void 
+#         setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &input)
+# 
+#         /** \brief Provide a target point cloud dataset (must contain XYZ
+#           * data!), used to compute the correspondence distance.  
+#           * \param[in] target a cloud containing XYZ data
+#           */
+#         template <typename PointT> inline void 
+#         setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+# 
+#         /** \brief Set the normals computed on the input point cloud
+#           * \param[in] normals the normals computed for the input cloud
+#           */
+#         template <typename PointT, typename NormalT> inline void 
+#         setInputNormals (const typename pcl::PointCloud<NormalT>::ConstPtr &normals)
+# 
+#         /** \brief Set the normals computed on the target point cloud
+#           * \param[in] normals the normals computed for the input cloud
+#           */
+#         template <typename PointT, typename NormalT> inline void 
+#         setTargetNormals (const typename pcl::PointCloud<NormalT>::ConstPtr &normals)
+# 
+#         /** \brief Get the normals computed on the input point cloud */
+#         template <typename NormalT> inline typename pcl::PointCloud<NormalT>::Ptr
+#         getInputNormals () const { return boost::static_pointer_cast<DataContainer<pcl::PointXYZ, NormalT> > (data_container_)->getInputNormals (); }
+# 
+#         /** \brief Get the normals computed on the target point cloud */
+#         template <typename NormalT> inline typename pcl::PointCloud<NormalT>::Ptr
+#         getTargetNormals () const { return boost::static_pointer_cast<DataContainer<pcl::PointXYZ, NormalT> > (data_container_)->getTargetNormals (); }
+###
+
+# correspondence_rejection_trimmed.h
+#     class CorrespondenceRejectorTrimmed: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_trimmed.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorTrimmed(CorrespondenceRejector):
+        CorrespondenceRejectorTrimmed()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       public:
+#         /** \brief Set the expected ratio of overlap between point clouds (in
+#           * terms of correspondences).
+#           * \param[in] ratio ratio of overlap between 0 (no overlap, no
+#           * correspondences) and 1 (full overlap, all correspondences)
+#           */
+#         virtual inline void setOverlapRadio (float ratio)
+# 
+#         /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+#         inline float getOverlapRadio ()
+# 
+#         /** \brief Set a minimum number of correspondences. If the specified overlap ratio causes to have
+#           * less correspondences,  \a CorrespondenceRejectorTrimmed will try to return at least
+#           * \a nr_min_correspondences_ correspondences (or all correspondences in case \a nr_min_correspondences_
+#           * is less than the number of given correspondences). 
+#           * \param[in] min_correspondences the minimum number of correspondences
+#           */
+#         inline void setMinCorrespondences (unsigned int min_correspondences) { nr_min_correspondences_ = min_correspondences; };
+# 
+#         /** \brief Get the minimum number of correspondences. */
+#         inline unsigned int getMinCorrespondences ()
+#
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences,
+#                                      pcl::Correspondences& remaining_correspondences);
+#       protected:
+#         /** \brief Apply the rejection algorithm.
+#           * \param[out] correspondences the set of resultant correspondences.
+#           */
+#         inline void 
+#         applyRejection (pcl::Correspondences &correspondences)
+#         {
+#           getRemainingCorrespondences (*input_correspondences_, correspondences);
+#         }
+# 
+#         /** Overlap Ratio in [0..1] */
+#         float overlap_ratio_;
+# 
+#         /** Minimum number of correspondences. */
+#         unsigned int nr_min_correspondences_;
+###
+
+# correspondence_rejection_var_trimmed.h
+#     class CorrespondenceRejectorVarTrimmed: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_var_trimmed.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorVarTrimmed(CorrespondenceRejector):
+        CorrespondenceRejectorVarTrimmed()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       public:
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void 
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                      pcl::Correspondences& remaining_correspondences);
+# 
+#         /** \brief Get the trimmed distance used for thresholding in correspondence rejection. */
+#         inline double
+#         getTrimmedDistance () const { return trimmed_distance_; };
+# 
+#         /** \brief Provide a source point cloud dataset (must contain XYZ
+#           * data!), used to compute the correspondence distance.  
+#           * \param[in] cloud a cloud containing XYZ data
+#           */
+#         template <typename PointT> inline void 
+#         setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+# 
+#         /** \brief Provide a target point cloud dataset (must contain XYZ
+#           * data!), used to compute the correspondence distance.  
+#           * \param[in] target a cloud containing XYZ data
+#           */
+#         template <typename PointT> inline void 
+#         setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+# 
+#         /** \brief Get the computed inlier ratio used for thresholding in correspondence rejection. */
+#         inline double
+#         getTrimFactor () const { return factor_; }
+# 
+#         /** brief set the minimum overlap ratio
+#           * \param[in] ratio the overlap ratio [0..1]
+#           */
+#         inline void
+#         setMinRatio (double ratio) { min_ratio_ = ratio; }
+# 
+#         /** brief get the minimum overlap ratio
+#           */
+#         inline double
+#         getMinRatio () const { return min_ratio_; }
+# 
+#         /** brief set the maximum overlap ratio
+#           * \param[in] ratio the overlap ratio [0..1]
+#           */
+#         inline void
+#         setMaxRatio (double ratio) { max_ratio_ = ratio; }
+# 
+#         /** brief get the maximum overlap ratio
+#           */
+#         inline double
+#         getMaxRatio () const { return max_ratio_; }
+#       protected:
+#         /** \brief Apply the rejection algorithm.
+#           * \param[out] correspondences the set of resultant correspondences.
+#           */
+#         inline void 
+#         applyRejection (pcl::Correspondences &correspondences)
+#         {
+#           getRemainingCorrespondences (*input_correspondences_, correspondences);
+#         }
+# 
+#         /** \brief The inlier distance threshold (based on the computed trim factor) between two correspondent points in source <-> target.
+#           */
+#         double trimmed_distance_;
+# 
+#         /** \brief The factor for correspondence rejection. Only factor times the total points sorted based on 
+#          *  the correspondence distances will be considered as inliers. Remaining points are rejected. This factor is
+#          *  computed internally 
+#          */
+#         double factor_;
+# 
+#         /** \brief The minimum overlap ratio between the input and target clouds
+#          */
+#         double min_ratio_;
+# 
+#         /** \brief The maximum overlap ratio between the input and target clouds
+#          */
+#         double max_ratio_;
+# 
+#                 /** \brief part of the term that balances the root mean square difference. This is an internal parameter
+#          */
+#         double lambda_;
+# 
+#         typedef boost::shared_ptr<DataContainerInterface> DataContainerPtr;
+# 
+#         /** \brief A pointer to the DataContainer object containing the input and target point clouds */
+#         DataContainerPtr data_container_;
+# 
+###
+
+# correspondence_sorting.h
+#     /** @b sortCorrespondencesByQueryIndex : a functor for sorting correspondences by query index
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByQueryIndex : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.index_query < b.index_query);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByMatchIndex : a functor for sorting correspondences by match index
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByMatchIndex : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.index_match < b.index_match);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByDistance : a functor for sorting correspondences by distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.distance < b.distance);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByQueryIndexAndDistance : a functor for sorting correspondences by query index _and_ distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByQueryIndexAndDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       inline bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         if (a.index_query < b.index_query)
+#           return (true);
+#         else if ( (a.index_query == b.index_query) && (a.distance < b.distance) )
+#           return (true);
+#         return (false);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByMatchIndexAndDistance : a functor for sorting correspondences by match index _and_ distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByMatchIndexAndDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       inline bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         if (a.index_match < b.index_match)
+#           return (true);
+#         else if ( (a.index_match == b.index_match) && (a.distance < b.distance) )
+#           return (true);
+#         return (false);
+#       }
+#     };
+
+# 
+###
+
+# correspondence_types.h
+#     /** \brief calculates the mean and standard deviation of descriptor distances from correspondences
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] mean the mean descriptor distance of correspondences
+#       * \param[out] stddev the standard deviation of descriptor distances.
+#       * \note The sample varaiance is used to determine the standard deviation
+#       */
+#     inline void 
+#     getCorDistMeanStd (const pcl::Correspondences& correspondences, double &mean, double &stddev);
+# 
+#     /** \brief extracts the query indices
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] indices array of extracted indices.
+#       * \note order of indices corresponds to input list of descriptor correspondences
+#       */
+#     inline void 
+#     getQueryIndices (const pcl::Correspondences& correspondences, std::vector<int>& indices);
+# 
+#     /** \brief extracts the match indices
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] indices array of extracted indices.
+#       * \note order of indices corresponds to input list of descriptor correspondences
+#       */
+#     inline void 
+#     getMatchIndices (const pcl::Correspondences& correspondences, std::vector<int>& indices);
+
+# 
+###
+
+# distances.h
+#     /** \brief Compute the median value from a set of doubles
+#       * \param[in] fvec the set of doubles
+#       * \param[in] m the number of doubles in the set
+#       */
+#     inline double 
+#     computeMedian (double *fvec, int m)
+#     {
+#       // Copy the values to vectors for faster sorting
+#       std::vector<double> data (m);
+#       memcpy (&data[0], fvec, sizeof (double) * m);
+#       
+#       std::nth_element(data.begin(), data.begin() + (data.size () >> 1), data.end());
+#       return (data[data.size () >> 1]);
+#     }
+# 
+#     /** \brief Use a Huber kernel to estimate the distance between two vectors
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       * \param[in] sigma the sigma value
+#       */
+#     inline double
+#     huber (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt, double sigma) 
+#     {
+#       Eigen::Array4f diff = (p_tgt.array () - p_src.array ()).abs ();
+#       double norm = 0.0;
+#       for (int i = 0; i < 3; ++i)
+#       {
+#         if (diff[i] < sigma)
+#           norm += diff[i] * diff[i];
+#         else
+#           norm += 2.0 * sigma * diff[i] - sigma * sigma;
+#       }
+#       return (norm);
+#     }
+# 
+#     /** \brief Use a Huber kernel to estimate the distance between two vectors
+#       * \param[in] diff the norm difference between two vectors
+#       * \param[in] sigma the sigma value
+#       */
+#     inline double
+#     huber (double diff, double sigma) 
+#     {
+#       double norm = 0.0;
+#       if (diff < sigma)
+#         norm += diff * diff;
+#       else
+#         norm += 2.0 * sigma * diff - sigma * sigma;
+#       return (norm);
+#     }
+# 
+#     /** \brief Use a Gedikli kernel to estimate the distance between two vectors
+#       * (for more information, see 
+#       * \param[in] val the norm difference between two vectors
+#       * \param[in] clipping the clipping value
+#       * \param[in] slope the slope. Default: 4
+#       */
+#     inline double
+#     gedikli (double val, double clipping, double slope = 4) 
+#     {
+#       return (1.0 / (1.0 + pow (fabs(val) / clipping, slope)));
+#     }
+# 
+#     /** \brief Compute the Manhattan distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l1 (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src.array () - p_tgt.array ()).abs ().sum ());
+#     }
+# 
+#     /** \brief Compute the Euclidean distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l2 (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src - p_tgt).norm ());
+#     }
+# 
+#     /** \brief Compute the squared Euclidean distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l2Sqr (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src - p_tgt).squaredNorm ());
+#     }
+
+# 
+# ###
+
+# eigen.h
+# # 
+# #include <Eigen/Core>
+# #include <Eigen/Geometry>
+# #include <unsupported/Eigen/Polynomials>
+# #include <Eigen/Dense>
+###
+
+# elch.h
+# template <typename PointT>
+# class ELCH : public PCLBase<PointT>
+cdef extern from "pcl/registration/elch.h" namespace "pcl::registration" nogil:
+    cdef cppclass ELCH[T](cpp.PCLBase[T]):
+        ELCH()
+#       public:
+#         typedef boost::shared_ptr< ELCH<PointT> > Ptr;
+#         typedef boost::shared_ptr< const ELCH<PointT> > ConstPtr;
+#         typedef pcl::PointCloud<PointT> PointCloud;
+#         typedef typename PointCloud::Ptr PointCloudPtr;
+#         typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#         struct Vertex
+#         {
+#           Vertex () : cloud () {}
+#           PointCloudPtr cloud;
+#         };
+# 
+#         /** \brief graph structure to hold the SLAM graph */
+#         typedef boost::adjacency_list<
+#           boost::listS, boost::vecS, boost::undirectedS,
+#           Vertex,
+#           boost::no_property>
+#         LoopGraph;
+#         typedef boost::shared_ptr< LoopGraph > LoopGraphPtr;
+#         typedef typename pcl::Registration<PointT, PointT> Registration;
+#         typedef typename Registration::Ptr RegistrationPtr;
+#         typedef typename Registration::ConstPtr RegistrationConstPtr;
+#
+#         /** \brief Add a new point cloud to the internal graph.
+#          * \param[in] cloud the new point cloud
+#          */
+#         inline void
+#         addPointCloud (PointCloudPtr cloud)
+# 
+#         /** \brief Getter for the internal graph. */
+#         inline LoopGraphPtr
+#         getLoopGraph ()
+# 
+#         /** \brief Setter for a new internal graph.
+#          * \param[in] loop_graph the new graph
+#          */
+#         inline void
+#         setLoopGraph (LoopGraphPtr loop_graph)
+# 
+#         /** \brief Getter for the first scan of a loop. */
+#         inline typename boost::graph_traits<LoopGraph>::vertex_descriptor
+#         getLoopStart ()
+#
+#         /** \brief Setter for the first scan of a loop.
+#          * \param[in] loop_start the scan that starts the loop
+#          */
+#         inline void
+#         setLoopStart (const typename boost::graph_traits<LoopGraph>::vertex_descriptor &loop_start)
+#
+#         /** \brief Getter for the last scan of a loop. */
+#         inline typename boost::graph_traits<LoopGraph>::vertex_descriptor
+#         getLoopEnd ()
+# 
+#         /** \brief Setter for the last scan of a loop.
+#          * \param[in] loop_end the scan that ends the loop
+#          */
+#         inline void
+#         setLoopEnd (const typename boost::graph_traits<LoopGraph>::vertex_descriptor &loop_end)
+# 
+#         /** \brief Getter for the registration algorithm. */
+#         inline RegistrationPtr
+#         getReg ()
+# 
+#         /** \brief Setter for the registration algorithm.
+#          * \param[in] reg the registration algorithm used to compute the transformation between the start and the end of the loop
+#          */
+#         inline void setReg (RegistrationPtr reg)
+# 
+#         /** \brief Getter for the transformation between the first and the last scan. */
+#         inline Eigen::Matrix4f getLoopTransform ()
+# 
+#         /** \brief Setter for the transformation between the first and the last scan.
+#          * \param[in] loop_transform the transformation between the first and the last scan
+#          */
+#         inline void setLoopTransform (const Eigen::Matrix4f &loop_transform)
+# 
+#         /** \brief Computes now poses for all point clouds by closing the loop
+#          * between start and end point cloud. This will transform all given point
+#          * clouds for now!
+#          */
+#         void compute ();
+#       protected:
+#         using PCLBase<PointT>::deinitCompute;
+# 
+#         /** \brief This method should get called before starting the actual computation. */
+#         virtual bool initCompute ();
+#       public:
+#         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+# 
+# # exceptions.h
+# # pcl/exceptions
+# #  /** \class SolverDidntConvergeException
+# #     * \brief An exception that is thrown when the non linear solver didn't converge
+# #     */
+# #   class PCL_EXPORTS SolverDidntConvergeException : public PCLException
+# #   {
+# #     public:
+# #     
+# #     SolverDidntConvergeException (const std::string& error_description,
+# #                                   const std::string& file_name = "",
+# #                                   const std::string& function_name = "" ,
+# #                                   unsigned line_number = 0) throw ()
+# #       : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+# #   } ;
+# # 
+# #  /** \class NotEnoughPointsException
+# #     * \brief An exception that is thrown when the number of correspondants is not equal
+# #     * to the minimum required
+# #     */
+# #   class PCL_EXPORTS NotEnoughPointsException : public PCLException
+# #   {
+# #     public:
+# #     
+# #     NotEnoughPointsException (const std::string& error_description,
+# #                               const std::string& file_name = "",
+# #                               const std::string& function_name = "" ,
+# #                               unsigned line_number = 0) throw ()
+# #       : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+# #   } ;
+# # 
+# ###
+
+# ia_ransac.h
+# template <typename PointSource, typename PointTarget, typename FeatureT>
+# class SampleConsensusInitialAlignment : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ia_ransac.h" namespace "pcl" nogil:
+    cdef cppclass SampleConsensusInitialAlignment[Source, Target, Feature](Registration[Source, Target]):
+        SampleConsensusInitialAlignment() except +
+        # public:
+        # using Registration<PointSource, PointTarget>::reg_name_;
+        # using Registration<PointSource, PointTarget>::input_;
+        # using Registration<PointSource, PointTarget>::indices_;
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # using Registration<PointSource, PointTarget>::corr_dist_threshold_;
+        # using Registration<PointSource, PointTarget>::min_number_correspondences_;
+        # using Registration<PointSource, PointTarget>::max_iterations_;
+        # using Registration<PointSource, PointTarget>::tree_;
+        # using Registration<PointSource, PointTarget>::transformation_estimation_;
+        # using Registration<PointSource, PointTarget>::getClassName;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # ctypedef pcl::PointCloud<FeatureT> FeatureCloud;
+        # ctypedef typename FeatureCloud::Ptr FeatureCloudPtr;
+        # ctypedef typename FeatureCloud::ConstPtr FeatureCloudConstPtr;
+        # cdef cppclass ErrorFunctor
+        # {
+        #   public:
+        #     virtual ~ErrorFunctor () {}
+        #     virtual float operator () (float d) const = 0;
+        # };
+        # class HuberPenalty : public ErrorFunctor
+        # cdef cppclass HuberPenalty(ErrorFunctor)
+        #     HuberPenalty ()
+        #   public:
+        #     HuberPenalty (float threshold)
+        #     virtual float operator () (float e) const
+        #     { 
+        #       if (e <= threshold_)
+        #         return (0.5 * e*e); 
+        #       else
+        #         return (0.5 * threshold_ * (2.0 * fabs (e) - threshold_));
+        #     }
+        #   protected:
+        #     float threshold_;
+        # };
+        # class TruncatedError : public ErrorFunctor
+        # cdef cppclass TruncatedError(ErrorFunctor)
+        #     TruncatedError ()
+        #   public:
+        #     virtual ~TruncatedError () {}
+        #     TruncatedError (float threshold) : threshold_ (threshold) {}
+        #     virtual float operator () (float e) const
+        #     { 
+        #       if (e <= threshold_)
+        #         return (e / threshold_);
+        #       else
+        #         return (1.0);
+        #     }
+        #   protected:
+        #     float threshold_;
+        # };
+        # typedef typename KdTreeFLANN<FeatureT>::Ptr FeatureKdTreePtr; 
+        # /** \brief Provide a boost shared pointer to the source point cloud's feature descriptors
+        #   * \param features the source point cloud's features
+        #   */
+        # void 
+        # setSourceFeatures (const FeatureCloudConstPtr &features);
+        # /** \brief Get a pointer to the source point cloud's features */
+        # inline FeatureCloudConstPtr const 
+        # getSourceFeatures () { return (input_features_); }
+        # /** \brief Provide a boost shared pointer to the target point cloud's feature descriptors
+        #   * \param features the target point cloud's features
+        #   */
+        # void 
+        # setTargetFeatures (const FeatureCloudConstPtr &features);
+        # /** \brief Get a pointer to the target point cloud's features */
+        # inline FeatureCloudConstPtr const 
+        # getTargetFeatures () { return (target_features_); }
+        # /** \brief Set the minimum distances between samples
+        #   * \param min_sample_distance the minimum distances between samples
+        #   */
+        # void 
+        # setMinSampleDistance (float min_sample_distance) { min_sample_distance_ = min_sample_distance; }
+        # /** \brief Get the minimum distances between samples, as set by the user */
+        # float 
+        # getMinSampleDistance () { return (min_sample_distance_); }
+        # /** \brief Set the number of samples to use during each iteration
+        #   * \param nr_samples the number of samples to use during each iteration
+        #   */
+        # void 
+        # setNumberOfSamples (int nr_samples) { nr_samples_ = nr_samples; }
+        # /** \brief Get the number of samples to use during each iteration, as set by the user */
+        # int 
+        # getNumberOfSamples () { return (nr_samples_); }
+        # /** \brief Set the number of neighbors to use when selecting a random feature correspondence.  A higher value will
+        #   * add more randomness to the feature matching.
+        #   * \param k the number of neighbors to use when selecting a random feature correspondence.
+        #   */
+        # void
+        # setCorrespondenceRandomness (int k) { k_correspondences_ = k; }
+        # /** \brief Get the number of neighbors used when selecting a random feature correspondence, as set by the user */
+        # int
+        # getCorrespondenceRandomness () { return (k_correspondences_); }
+        # /** \brief Specify the error function to minimize
+        #  * \note This call is optional.  TruncatedError will be used by default
+        #  * \param[in] error_functor a shared pointer to a subclass of SampleConsensusInitialAlignment::ErrorFunctor
+        #  */
+        # void
+        # setErrorFunction (const boost::shared_ptr<ErrorFunctor> & error_functor) { error_functor_ = error_functor; }
+        # /** \brief Get a shared pointer to the ErrorFunctor that is to be minimized  
+        #  * \return A shared pointer to a subclass of SampleConsensusInitialAlignment::ErrorFunctor
+        #  */
+        # boost::shared_ptr<ErrorFunctor>
+        # getErrorFunction () { return (error_functor_); }
+        # protected:
+        # /** \brief Choose a random index between 0 and n-1
+        #   * \param n the number of possible indices to choose from
+        #   */
+        # inline int 
+        # getRandomIndex (int n) { return (static_cast<int> (n * (rand () / (RAND_MAX + 1.0)))); };
+        # /** \brief Select \a nr_samples sample points from cloud while making sure that their pairwise distances are 
+        #   * greater than a user-defined minimum distance, \a min_sample_distance.
+        #   * \param cloud the input point cloud
+        #   * \param nr_samples the number of samples to select
+        #   * \param min_sample_distance the minimum distance between any two samples
+        #   * \param sample_indices the resulting sample indices
+        #   */
+        # void 
+        # selectSamples (const PointCloudSource &cloud, int nr_samples, float min_sample_distance, 
+        #                std::vector<int> &sample_indices);
+        # /** \brief For each of the sample points, find a list of points in the target cloud whose features are similar to 
+        #   * the sample points' features. From these, select one randomly which will be considered that sample point's 
+        #   * correspondence. 
+        #   * \param input_features a cloud of feature descriptors
+        #   * \param sample_indices the indices of each sample point
+        #   * \param corresponding_indices the resulting indices of each sample's corresponding point in the target cloud
+        #   */
+        # void 
+        # findSimilarFeatures (const FeatureCloud &input_features, const std::vector<int> &sample_indices, 
+        #                      std::vector<int> &corresponding_indices);
+        # /** \brief An error metric for that computes the quality of the alignment between the given cloud and the target.
+        #   * \param cloud the input cloud
+        #   * \param threshold distances greater than this value are capped
+        #   */
+        # float 
+        # computeErrorMetric (const PointCloudSource &cloud, float threshold);
+        # /** \brief Rigid transformation computation method.
+        #   * \param output the transformed input point cloud dataset using the rigid transformation found
+        #   */
+        # virtual void 
+        # computeTransformation (PointCloudSource &output, const Eigen::Matrix4f& guess);
+        # /** \brief The source point cloud's feature descriptors. */
+        # FeatureCloudConstPtr input_features_;
+        # /** \brief The target point cloud's feature descriptors. */
+        # FeatureCloudConstPtr target_features_;  
+        # /** \brief The number of samples to use during each iteration. */
+        # int nr_samples_;
+        # /** \brief The minimum distances between samples. */
+        # float min_sample_distance_;
+        # /** \brief The number of neighbors to use when selecting a random feature correspondence. */
+        # int k_correspondences_;
+        # /** \brief The KdTree used to compare feature descriptors. */
+        # FeatureKdTreePtr feature_tree_;               
+        # /** */
+        # boost::shared_ptr<ErrorFunctor> error_functor_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+
+# ppf_registration.h
+# template <typename PointSource, typename PointTarget>
+# class PPFRegistration : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ppf_registration.h" namespace "pcl" nogil:
+    cdef cppclass PPFRegistration[Source, Target](Registration[Source, Target]):
+        PPFRegistration() except +
+        # public:
+        # cdef struct PoseWithVotes
+        #   PoseWithVotes(Eigen::Affine3f &a_pose, unsigned int &a_votes)
+        #   Eigen::Affine3f pose;
+        #   unsigned int votes;
+        # ctypedef std::vector<PoseWithVotes, Eigen::aligned_allocator<PoseWithVotes> > PoseWithVotesList;
+        # /// input_ is the model cloud
+        # using Registration<PointSource, PointTarget>::input_;
+        # /// target_ is the scene cloud
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::converged_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # ctypedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        
+        # /** \brief Method for setting the position difference clustering parameter
+        #  * \param clustering_position_diff_threshold distance threshold below which two poses are
+        #  * considered close enough to be in the same cluster (for the clustering phase of the algorithm)
+        #  */
+        # inline void setPositionClusteringThreshold (float clustering_position_diff_threshold)
+        
+        # /** \brief Returns the parameter defining the position difference clustering parameter -
+        #  * distance threshold below which two poses are considered close enough to be in the same cluster
+        #  * (for the clustering phase of the algorithm)
+        #  */
+        # inline float getPositionClusteringThreshold ()
+        
+        # /** \brief Method for setting the rotation clustering parameter
+        #  * \param clustering_rotation_diff_threshold rotation difference threshold below which two
+        #  * poses are considered to be in the same cluster (for the clustering phase of the algorithm)
+        #  */
+        # inline void setRotationClusteringThreshold (float clustering_rotation_diff_threshold)
+        
+        # /** \brief Returns the parameter defining the rotation clustering threshold
+        #  */
+        # inline float getRotationClusteringThreshold ()
+        
+        # /** \brief Method for setting the scene reference point sampling rate
+        #  * \param scene_reference_point_sampling_rate sampling rate for the scene reference point
+        #  */
+        # inline void setSceneReferencePointSamplingRate (unsigned int scene_reference_point_sampling_rate) { scene_reference_point_sampling_rate_ = scene_reference_point_sampling_rate; }
+        # /** \brief Returns the parameter for the scene reference point sampling rate of the algorithm */
+        # inline unsigned int getSceneReferencePointSamplingRate ()
+        
+        # /** \brief Function that sets the search method for the algorithm
+        #  * \note Right now, the only available method is the one initially proposed by
+        #  * the authors - by using a hash map with discretized feature vectors
+        #  * \param search_method smart pointer to the search method to be set
+        #  */
+        # inline void setSearchMethod (PPFHashMapSearch::Ptr search_method)
+        
+        # /** \brief Getter function for the search method of the class */
+        # inline PPFHashMapSearch::Ptr getSearchMethod ()
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #  * \param cloud the input point cloud target
+        #  */
+        # void setInputTarget (const PointCloudTargetConstPtr &cloud);
+
+###
+
+# pyramid_feature_matching.h
+# template <typename PointFeature>
+# class PyramidFeatureHistogram : public PCLBase<PointFeature>
+# cdef cppclass PyramidFeatureHistogram[PointFeature](PCLBase[PointFeature]):
+cdef extern from "pcl/registration/pyramid_feature_matching.h" namespace "pcl" nogil:
+    cdef cppclass PyramidFeatureHistogram[PointFeature]:
+        PyramidFeatureHistogram() except +
+        # public:
+        # using PCLBase<PointFeature>::input_;
+        # ctypedef boost::shared_ptr<PyramidFeatureHistogram<PointFeature> > Ptr;
+        # ctypedef Ptr PyramidFeatureHistogramPtr;
+        # ctypedef boost::shared_ptr<const pcl::PointRepresentation<PointFeature> > FeatureRepresentationConstPtr;
+        # /** \brief Method for setting the input dimension range parameter.
+        #  * \note Please check the PyramidHistogram class description for more details about this parameter.
+        #  */
+        # inline void setInputDimensionRange (std::vector<std::pair<float, float> > &dimension_range_input)
+        # void setInputDimensionRange (vector[pair[float, float] ] &dimension_range_input)
+        
+        # /** \brief Method for retrieving the input dimension range vector */
+        # inline std::vector<std::pair<float, float> > getInputDimensionRange () { return dimension_range_input_; }
+        # vector[pair[float, float] ] getInputDimensionRange ()
+        
+        # /** \brief Method to set the target dimension range parameter.
+        #  * \note Please check the PyramidHistogram class description for more details about this parameter.
+        #  */
+        # inline void setTargetDimensionRange (std::vector<std::pair<float, float> > &dimension_range_target)
+        void setTargetDimensionRange (vector[pair[float, float] ] &dimension_range_target)
+        
+        # /** \brief Method for retrieving the target dimension range vector */
+        # inline std::vector<std::pair<float, float> > getTargetDimensionRange () { return dimension_range_target_; }
+        vector[pair[float, float] ] getTargetDimensionRange ()
+        
+        # /** \brief Provide a pointer to the feature representation to use to convert features to k-D vectors.
+        #  * \param feature_representation the const boost shared pointer to a PointRepresentation
+        #  */
+        # inline void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation) { feature_representation_ = feature_representation; }
+        # /** \brief Get a pointer to the feature representation used when converting features into k-D vectors. */
+        # inline FeatureRepresentationConstPtr const getPointRepresentation () { return feature_representation_; }
+        
+        # /** \brief The central method for inserting the feature set inside the pyramid and obtaining the complete pyramid */
+        # void compute ();
+        
+        # /** \brief Checks whether the pyramid histogram has been computed */
+        # inline bool isComputed () { return is_computed_; }
+        
+        # /** \brief Static method for comparing two pyramid histograms that returns a floating point value between 0 and 1,
+        #  * representing the similiarity between the feature sets on which the two pyramid histograms are based.
+        #  * \param pyramid_a Pointer to the first pyramid to be compared (needs to be computed already).
+        #  * \param pyramid_b Pointer to the second pyramid to be compared (needs to be computed already).
+        #  */
+        # static float comparePyramidFeatureHistograms (const PyramidFeatureHistogramPtr &pyramid_a, const PyramidFeatureHistogramPtr &pyramid_b);
+
+
+###
+
+# transformation_estimation.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationEstimation
+cdef extern from "pcl/registration/transformation_estimation.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimation[Source, Target](Registration[Source, Target]):
+        TransformationEstimation() except +
+        # public:
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+
+# ctypedef shared_ptr[TransformationEstimation<PointSource, PointTarget> > Ptr;
+# ctypedef shared_ptr[const TransformationEstimation<PointSource, PointTarget> > ConstPtr;
+
+###
+
+# transformation_estimation_lm.h
+
+# template <typename PointSource, typename PointTarget>
+# class TransformationEstimationLM : public TransformationEstimation<PointSource, PointTarget>
+cdef extern from "pcl/registration/transformation_estimation_lm.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationLM[Source, Target](TransformationEstimation[Source, Target]):
+        TransformationEstimationLM() except +
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # public:
+        # TransformationEstimationLM (const TransformationEstimationLM &src)
+        # TransformationEstimationLM& operator = (const TransformationEstimationLM &src)
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from 
+        #   * \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Set the function we use to warp points. Defaults to rigid 6D warp.
+        #   * \param[in] warp_fcn a shared pointer to an object that warps points
+        #   */
+        # void setWarpFunction (const boost::shared_ptr<WarpPointRigid<PointSource, PointTarget> > &warp_fcn)
+        
+        # /** Base functor all the models that need non linear optimization must
+        #   * define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec)
+        #   * or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) dependening on the choosen _Scalar
+        #   */
+        # template<typename _Scalar, int NX=Eigen::Dynamic, int NY=Eigen::Dynamic>
+        # struct Functor
+        # {
+        #   typedef _Scalar Scalar;
+        #   enum 
+        #   {
+        #     InputsAtCompileTime = NX,
+        #     ValuesAtCompileTime = NY
+        #   };
+        #   typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> InputType;
+        #   typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,1> ValueType;
+        #   typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,InputsAtCompileTime> JacobianType;
+        # 
+        #   /** \brief Empty Construtor. */
+        #   Functor () : m_data_points_ (ValuesAtCompileTime) {}
+        #   /** \brief Constructor
+        #     * \param[in] m_data_points number of data points to evaluate.
+        #     */
+        #   Functor (int m_data_points) : m_data_points_ (m_data_points) {}
+        # 
+        #   /** \brief Destructor. */
+        #   virtual ~Functor () {}
+        # 
+        #   /** \brief Get the number of values. */ 
+        #   int
+        #   values () const { return (m_data_points_); }
+        # 
+        #   protected:
+        #     int m_data_points_;
+        # };
+        # 
+        # struct OptimizationFunctor : public Functor<double>
+        # {
+        #   using Functor<double>::values;
+        # /** Functor constructor
+        #     * \param[in] m_data_points the number of data points to evaluate
+        #     * \param[in,out] estimator pointer to the estimator object
+        #     */
+        #   OptimizationFunctor (int m_data_points, TransformationEstimationLM<PointSource, PointTarget> *estimator) : 
+        #     Functor<double> (m_data_points), estimator_ (estimator) {}
+        #   /** Copy constructor
+        #     * \param[in] the optimization functor to copy into this
+        #     */
+        #   inline OptimizationFunctor (const OptimizationFunctor &src) : 
+        #     Functor<double> (src.m_data_points_), estimator_ ()
+        #   {
+        #     *this = src;
+        #   }
+        #   /** Copy operator
+        #     * \param[in] the optimization functor to copy into this
+        #     */
+        #   inline OptimizationFunctor& 
+        #   operator = (const OptimizationFunctor &src) 
+        #   { 
+        #     Functor<double>::operator=(src);
+        #     estimator_ = src.estimator_; 
+        #     return (*this); 
+        #   }
+        #   /** \brief Destructor. */
+        #   virtual ~OptimizationFunctor () {}
+        #   /** Fill fvec from x. For the current state vector x fill the f values
+        #     * \param[in] x state vector
+        #     * \param[out] fvec f values vector
+        #     */
+        #   int 
+        #   operator () (const Eigen::VectorXd &x, Eigen::VectorXd &fvec) const;
+        # 
+        #   TransformationEstimationLM<PointSource, PointTarget> *estimator_;
+        # };
+        # struct OptimizationFunctorWithIndices : public Functor<double>
+        # {
+        #   using Functor<double>::values;
+        #   /** Functor constructor
+        #     * \param[in] m_data_points the number of data points to evaluate
+        #     * \param[in,out] estimator pointer to the estimator object
+        #     */
+        #   OptimizationFunctorWithIndices (int m_data_points, TransformationEstimationLM *estimator) :
+        #     Functor<double> (m_data_points), estimator_ (estimator) {}
+        #   /** Copy constructor
+        #     * \param[in] the optimization functor to copy into this
+        #     */
+        #   inline OptimizationFunctorWithIndices (const OptimizationFunctorWithIndices &src) : 
+        #     Functor<double> (src.m_data_points_), estimator_ ()
+        #   {
+        #     *this = src;
+        #   }
+        #   /** Copy operator
+        #     * \param[in] the optimization functor to copy into this
+        #     */
+        #   inline OptimizationFunctorWithIndices& 
+        #   operator = (const OptimizationFunctorWithIndices &src) 
+        #   { 
+        #     Functor<double>::operator=(src);
+        #     estimator_ = src.estimator_; 
+        #     return (*this); 
+        #   }
+        # 
+        #   /** \brief Destructor. */
+        #   virtual ~OptimizationFunctorWithIndices () {}
+        # 
+        #   /** Fill fvec from x. For the current state vector x fill the f values
+        #     * \param[in] x state vector
+        #     * \param[out] fvec f values vector
+        #     */
+        #   int 
+        #   operator () (const Eigen::VectorXd &x, Eigen::VectorXd &fvec) const;
+        #   TransformationEstimationLM<PointSource, PointTarget> *estimator_;
+        # };
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+
+###
+
+# transformation_estimation_point_to_plane.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationEstimationPointToPlane : public TransformationEstimationLM<PointSource, PointTarget>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlane[Source, Target](TransformationEstimationLM[Source, Target]):
+        TransformationEstimationPointToPlane ()
+        # public:
+        # ctypedef boost::shared_ptr<TransformationEstimationPointToPlane<PointSource, PointTarget> > Ptr;
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+###
+
+# transformation_estimation_point_to_plane_lls.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationEstimationPointToPlaneLLS : public TransformationEstimation<PointSource, PointTarget>
+
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane_lls.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlaneLLS[Source, Target](TransformationEstimation[Source, Target]):
+        TransformationEstimationPointToPlaneLLS ()
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix);
+
+###
+
+# transformation_estimation_svd.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationEstimationSVD : public TransformationEstimation<PointSource, PointTarget>
+cdef extern from "pcl/registration/transformation_estimation_svd.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationSVD[Source, Target](TransformationEstimation[Source, Target]):
+        TransformationEstimationSVD ()
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix);
+
+
+###
+
+# transformation_validation.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationValidation
+cdef extern from "pcl/registration/transformation_validation.h" namespace "pcl" nogil:
+    cdef cppclass TransformationValidation[Source, Target]:
+        TransformationValidation ()
+        # public:
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # ctypedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # /** \brief Validate the given transformation with respect to the input cloud data, and return a score.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \return the score or confidence measure for the given
+        #   * transformation_matrix with respect to the input data
+        #   */
+        # virtual double validateTransformation (
+        #    const cpp.PointCloudPtr_t &cloud_src,
+        #    const cpp.PointCloudPtr_t &cloud_tgt,
+        #    const Matrix4f &transformation_matrix) = 0;
+        # 
+        # ctypedef shared_ptr[TransformationValidation[PointSource, PointTarget] ] Ptr;
+        # ctypedef shared_ptr[const TransformationValidation[PointSource, PointTarget] ] ConstPtr;
+
+
+###
+
+# transformation_validation_euclidean.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationValidationEuclidean
+cdef extern from "pcl/registration/transformation_validation_euclidean.h" namespace "pcl" nogil:
+    cdef cppclass TransformationValidationEuclidean[Source, Target]:
+        TransformationValidationEuclidean ()
+        # public:
+        # ctypedef boost::shared_ptr<TransformationValidation<PointSource, PointTarget> > Ptr;
+        # ctypedef boost::shared_ptr<const TransformationValidation<PointSource, PointTarget> > ConstPtr;
+        # ctypedef typename pcl::KdTree<PointTarget> KdTree;
+        # ctypedef typename pcl::KdTree<PointTarget>::Ptr KdTreePtr;
+        # ctypedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # ctypedef typename TransformationValidation<PointSource, PointTarget>::PointCloudSourceConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename TransformationValidation<PointSource, PointTarget>::PointCloudTargetConstPtr PointCloudTargetConstPtr;
+        inline void setMaxRange (double max_range)
+        double validateTransformation (
+            const cpp.PointCloudPtr_t &cloud_src,
+            const cpp.PointCloudPtr_t &cloud_tgt,
+            const Matrix4f &transformation_matrix)
+
+
+###
+
+# transforms.h
+# common/transforms.h
+###
+
+# warp_point_rigid_3d.h
+# template <class PointSourceT, class PointTargetT>
+# class WarpPointRigid3D : public WarpPointRigid<PointSourceT, PointTargetT>
+cdef extern from "pcl/registration/warp_point_rigid_3d.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid3D[Source, Target](WarpPointRigid[Source, Target]):
+        WarpPointRigid3D ()
+        # public:
+        # virtual void setParam (const Eigen::VectorXf & p)
+
+
+###
+
+# warp_point_rigid_6d.h
+# template <class PointSourceT, class PointTargetT>
+# class WarpPointRigid6D : public WarpPointRigid<PointSourceT, PointTargetT>
+cdef extern from "pcl/registration/warp_point_rigid_6d.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid6D[Source, Target](WarpPointRigid[Source, Target]):
+        WarpPointRigid6D ()
+        # public:
+        # virtual void setParam (const Eigen::VectorXf & p)
+
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# bfgs.h
+# template<typename _Scalar, int NX=Eigen::Dynamic>
+# struct BFGSDummyFunctor
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+#     # cdef struct BFGSDummyFunctor[_Scalar, NX]:
+#         # enum { InputsAtCompileTime = NX };
+# 
+# cdef extern from "pcl/registration/bfgs.h" namespace "pcl":
+#     ctypedef enum "pcl::BFGSDummyFunctor":
+#             INPUTSATCOMPILETIME "pcl::BFGSDummyFunctor::InputsAtCompileTime"
+# 
+###
+
+# bfgs.h
+# namespace BFGSSpace {
+#   enum Status {
+#     NegativeGradientEpsilon = -3,
+#     NotStarted = -2,
+#     Running = -1,
+#     Success = 0,
+#     NoProgress = 1
+#   };
+# }
+cdef extern from "pcl/registration/bfgs.h" namespace "pcl":
+    cdef enum Status:
+        NegativeGradientEpsilon = -3
+        NotStarted = -2
+        Running = -1
+        Success = 0
+        NoProgress = 1
+
+# /** Base functor all the models that need non linear optimization must
+#   * define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec)
+#   * or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) dependening on the choosen _Scalar
+#   */
+# template<typename _Scalar, int NX=Eigen::Dynamic, int NY=Eigen::Dynamic>
+# struct Functor
+# {
+#   typedef _Scalar Scalar;
+#   enum 
+#   {
+#     InputsAtCompileTime = NX,
+#     ValuesAtCompileTime = NY
+#   };
+#   typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> InputType;
+#   typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,1> ValueType;
+#   typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,InputsAtCompileTime> JacobianType;
+# 
+#   /** \brief Empty Construtor. */
+#   Functor () : m_data_points_ (ValuesAtCompileTime) {}
+#   /** \brief Constructor
+#     * \param[in] m_data_points number of data points to evaluate.
+#     */
+#   Functor (int m_data_points) : m_data_points_ (m_data_points) {}
+# 
+#   /** \brief Destructor. */
+#   virtual ~Functor () {}
+# 
+#   /** \brief Get the number of values. */ 
+#   int
+#   values () const { return (m_data_points_); }
+# 
+#   protected:
+#     int m_data_points_;
+# };
+
+#####
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_registration_172.pxd b/pcl/pcl_registration_172.pxd
new file mode 100644
index 0000000..43a5887
--- /dev/null
+++ b/pcl/pcl_registration_172.pxd
@@ -0,0 +1,4476 @@
+# -*- coding: utf-8 -*-
+
+from libcpp cimport bool
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# main
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+# Cython - limits.pxd
+# from libcpp cimport numeric_limits
+
+# base
+from eigen cimport Matrix4f
+
+# registration.h
+# /** \brief @b Registration represents the base registration class for general purpose, ICP-like methods.
+#  * \author Radu B. Rusu, Michael Dixon
+#  * \ingroup registration
+#  */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class Registration : public PCLBase<PointSource>
+cdef extern from "pcl/registration/registration.h" namespace "pcl" nogil:
+    cdef cppclass Registration[Source, Target, float](cpp.PCLBase[Source]):
+        Registration()
+        # public:
+        # /** \brief Provide a pointer to the transformation estimation object.
+        #   * (e.g., SVD, point to plane etc.) 
+        #   * \param[in] te is the pointer to the corresponding transformation estimation object
+        #   * Code example:
+        #   * \code
+        #   * TransformationEstimationPointToPlaneLLS<PointXYZ, PointXYZ>::Ptr trans_lls (new TransformationEstimationPointToPlaneLLS<PointXYZ, PointXYZ>);
+        #   * icp.setTransformationEstimation (trans_lls);
+        #   * // or...
+        #   * TransformationEstimationSVD<PointXYZ, PointXYZ>::Ptr trans_svd (new TransformationEstimationSVD<PointXYZ, PointXYZ>);
+        #   * icp.setTransformationEstimation (trans_svd);
+        #   * \endcode
+        #   */
+        # void setTransformationEstimation (const TransformationEstimationPtr &te)
+        
+        # /** \brief Provide a pointer to the correspondence estimation object.
+        #   * (e.g., regular, reciprocal, normal shooting etc.) 
+        #   * \param[in] ce is the pointer to the corresponding correspondence estimation object
+        #   * Code example:
+        #   * \code
+        #   * CorrespondenceEstimation<PointXYZ, PointXYZ>::Ptr ce (new CorrespondenceEstimation<PointXYZ, PointXYZ>);
+        #   * ce->setInputSource (source);
+        #   * ce->setInputTarget (target);
+        #   * icp.setCorrespondenceEstimation (ce);
+        #   * // or...
+        #   * CorrespondenceEstimationNormalShooting<PointNormal, PointNormal, PointNormal>::Ptr cens (new CorrespondenceEstimationNormalShooting<PointNormal, PointNormal>);
+        #   * ce->setInputSource (source);
+        #   * ce->setInputTarget (target);
+        #   * ce->setSourceNormals (source);
+        #   * ce->setTargetNormals (target);
+        #   * icp.setCorrespondenceEstimation (cens);
+        #   * \endcode
+        #   */
+        # void setCorrespondenceEstimation (const CorrespondenceEstimationPtr &ce)
+        
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # PCL_DEPRECATED ("[pcl::registration::Registration::setInputCloud] setInputCloud is deprecated. Please use setInputSource instead.")
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud);
+        void setInputCloud(cpp.PointCloudPtr_t ptcloud) except +
+        
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # PCL_DEPRECATED ("[pcl::registration::Registration::getInputCloud] getInputCloud is deprecated. Please use getInputSource instead.")
+        # PointCloudSourceConstPtr const getInputCloud ();
+        
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        # virtual void setInputSource (const PointCloudSourceConstPtr &cloud)
+        void setInputSource(cpp.PointCloudPtr_t) except +
+        # void setInputSource(cpp.PointCloudPtr2_t pt2cloud) except +
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudSourceConstPtr const getInputSource ()
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # virtual inline void setInputTarget (const PointCloudTargetConstPtr &cloud); 
+        void setInputTarget(cpp.PointCloudPtr_t)
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudTargetConstPtr const getInputTarget ()
+        cpp.PointCloudPtr_t getInputTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the target cloud.
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputTarget. Only use if you are 
+        #   * confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute = false) 
+        # void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute) 
+        
+        # /** \brief Get a pointer to the search method used to find correspondences in the
+        #   * target cloud. */
+        # inline KdTreePtr getSearchMethodTarget () const
+        # KdTreePtr getSearchMethodTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the source cloud (usually used by reciprocal correspondence finding).
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputSource. Only use if you are 
+        #   * extremely confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodSource (const KdTreeReciprocalPtr &tree, bool force_no_recompute = false) 
+        # 
+        # /** \brief Get a pointer to the search method used to find correspondences in the
+        #   * source cloud. */
+        # inline KdTreeReciprocalPtr getSearchMethodSource () const
+        # 
+        # /** \brief Get the final transformation matrix estimated by the registration method. */
+        # inline Matrix4 getFinalTransformation ()
+        Matrix4f getFinalTransformation ()
+        
+        # /** \brief Get the last incremental transformation matrix estimated by the registration method. */
+        Matrix4f getLastIncrementalTransformation ()
+        
+        # Set the maximum number of iterations the internal optimization should run for.
+        # param nr_iterations the maximum number of iterations the internal optimization should run for
+        void setMaximumIterations (int nr_iterations) except +
+        
+        # /** \brief Get the maximum number of iterations the internal optimization should run for, as set by the user. */
+        int getMaximumIterations () 
+        
+        # /** \brief Set the number of iterations RANSAC should run for.
+        #   * \param[in] ransac_iterations is the number of iterations RANSAC should run for
+        #   */
+        void setRANSACIterations (int ransac_iterations)
+        
+        # /** \brief Get the number of iterations RANSAC should run for, as set by the user. */
+        # inline double getRANSACIterations ()
+        double getRANSACIterations ()
+        
+        # /** \brief Set the inlier distance threshold for the internal RANSAC outlier rejection loop.
+        #   * The method considers a point to be an inlier, if the distance between the target data index and the transformed 
+        #   * source index is smaller than the given inlier distance threshold. 
+        #   * The value is set by default to 0.05m.
+        #   * \param[in] inlier_threshold the inlier distance threshold for the internal RANSAC outlier rejection loop
+        #   */
+        # inline void setRANSACOutlierRejectionThreshold (double inlier_threshold) { inlier_threshold_ = inlier_threshold; }
+        void setRANSACOutlierRejectionThreshold (double inlier_threshold)
+        
+        # /** \brief Get the inlier distance threshold for the internal outlier rejection loop as set by the user. */
+        # inline double getRANSACOutlierRejectionThreshold ()
+        double getRANSACOutlierRejectionThreshold ()
+        
+        # /** \brief Set the maximum distance threshold between two correspondent points in source <-> target. If the 
+        #   * distance is larger than this threshold, the points will be ignored in the alignment process.
+        #   * \param[in] distance_threshold the maximum distance threshold between a point and its nearest neighbor 
+        #   * correspondent in order to be considered in the alignment process
+        #   */
+        # inline void setMaxCorrespondenceDistance (double distance_threshold)
+        void setMaxCorrespondenceDistance (double distance_threshold)
+        
+        # /** \brief Get the maximum distance threshold between two correspondent points in source <-> target. If the 
+        #   * distance is larger than this threshold, the points will be ignored in the alignment process.
+        #   */
+        # inline double getMaxCorrespondenceDistance ()
+        double getMaxCorrespondenceDistance ()
+        
+        # /** \brief Set the transformation epsilon (maximum allowable difference between two consecutive 
+        #   * transformations) in order for an optimization to be considered as having converged to the final 
+        #   * solution.
+        #   * \param[in] epsilon the transformation epsilon in order for an optimization to be considered as having 
+        #   * converged to the final solution.
+        #   */
+        # inline void setTransformationEpsilon (double epsilon)
+        void setTransformationEpsilon (double epsilon)
+        
+        # /** \brief Get the transformation epsilon (maximum allowable difference between two consecutive 
+        #   * transformations) as set by the user.
+        #   */
+        # inline double getTransformationEpsilon ()
+        double getTransformationEpsilon ()
+        
+        # /** \brief Set the maximum allowed Euclidean error between two consecutive steps in the ICP loop, before 
+        #   * the algorithm is considered to have converged. 
+        #   * The error is estimated as the sum of the differences between correspondences in an Euclidean sense, 
+        #   * divided by the number of correspondences.
+        #   * \param[in] epsilon the maximum allowed distance error before the algorithm will be considered to have
+        #   * converged
+        #   */
+        # inline void setEuclideanFitnessEpsilon (double epsilon)
+        void setEuclideanFitnessEpsilon (double epsilon)
+        
+        # /** \brief Get the maximum allowed distance error before the algorithm will be considered to have converged,
+        #   * as set by the user. See \ref setEuclideanFitnessEpsilon
+        #   */
+        # inline double getEuclideanFitnessEpsilon ()
+        double getEuclideanFitnessEpsilon ()
+        
+        # 
+        # /** \brief Provide a boost shared pointer to the PointRepresentation to be used when comparing points
+        #   * \param[in] point_representation the PointRepresentation to be used by the k-D tree
+        #   */
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # 
+        # /** \brief Register the user callback function which will be called from registration thread
+        #  * in order to update point cloud obtained after each iteration
+        #  * \param[in] visualizerCallback reference of the user callback function
+        #  */
+        # template<typename FunctionSignature> inline bool registerVisualizationCallback (boost::function<FunctionSignature> &visualizerCallback)
+        
+        # /** \brief Obtain the Euclidean fitness score (e.g., sum of squared distances from the source to the target)
+        #   * \param[in] max_range maximum allowable distance between a point and its correspondence in the target 
+        #   * (default: double::max)
+        #   */
+        # double getFitnessScore (double max_range = numeric_limits[double]::max ());
+        # double getFitnessScore (double max_range)
+        double getFitnessScore()
+        
+        # /** \brief Obtain the Euclidean fitness score (e.g., sum of squared distances from the source to the target)
+        #   * from two sets of correspondence distances (distances between source and target points)
+        #   * \param[in] distances_a the first set of distances between correspondences
+        #   * \param[in] distances_b the second set of distances between correspondences
+        #   */
+        # inline double getFitnessScore (const std::vector<float> &distances_a, const std::vector<float> &distances_b);
+        double getFitnessScore (const vector[float] &distances_a, const vector[float] &distances_b)
+        
+        # /** \brief Return the state of convergence after the last align run */
+        # inline bool hasConverged ()
+        bool hasConverged ()
+        
+        # /** \brief Call the registration algorithm which estimates the transformation and returns the transformed source 
+        #   * (input) as \a output.
+        #   * \param[out] output the resultant input transfomed point cloud dataset
+        #   */
+        # inline void align (PointCloudSource &output);
+        void align(cpp.PointCloud[Source] &) except +
+        
+        # /** \brief Call the registration algorithm which estimates the transformation and returns the transformed source 
+        #   * (input) as \a output.
+        #   * \param[out] output the resultant input transfomed point cloud dataset
+        #   * \param[in] guess the initial gross estimation of the transformation
+        #   */
+        # inline void align (PointCloudSource &output, const Matrix4f& guess);
+        void align (cpp.PointCloud[Source] &output, const Matrix4f& guess)
+        
+        # /** \brief Abstract class get name method. */
+        # inline const std::string& getClassName () const
+        string& getClassName ()
+        
+        # /** \brief Internal computation initalization. */
+        # bool initCompute ();
+        bool initCompute ()
+        
+        # /** \brief Internal computation when reciprocal lookup is needed */
+        # bool initComputeReciprocal ();
+        bool initComputeReciprocal ()
+        
+        # /** \brief Add a new correspondence rejector to the list
+        #   * \param[in] rejector the new correspondence rejector to concatenate
+        # inline void addCorrespondenceRejector (const CorrespondenceRejectorPtr &rejector)
+        # void addCorrespondenceRejector (const CorrespondenceRejectorPtr &rejector)
+        
+        # /** \brief Get the list of correspondence rejectors. */
+        # inline std::vector<CorrespondenceRejectorPtr> getCorrespondenceRejectors ()
+        # vector[CorrespondenceRejectorPtr] getCorrespondenceRejectors ()
+        
+        # /** \brief Remove the i-th correspondence rejector in the list
+        #   * \param[in] i the position of the correspondence rejector in the list to remove
+        # inline bool removeCorrespondenceRejector (unsigned int i)
+        bool removeCorrespondenceRejector (unsigned int i)
+        
+        # /** \brief Clear the list of correspondence rejectors. */
+        # inline void clearCorrespondenceRejectors ()
+        void clearCorrespondenceRejectors ()
+
+
+###
+
+# warp_point_rigid.h
+# template <typename PointSourceT, typename PointTargetT, typename Scalar = float>
+# class WarpPointRigid
+cdef extern from "pcl/registration/warp_point_rigid.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid[Source, Target, float]:
+        WarpPointRigid (int nr_dim)
+        # public:
+        # virtual void setParam (const Eigen::VectorXf& p) = 0;
+        # void warpPoint (const PointSourceT& pnt_in, PointSourceT& pnt_out) const
+        # int getDimension () const {return nr_dim_;}
+        # const Eigen::Matrix4f& getTransform () const { return transform_matrix_; }
+
+
+###
+
+# correspondence_rejection.h
+# class CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejector:
+        CorrespondenceRejector()
+        # /** \brief Provide a pointer to the vector of the input correspondences.
+        #   * \param[in] correspondences the const boost shared pointer to a correspondence vector
+        #   */
+        # virtual inline void setInputCorrespondences (const CorrespondencesConstPtr &correspondences) 
+        
+        # /** \brief Get a pointer to the vector of the input correspondences.
+        #   * \return correspondences the const boost shared pointer to a correspondence vector
+        #   */
+        # inline CorrespondencesConstPtr getInputCorrespondences ()
+        # CorrespondencesConstPtr getInputCorrespondences ()
+        
+        # /** \brief Run correspondence rejection
+        #   * \param[out] correspondences Vector of correspondences that have not been rejected.
+        #   */
+        # inline void getCorrespondences (pcl::Correspondences &correspondences)
+        # void getCorrespondences (pcl::Correspondences &correspondences)
+        
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * Pure virtual. Compared to \a getCorrespondences this function is
+        #   * stateless, i.e., input correspondences do not need to be provided beforehand,
+        #   * but are directly provided in the function call.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # virtual inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences) = 0;
+        
+        # /** \brief Determine the indices of query points of
+        #   * correspondences that have been rejected, i.e., the difference
+        #   * between the input correspondences (set via \a setInputCorrespondences)
+        #   * and the given correspondence vector.
+        #   * \param[in] correspondences Vector of correspondences after rejection
+        #   * \param[out] indices Vector of query point indices of those correspondences
+        #   * that have been rejected.
+        #   */
+        # inline void getRejectedQueryIndices (const pcl::Correspondences &correspondences, std::vector<int>& indices)
+        # void getRejectedQueryIndices (const pcl::Correspondences &correspondences, vector[int]& indices)
+        
+        # /** @b DataContainerInterface provides a generic interface for computing correspondence scores between correspondent
+        # * points in the input and target clouds
+        # * \ingroup registration
+        # */
+        # class DataContainerInterface
+        # {
+        #   public:
+        #       virtual ~DataContainerInterface () {}
+        #       virtual double getCorrespondenceScore (int index) = 0;
+        #       virtual double getCorrespondenceScore (const pcl::Correspondence &) = 0;
+        # };
+        
+        # /** @b DataContainer is a container for the input and target point clouds and implements the interface 
+        #  * to compute correspondence scores between correspondent points in the input and target clouds
+        #  * \ingroup registration
+        #  */
+        # template <typename PointT, typename NormalT=pcl::PointNormal>
+        # class DataContainer : public DataContainerInterface
+        # {
+        #   typedef typename pcl::PointCloud<PointT>::ConstPtr PointCloudConstPtr;
+        #   typedef typename pcl::KdTree<PointT>::Ptr KdTreePtr;
+        #   typedef typename pcl::PointCloud<NormalT>::ConstPtr NormalsPtr;
+        #   public:
+        #   /** \brief Empty constructor. */
+        #   DataContainer ()
+        #   
+        #   /** \brief Provide a source point cloud dataset (must contain XYZ
+        #    * data!), used to compute the correspondence distance.  
+        #    * \param[in] cloud a cloud containing XYZ data
+        #    */
+        #   inline void setInputCloud (const PointCloudConstPtr &cloud)
+        #   
+        #   /** \brief Provide a target point cloud dataset (must contain XYZ
+        #    * data!), used to compute the correspondence distance.  
+        #    * \param[in] target a cloud containing XYZ data
+        #    */
+        #   inline void setInputTarget (const PointCloudConstPtr &target)
+        #   
+        #   /** \brief Set the normals computed on the input point cloud
+        #    * \param[in] normals the normals computed for the input cloud
+        #    */
+        #   inline void setInputNormals (const NormalsPtr &normals)
+        # 
+        #   /** \brief Set the normals computed on the target point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        #   */
+        #   inline void setTargetNormals (const NormalsPtr &normals)
+        # 
+        #   /** \brief Get the normals computed on the input point cloud */
+        #   inline NormalsPtr getInputNormals ()
+        # 
+        #   /** \brief Get the normals computed on the target point cloud */
+        #   inline NormalsPtr getTargetNormals ()
+        # 
+        #   /** \brief Get the correspondence score for a point in the input cloud
+        #    *  \param[index] index of the point in the input cloud
+        #    */
+        #   inline double getCorrespondenceScore (int index)
+        # 
+        #   /** \brief Get the correspondence score for a given pair of correspondent points
+        #    *  \param[corr] Correspondent points
+        #    */
+        #   inline double getCorrespondenceScore (const pcl::Correspondence &corr)
+        # 
+        #   /** \brief Get the correspondence score for a given pair of correspondent points based on 
+        #    * the angle betweeen the normals. The normmals for the in put and target clouds must be 
+        #    * set before using this function
+        #    * \param[in] corr Correspondent points
+        #    */
+        #   double getCorrespondenceScoreFromNormals (const pcl::Correspondence &corr)
+        # };
+
+
+###
+
+# correspondence_estimation.h
+# /** \brief Abstract @b CorrespondenceEstimationBase class. 
+#   * All correspondence estimation methods should inherit from this.
+#   * \author Radu B. Rusu
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class CorrespondenceEstimationBase: public PCLBase<PointSource>
+cdef extern from "pcl/registration/correspondence_estimation.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationBase[Source, Target, float](cpp.PCLBase[Source]):
+        CorrespondenceEstimationBase()
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > ConstPtr;
+        # // using PCLBase<PointSource>::initCompute;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using PCLBase<PointSource>::setIndices;
+        # typedef pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::search::KdTree<PointSource> KdTreeReciprocal;
+        # typedef typename KdTree::Ptr KdTreeReciprocalPtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # 
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # PCL_DEPRECATED ("[pcl::registration::CorrespondenceEstimationBase::setInputCloud] setInputCloud is deprecated. Please use setInputSource instead.")
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud);
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud)
+        
+        # 
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # PCL_DEPRECATED ("[pcl::registration::CorrespondenceEstimationBase::getInputCloud] getInputCloud is deprecated. Please use getInputSource instead.")
+        # PointCloudSourceConstPtr const getInputCloud ();
+        # PointCloudSourceConstPtr const getInputCloud ()
+        
+        # 
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # inline void setInputSource (const PointCloudSourceConstPtr &cloud)
+        # void setInputSource (const PointCloudSourceConstPtr &cloud)
+        
+        # 
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudSourceConstPtr const getInputSource () 
+        # PointCloudSourceConstPtr const getInputSource () 
+        
+        # /** \brief Provide a pointer to the input target 
+        #   * (e.g., the point cloud that we want to align the input source to)
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &cloud);
+        # void setInputTarget (const PointCloudTargetConstPtr &cloud)
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudTargetConstPtr const getInputTarget () { return (target_ ); }
+        # PointCloudTargetConstPtr const getInputTarget ()
+        
+        # /** \brief See if this rejector requires source normals */
+        # virtual bool requiresSourceNormals () const
+        # 
+        # /** \brief Abstract method for setting the source normals */
+        # virtual void setSourceNormals (pcl::PCLPointCloud2::ConstPtr /*cloud2*/)
+        # 
+        # /** \brief See if this rejector requires target normals */
+        # virtual bool requiresTargetNormals () const
+        # 
+        # /** \brief Abstract method for setting the target normals */
+        # virtual void setTargetNormals (pcl::PCLPointCloud2::ConstPtr /*cloud2*/)
+        # 
+        # /** \brief Provide a pointer to the vector of indices that represent the 
+        #   * input source point cloud.
+        #   * \param[in] indices a pointer to the vector of indices 
+        #   */
+        # inline void setIndicesSource (const IndicesPtr &indices)
+        # void setIndicesSource (const IndicesPtr &indices)
+        
+        # /** \brief Get a pointer to the vector of indices used for the source dataset. */
+        # inline IndicesPtr const getIndicesSource () { return (indices_); }
+        # IndicesPtr const getIndicesSource ()
+        
+        # 
+        # /** \brief Provide a pointer to the vector of indices that represent the input target point cloud.
+        #   * \param[in] indices a pointer to the vector of indices 
+        #   */
+        # inline void setIndicesTarget (const IndicesPtr &indices)
+        # void setIndicesTarget (const IndicesPtr &indices)
+        
+        # /** \brief Get a pointer to the vector of indices used for the target dataset. */
+        # inline IndicesPtr const getIndicesTarget () { return (target_indices_); }
+        # IndicesPtr const getIndicesTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the target cloud.
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputTarget. Only use if you are 
+        #   * confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute = false) 
+        # void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute = false) 
+        
+        # /** \brief Get a pointer to the search method used to find correspondences in the target cloud. */
+        # inline KdTreePtr getSearchMethodTarget () const
+        # KdTreePtr getSearchMethodTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the source cloud (usually used by reciprocal correspondence finding).
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputSource. Only use if you are 
+        #   * extremely confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodSource (const KdTreeReciprocalPtr &tree, bool force_no_recompute = false) 
+        # void setSearchMethodSource (const KdTreeReciprocalPtr &tree, bool force_no_recompute = false)
+        
+        # /** \brief Get a pointer to the search method used to find correspondences in the source cloud. */
+        # inline KdTreeReciprocalPtr getSearchMethodSource () const
+        # KdTreeReciprocalPtr getSearchMethodSource ()
+        
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ()) = 0;
+        # 
+        # /** \brief Determine the reciprocal correspondences between input and target cloud.
+        #   * A correspondence is considered reciprocal if both Src_i has Tgt_i as a 
+        #   * correspondence, and Tgt_i has Src_i as one.
+        #   * \param[out] correspondences the found correspondences (index of query and target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineReciprocalCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ()) = 0;
+        # 
+        # /** \brief Provide a boost shared pointer to the PointRepresentation to be used when searching for nearest neighbors.
+        #   * \param[in] point_representation the PointRepresentation to be used by the 
+        #   * k-D tree for nearest neighbor search
+        #   */
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const = 0;
+
+
+###
+
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class CorrespondenceEstimation : public CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/correspondence_estimation.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimation[Source, Target, float](CorrespondenceEstimationBase[Source, Target, float]):
+        CorrespondenceEstimation()
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceEstimation<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceEstimation<PointSource, PointTarget, Scalar> > ConstPtr;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::point_representation_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_transformed_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::tree_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::tree_reciprocal_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::corr_name_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::getClassName;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initCompute;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initComputeReciprocal;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_fields_;
+        # using PCLBase<PointSource>::deinitCompute;
+        # 
+        # typedef pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::search::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~CorrespondenceEstimation () {}
+        # 
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # 
+        # /** \brief Determine the reciprocal correspondences between input and target cloud.
+        #   * A correspondence is considered reciprocal if both Src_i has Tgt_i as a 
+        #   * correspondence, and Tgt_i has Src_i as one.
+        #   *
+        #   * \param[out] correspondences the found correspondences (index of query and target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineReciprocalCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # 
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const
+
+
+###
+
+### Inheritance ###
+
+# icp.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class IterativeClosestPoint : public Registration<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/icp.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPoint[Source, Target, Scalar](Registration[Source, Target, Scalar]):
+        IterativeClosestPoint() except +
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+        
+        # /** \brief Returns a pointer to the DefaultConvergenceCriteria used by the IterativeClosestPoint class.
+        #   * This allows to check the convergence state after the align() method as well as to configure
+        #   * DefaultConvergenceCriteria's parameters not available through the ICP API before the align()
+        #   * method is called. Please note that the align method sets max_iterations_,
+        #   * euclidean_fitness_epsilon_ and transformation_epsilon_ and therefore overrides the default / set
+        #   * values of the DefaultConvergenceCriteria instance.
+        #   * \return Pointer to the IterativeClosestPoint's DefaultConvergenceCriteria.
+        #   */
+        # inline typename pcl::registration::DefaultConvergenceCriteria<Scalar>::Ptr getConvergeCriteria ()
+        # 
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # virtual void setInputSource (const PointCloudSourceConstPtr &cloud)
+        # 
+        # /** \brief Provide a pointer to the input target 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # virtual void setInputTarget (const PointCloudTargetConstPtr &cloud)
+        # 
+        # /** \brief Set whether to use reciprocal correspondence or not
+        #   * \param[in] use_reciprocal_correspondence whether to use reciprocal correspondence or not
+        #   */
+        # inline void setUseReciprocalCorrespondences (bool use_reciprocal_correspondence)
+        # 
+        # /** \brief Obtain whether reciprocal correspondence are used or not */
+        # inline bool getUseReciprocalCorrespondences () const
+
+
+ctypedef IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPoint_t
+ctypedef IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPoint_PointXYZI_t
+ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPoint_PointXYZRGB_t
+ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPoint_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointPtr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPoint_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPoint_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPoint_PointXYZRGBA_Ptr_t
+###
+
+# /** \brief @b IterativeClosestPointWithNormals is a special case of
+#  * IterativeClosestPoint, that uses a transformation estimated based on
+#  * Point to Plane distances by default.
+#  *
+#  * \author Radu B. Rusu
+#  * \ingroup registration
+#  */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class IterativeClosestPointWithNormals : public IterativeClosestPoint<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/icp.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPointWithNormals[Source, Target, Scalar](IterativeClosestPoint[Source, Target, Scalar]):
+        IterativeClosestPointWithNormals() except +
+        # public:
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudSource PointCloudSource;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudTarget PointCloudTarget;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::reg_name_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_estimation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondence_rejectors_;
+        # typedef boost::shared_ptr<IterativeClosestPoint<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const IterativeClosestPoint<PointSource, PointTarget, Scalar> > ConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # IterativeClosestPointWithNormals () 
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~IterativeClosestPointWithNormals () {}
+
+
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointWithNormals_t
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointWithNormals_PointXYZI_t
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointWithNormals_PointXYZRGB_t
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointWithNormals_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointWithNormalsPtr_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointWithNormals_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointWithNormals_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointWithNormals_PointXYZRGBA_Ptr_t
+###
+
+# gicp.h
+# Version 1.7.2
+# namespace pcl
+# /** \brief GeneralizedIterativeClosestPoint is an ICP variant that implements the 
+#   * generalized iterative closest point algorithm as described by Alex Segal et al. in 
+#   * http://www.stanford.edu/~avsegal/resources/papers/Generalized_ICP.pdf
+#   * The approach is based on using anistropic cost functions to optimize the alignment 
+#   * after closest point assignments have been made.
+#   * The original code uses GSL and ANN while in ours we use an eigen mapped BFGS and 
+#   * FLANN.
+#   * \author Nizar Sallem
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget>
+# class GeneralizedIterativeClosestPoint : public IterativeClosestPoint<PointSource, PointTarget>
+cdef extern from "pcl/registration/gicp.h" namespace "pcl" nogil:
+    cdef cppclass GeneralizedIterativeClosestPoint[Source, Target](IterativeClosestPoint[Source, Target, float]):
+        GeneralizedIterativeClosestPoint() except +
+        # using IterativeClosestPoint<PointSource, PointTarget>::reg_name_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::getClassName;
+        # using IterativeClosestPoint<PointSource, PointTarget>::indices_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::target_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::input_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::tree_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::nr_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::max_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::previous_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::final_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::transformation_epsilon_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::converged_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::corr_dist_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::inlier_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::min_number_correspondences_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::update_visualizer_;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # typedef typename pcl::KdTree<PointSource> InputKdTree;
+        # typedef typename pcl::KdTree<PointSource>::Ptr InputKdTreePtr;
+        # typedef Eigen::Matrix<double, 6, 1> Vector6d;
+        # public:
+        # /** \brief Provide a pointer to the input dataset
+        #  * \param cloud the const boost shared pointer to a PointCloud message
+        #  */
+        # void setInputCloud (cpp.PointCloudPtr_t ptcloud)
+        # void setInputCloud (cpp.PointCloudPtr_t ptcloud)
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #  * \param[in] target the input point cloud target
+        #  */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &target)
+        # void setInputTarget (const PointCloudTargetConstPtr &target)
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using an iterative
+        #  * non-linear Levenberg-Marquardt approach.
+        #  * \param[in] cloud_src the source point cloud dataset
+        #  * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #  * \param[in] cloud_tgt the target point cloud dataset
+        #  * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #  * \param[out] transformation_matrix the resultant transformation matrix
+        #  */
+        # void estimateRigidTransformationBFGS (
+        #                                const PointCloudSource &cloud_src,
+        #                                const std::vector<int> &indices_src,
+        #                                const PointCloudTarget &cloud_tgt,
+        #                                const std::vector<int> &indices_tgt,
+        #                                Eigen::Matrix4f &transformation_matrix);
+        # void estimateRigidTransformationBFGS (
+        #                                 const PointCloudSource &cloud_src,
+        #                                 const std::vector<int> &indices_src,
+        #                                 const PointCloudTarget &cloud_tgt,
+        #                                 const vector[int] &indices_tgt, 
+        #                                 Matrix4f &transformation_matrix);
+        
+        # /** \brief \return Mahalanobis distance matrix for the given point index */
+        # inline const Eigen::Matrix3d& mahalanobis(size_t index) const
+        # const Matrix3d& mahalanobis(size_t index)
+        
+        # /** \brief Computes rotation matrix derivative.
+        #  * rotation matrix is obtainded from rotation angles x[3], x[4] and x[5]
+        #  * \return d/d_rx, d/d_ry and d/d_rz respectively in g[3], g[4] and g[5]
+        #  * param x array representing 3D transformation
+        #  * param R rotation matrix
+        #  * param g gradient vector
+        #  */
+        # void computeRDerivative(const Vector6d &x, const Eigen::Matrix3d &R, Vector6d &g) const;
+        # void computeRDerivative(const Vector6d &x, const Matrix3d &R, Vector6d &g)
+        
+        # /** \brief Set the rotation epsilon (maximum allowable difference between two 
+        #  * consecutive rotations) in order for an optimization to be considered as having 
+        #  * converged to the final solution.
+        #  * \param epsilon the rotation epsilon
+        #  */
+        # inline void setRotationEpsilon (double epsilon)
+        void setRotationEpsilon (double epsilon)
+        
+        # /** \brief Get the rotation epsilon (maximum allowable difference between two 
+        #  * consecutive rotations) as set by the user.
+        #  */
+        # inline double getRotationEpsilon ()
+        double getRotationEpsilon ()
+        
+        # /** \brief Set the number of neighbors used when selecting a point neighbourhood
+        #   * to compute covariances. 
+        #   * A higher value will bring more accurate covariance matrix but will make 
+        #   * covariances computation slower.
+        #   * \param k the number of neighbors to use when computing covariances
+        #   */
+        void setCorrespondenceRandomness (int k)
+        
+        # /** \brief Get the number of neighbors used when computing covariances as set by the user 
+        #   */
+        int getCorrespondenceRandomness ()
+        
+        # /** set maximum number of iterations at the optimization step
+        #  * \param[in] max maximum number of iterations for the optimizer
+        #  */
+        void setMaximumOptimizerIterations (int max)
+        
+        # ///\return maximum number of iterations at the optimization step
+        int getMaximumOptimizerIterations ()
+
+
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] GeneralizedIterativeClosestPoint_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] GeneralizedIterativeClosestPoint_PointXYZI_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] GeneralizedIterativeClosestPoint_PointXYZRGBA_Ptr_t
+###
+
+# icp_nl.h
+# /** \brief @b IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization 
+#     * backend. The resultant transformation is optimized as a quaternion.
+#     * The algorithm has several termination criteria:
+#     * <ol>
+#     * <li>Number of iterations has reached the maximum user imposed number of iterations 
+#     *     (via \ref setMaximumIterations)</li>
+#     * <li>The epsilon (difference) between the previous transformation and the current estimated transformation is 
+#     *     smaller than an user imposed value (via \ref setTransformationEpsilon)</li>
+#     * <li>The sum of Euclidean squared errors is smaller than a user defined threshold 
+#     *     (via \ref setEuclideanFitnessEpsilon)</li>
+#     * </ol>
+#     * \author Radu B. Rusu, Michael Dixon
+#     * \ingroup registration
+#     */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class IterativeClosestPointNonLinear : public IterativeClosestPoint<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/icp_nl.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPointNonLinear[Source, Target, Scalar](IterativeClosestPoint[Source, Target, Scalar]):
+        IterativeClosestPointNonLinear() except +
+
+
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointNonLinear_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointNonLinear_PointXYZI_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointNonLinear_PointXYZRGB_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointNonLinear_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointNonLinearPtr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointNonLinear_PointXYZRGBA_Ptr_t
+###
+
+# bfgs.h
+# template< typename _Scalar >
+# class PolynomialSolver<_Scalar,2> : public PolynomialSolverBase<_Scalar,2>
+# cdef extern from "pcl/registration/bfgs.h" namespace "Eigen" nogil:
+#     cdef cppclass PolynomialSolver[_Scalar, 2](PolynomialSolverBase[_Scalar, 2]):
+#         PolynomialSolver (int nr_dim)
+        # public:
+        # typedef PolynomialSolverBase<_Scalar,2>    PS_Base;
+        # EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES( PS_Base )
+        # public:
+        # template< typename OtherPolynomial >
+        # inline PolynomialSolver( const OtherPolynomial& poly, bool& hasRealRoot )
+        # /** Computes the complex roots of a new polynomial. */
+        # template< typename OtherPolynomial >
+        # void compute( const OtherPolynomial& poly, bool& hasRealRoot)
+        # template< typename OtherPolynomial > 
+        # void compute( const OtherPolynomial& poly)
+
+###
+
+# bfgs.h
+# template<typename _Scalar, int NX=Eigen::Dynamic>
+# struct BFGSDummyFunctor
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+#   cdef struct BFGSDummyFunctor[_Scalar, NX]:
+#       BFGSDummyFunctor ()
+#       BFGSDummyFunctor(int inputs)
+#       typedef _Scalar Scalar;
+#       enum { InputsAtCompileTime = NX };
+#       typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> VectorType;
+#       const int m_inputs;
+#       int inputs() const { return m_inputs; }
+#       virtual double operator() (const VectorType &x) = 0;
+#       virtual void  df(const VectorType &x, VectorType &df) = 0;
+#       virtual void fdf(const VectorType &x, Scalar &f, VectorType &df) = 0;
+# 
+###
+
+# bfgs.h
+# namespace BFGSSpace {
+#   enum Status {
+#     NegativeGradientEpsilon = -3,
+#     NotStarted = -2,
+#     Running = -1,
+#     Success = 0,
+#     NoProgress = 1
+#   };
+# }
+# 
+###
+
+# bfgs.h
+# /**
+#  * BFGS stands for Broydenletcheroldfarbhanno (BFGS) method for solving 
+#  * unconstrained nonlinear optimization problems. 
+#  * For further details please visit: http://en.wikipedia.org/wiki/BFGS_method
+#  * The method provided here is almost similar to the one provided by GSL.
+#  * It reproduces Fletcher's original algorithm in Practical Methods of Optimization
+#  * algorithms : 2.6.2 and 2.6.4 and uses the same politics in GSL with cubic 
+#  * interpolation whenever it is possible else falls to quadratic interpolation for 
+#  * alpha parameter.
+#  */
+# template<typename FunctorType>
+# class BFGS
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+#     cdef cppclass BFGS[FunctorType]:
+#         # BFGS (FunctorType &_functor) 
+# public:
+#   typedef typename FunctorType::Scalar Scalar;
+#   typedef typename FunctorType::VectorType FVectorType;
+#   typedef Eigen::DenseIndex Index;
+# 
+#   struct Parameters {
+#     Parameters()
+#     : max_iters(400)
+#       , bracket_iters(100)
+#       , section_iters(100)
+#       , rho(0.01)
+#       , sigma(0.01)
+#       , tau1(9)
+#       , tau2(0.05)
+#       , tau3(0.5)
+#       , step_size(1)
+#       , order(3) {}
+#     Index max_iters;   // maximum number of function evaluation
+#     Index bracket_iters;
+#     Index section_iters;
+#     Scalar rho;
+#     Scalar sigma;
+#     Scalar tau1;
+#     Scalar tau2;
+#     Scalar tau3;
+#     Scalar step_size;
+#     Index order;
+# 
+#   BFGSSpace::Status minimize(FVectorType &x);
+#   BFGSSpace::Status minimizeInit(FVectorType &x);
+#   BFGSSpace::Status minimizeOneStep(FVectorType &x);
+#   BFGSSpace::Status testGradient(Scalar epsilon);
+#   void resetParameters(void) { parameters = Parameters(); }
+#   
+#   Parameters parameters;
+#   Scalar f;
+#   FVectorType gradient;
+# 
+#
+# template<typename FunctorType> void
+# BFGS<FunctorType>::checkExtremum(const Eigen::Matrix<Scalar, 4, 1>& coefficients, Scalar x, Scalar& xmin, Scalar& fmin)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::moveTo(Scalar alpha)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::slope()
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::applyF(Scalar alpha)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::applyDF(Scalar alpha)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::applyFDF(Scalar alpha, Scalar& f, Scalar& df)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::updatePosition (Scalar alpha, FVectorType &x, Scalar &f, FVectorType &g)
+#
+# template<typename FunctorType> void
+# BFGS<FunctorType>::changeDirection ()
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimize(FVectorType  &x)
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimizeInit(FVectorType  &x)
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimizeOneStep(FVectorType  &x)
+# 
+# template<typename FunctorType> typename BFGSSpace::Status 
+# BFGS<FunctorType>::testGradient(Scalar epsilon)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar 
+# BFGS<FunctorType>::interpolate (Scalar a, Scalar fa, Scalar fpa,
+#                                 Scalar b, Scalar fb, Scalar fpb, 
+#                                 Scalar xmin, Scalar xmax,
+#                                 int order)
+# 
+# template<typename FunctorType> BFGSSpace::Status 
+# BFGS<FunctorType>::lineSearch(Scalar rho, Scalar sigma, 
+#                               Scalar tau1, Scalar tau2, Scalar tau3,
+#                               int order, Scalar alpha1, Scalar &alpha_new)
+###
+
+# correspondence_estimation_backprojection.h
+# namespace pcl
+# namespace registration
+# /** \brief @b CorrespondenceEstimationBackprojection computes
+#   * correspondences as points in the target cloud which have minimum
+#   * \author Suat Gedikli
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename NormalT, typename Scalar = float>
+# class CorrespondenceEstimationBackProjection : public CorrespondenceEstimationBase <PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/correspondence_estimation.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationBackProjection[Source, Target, Normal](CorrespondenceEstimationBase[Source, Target, float]):
+        CorrespondenceEstimationBackProjection ()
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceEstimationBackProjection<PointSource, PointTarget, NormalT, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceEstimationBackProjection<PointSource, PointTarget, NormalT, Scalar> > ConstPtr;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initCompute;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initComputeReciprocal;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_transformed_;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::getClassName;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::point_representation_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_indices_;
+        # typedef typename pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::search::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef pcl::PointCloud<NormalT> PointCloudNormals;
+        # typedef typename PointCloudNormals::Ptr NormalsPtr;
+        # typedef typename PointCloudNormals::ConstPtr NormalsConstPtr;
+        # /** \brief Set the normals computed on the source point cloud
+        #   * \param[in] normals the normals computed for the source cloud
+        #   */
+        # inline void setSourceNormals (const NormalsConstPtr &normals) { source_normals_ = normals; }
+        # void setSourceNormals (const NormalsConstPtr &normals)
+        
+        # /** \brief Get the normals of the source point cloud
+        #   */
+        # inline NormalsConstPtr getSourceNormals () const { return (source_normals_); }
+        # NormalsConstPtr getSourceNormals ()
+        
+        # /** \brief Set the normals computed on the target point cloud
+        #   * \param[in] normals the normals computed for the target cloud
+        #   */
+        # inline void setTargetNormals (const NormalsConstPtr &normals) { target_normals_ = normals; }
+        # void setTargetNormals (const NormalsConstPtr &normals)
+        
+        # /** \brief Get the normals of the target point cloud
+        #   */
+        # inline NormalsConstPtr getTargetNormals () const { return (target_normals_); }
+        # NormalsConstPtr getTargetNormals ()
+        
+        # /** \brief See if this rejector requires source normals */
+        # bool requiresSourceNormals () const
+        bool requiresSourceNormals ()
+        
+        # /** \brief Blob method for setting the source normals */
+        # void setSourceNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setSourceNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief See if this rejector requires target normals*/
+        # bool requiresTargetNormals () const
+        bool requiresTargetNormals ()
+        
+        # /** \brief Method for setting the target normals */
+        # void setTargetNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setTargetNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum distance between the normal on the source point cloud and the corresponding point in the target
+        #   * point cloud
+        #   */
+        # void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        
+        # /** \brief Determine the reciprocal correspondences between input and target cloud.
+        #   * A correspondence is considered reciprocal if both Src_i has Tgt_i as a 
+        #   * correspondence, and Tgt_i has Src_i as one.
+        #   *
+        #   * \param[out] correspondences the found correspondences (index of query and target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineReciprocalCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # 
+        # /** \brief Set the number of nearest neighbours to be considered in the target 
+        #   * point cloud. By default, we use k = 10 nearest neighbors.
+        #   *
+        #   * \param[in] k the number of nearest neighbours to be considered
+        #   */
+        # inline void setKSearch (unsigned int k)
+        # void setKSearch (unsigned int k)
+        
+        # /** \brief Get the number of nearest neighbours considered in the target point 
+        #   * cloud for computing correspondences. By default we use k = 10 nearest 
+        #   * neighbors.
+        #   */
+        # inline void getKSearch ()
+        # void getKSearch ()
+        
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const
+
+
+###
+
+# correspondence_estimation_normal_shooting.h
+# template <typename PointSource, typename PointTarget, typename NormalT>
+# class CorrespondenceEstimationNormalShooting : public CorrespondenceEstimation <PointSource, PointTarget>
+cdef extern from "pcl/registration/correspondence_estimation_normal_shooting.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationNormalShooting[Source, Target, NormalT](CorrespondenceEstimation[Source, Target, NormalT]):
+        CorrespondenceEstimationNormalShooting()
+        # public:
+        # using PCLBase<PointSource>::initCompute;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using CorrespondenceEstimation<PointSource, PointTarget>::getClassName;
+        # typedef typename pcl::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # typedef typename pcl::PointCloud<NormalT>::Ptr NormalsPtr;
+        
+        # /** \brief Set the normals computed on the input point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        #   */
+        # inline void setSourceNormals (const NormalsPtr &normals)
+        # void setSourceNormals (const NormalsPtr &normals)
+        
+        # 
+        # /** \brief Get the normals of the input point cloud
+        #   */
+        # inline NormalsPtr getSourceNormals () const
+        # NormalsPtr getSourceNormals ()
+        
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum distance between the normal on the source point cloud and the corresponding point in the target
+        #   * point cloud
+        #   */
+        # void determineCorrespondences (pcl::Correspondences &correspondences, float max_distance = std::numeric_limits<float>::max ());
+        
+        # /** \brief Set the number of nearest neighbours to be considered in the target point cloud
+        #   * \param[in] k the number of nearest neighbours to be considered
+        #   */
+        # inline void setKSearch (unsigned int k)
+        void setKSearch (unsigned int k)
+        
+        # /** \brief Get the number of nearest neighbours considered in the target point cloud for computing correspondence
+        #   */
+        # inline void getKSearch ()
+        void getKSearch ()
+
+
+###
+
+# correspondence_estimation_organized_projection.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class CorrespondenceEstimationOrganizedProjection : public CorrespondenceEstimationBase <PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/correspondence_estimation_organized_projection.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationOrganizedProjection[Source, Target, float](CorrespondenceEstimationBase[Source, Target, float]):
+        # CorrespondenceEstimationOrganizedProjection ()
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initCompute;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_transformed_;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::getClassName;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::point_representation_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_cloud_updated_;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef boost::shared_ptr< CorrespondenceEstimationOrganizedProjection<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr< const CorrespondenceEstimationOrganizedProjection<PointSource, PointTarget, Scalar> > ConstPtr;
+        
+        # /** \brief Empty constructor that sets all the intrinsic calibration to the default Kinect values. */
+        # CorrespondenceEstimationOrganizedProjection ()
+        
+        # /** \brief Sets the focal length parameters of the target camera.
+        #   * \param[in] fx the focal length in pixels along the x-axis of the image
+        #   * \param[in] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void setFocalLengths (const float fx, const float fy)
+        void setFocalLengths (const float fx, const float fy)
+        
+        # /** \brief Reads back the focal length parameters of the target camera.
+        #   * \param[out] fx the focal length in pixels along the x-axis of the image
+        #   * \param[out] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void getFocalLengths (float &fx, float &fy) const
+        void getFocalLengths (float &fx, float &fy)
+        
+        # /** \brief Sets the camera center parameters of the target camera.
+        #   * \param[in] cx the x-coordinate of the camera center
+        #   * \param[in] cy the y-coordinate of the camera center
+        #   */
+        # inline void setCameraCenters (const float cx, const float cy)
+        void setCameraCenters (const float cx, const float cy)
+        
+        # /** \brief Reads back the camera center parameters of the target camera.
+        #   * \param[out] cx the x-coordinate of the camera center
+        #   * \param[out] cy the y-coordinate of the camera center
+        #   */
+        # inline void getCameraCenters (float &cx, float &cy) const
+        void getCameraCenters (float &cx, float &cy)
+        
+        # /** \brief Sets the transformation from the source point cloud to the target point cloud.
+        #   * \note The target point cloud must be in its local camera coordinates, so use this transformation to correct
+        #   * for that.
+        #   * \param[in] src_to_tgt_transformation the transformation
+        #   */
+        # inline void setSourceTransformation (const Eigen::Matrix4f &src_to_tgt_transformation)
+        void setSourceTransformation (const Matrix4f &src_to_tgt_transformation)
+        
+        # /** \brief Reads back the transformation from the source point cloud to the target point cloud.
+        #   * \note The target point cloud must be in its local camera coordinates, so use this transformation to correct
+        #   * for that.
+        #   * \return the transformation
+        #   */
+        # inline Eigen::Matrix4f getSourceTransformation () const
+        Matrix4f getSourceTransformation ()
+        
+        # /** \brief Sets the depth threshold; after projecting the source points in the image space of the target camera,
+        #   * this threshold is applied on the depths of corresponding dexels to eliminate the ones that are too far from
+        #   * each other.
+        #   * \param[in] depth_threshold the depth threshold
+        #   */
+        # inline void setDepthThreshold (const float depth_threshold)
+        void setDepthThreshold (const float depth_threshold)
+        
+        # /** \brief Reads back the depth threshold; after projecting the source points in the image space of the target
+        #   * camera, this threshold is applied on the depths of corresponding dexels to eliminate the ones that are too
+        #   * far from each other.
+        #   * \return the depth threshold
+        #   */
+        # inline float getDepthThreshold ()
+        float getDepthThreshold ()
+        
+        # /** \brief Computes the correspondences, applying a maximum Euclidean distance threshold.
+        #   * \param correspondences
+        #   * \param[in] max_distance Euclidean distance threshold above which correspondences will be rejected
+        #   */
+        # void determineCorrespondences (Correspondences &correspondences, double max_distance);
+        # void determineCorrespondences (Correspondences &correspondences, double max_distance)
+        
+        # /** \brief Computes the correspondences, applying a maximum Euclidean distance threshold.
+        #   * \param correspondences
+        #   * \param[in] max_distance Euclidean distance threshold above which correspondences will be rejected
+        #   */
+        # void determineReciprocalCorrespondences (Correspondences &correspondences, double max_distance);
+        # void determineReciprocalCorrespondences (Correspondences &correspondences, double max_distance)
+        
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const
+
+
+###
+
+# correspondence_rejection_distance.h
+# class CorrespondenceRejectorDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorDistance(CorrespondenceRejector):
+        CorrespondenceRejectorDistance()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Set the maximum distance used for thresholding in correspondence rejection.
+        #   * \param[in] distance Distance to be used as maximum distance between correspondences. 
+        #   * Correspondences with larger distances are rejected.
+        #   * \note Internally, the distance will be stored squared.
+        #   */
+        # virtual inline void setMaximumDistance (float distance)
+        # 
+        # /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+        # inline float getMaximumDistance ()
+        # 
+        # /** \brief Provide a source point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # 
+        # /** \brief Provide a target point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+
+
+###
+
+# correspondence_rejection_features.h
+# class CorrespondenceRejectorFeatures: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_features.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorFeatures(CorrespondenceRejector):
+        CorrespondenceRejectorFeatures()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] source_feature a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setSourceFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &source_feature, const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setSourceFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr getSourceFeature (const std::string &key);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] target_feature a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setTargetFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &target_feature, const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setTargetFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr getTargetFeature (const std::string &key);
+        # 
+        # /** \brief Set a hard distance threshold in the feature \a FeatureT space, between source and target
+        #   * features. Any feature correspondence that is above this threshold will be considered bad and will be
+        #   * filtered out.
+        #   * \param[in] thresh the distance threshold
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setDistanceThreshold (double thresh, const std::string &key);
+        # 
+        # /** \brief Test that all features are valid (i.e., does each key have a valid source cloud, target cloud, 
+        #   * and search method)
+        #   */
+        # inline bool hasValidFeatures ();
+        # 
+        # /** \brief Provide a boost shared pointer to a PointRepresentation to be used when comparing features
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   * \param[in] fr the point feature representation to be used 
+        #   */
+        # template <typename FeatureT> inline void setFeatureRepresentation (const typename pcl::PointRepresentation<FeatureT>::ConstPtr &fr, const std::string &key);
+
+
+###
+
+# correspondence_rejection_median_distance.h
+# class CorrespondenceRejectorMedianDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_median_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorMedianDistance(CorrespondenceRejector):
+        CorrespondenceRejectorMedianDistance()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void 
+        # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+        #                              pcl::Correspondences& remaining_correspondences);
+        # /** \brief Set the maximum distance used for thresholding in correspondence rejection.
+        #   * \param[in] distance Distance to be used as maximum distance between correspondences. 
+        #   * Correspondences with larger distances are rejected.
+        #   * \note Internally, the distance will be stored squared.
+        #   */
+        # virtual inline void setMaximumDistance (float distance)
+        # /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+        # inline float getMaximumDistance ()
+        # /** \brief Provide a source point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # 
+        # /** \brief Provide a target point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+
+
+###
+
+# correspondence_rejection_features.h
+# class CorrespondenceRejectorFeatures: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_features.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorFeatures(CorrespondenceRejector):
+        CorrespondenceRejectorFeatures()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # void 
+        # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+        #                              pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] source_feature a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void 
+        # setSourceFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &source_feature, 
+        #                   const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setSourceFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr 
+        # getSourceFeature (const std::string &key);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] target_feature a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void 
+        # setTargetFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &target_feature, 
+        #                   const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setTargetFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr 
+        # getTargetFeature (const std::string &key);
+        # 
+        # /** \brief Set a hard distance threshold in the feature \a FeatureT space, between source and target
+        #   * features. Any feature correspondence that is above this threshold will be considered bad and will be
+        #   * filtered out.
+        #   * \param[in] thresh the distance threshold
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void 
+        # setDistanceThreshold (double thresh, const std::string &key);
+        # 
+        # /** \brief Test that all features are valid (i.e., does each key have a valid source cloud, target cloud, 
+        #   * and search method)
+        #   */
+        # inline bool hasValidFeatures ();
+        # 
+        # /** \brief Provide a boost shared pointer to a PointRepresentation to be used when comparing features
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   * \param[in] fr the point feature representation to be used 
+        #   */
+        # template <typename FeatureT> inline void
+        # setFeatureRepresentation (const typename pcl::PointRepresentation<FeatureT>::ConstPtr &fr,
+        #                           const std::string &key);
+        # 
+
+
+###
+
+# correspondence_rejection_median_distance.h
+# class CorrespondenceRejectorMedianDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_median_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorMedianDistance(CorrespondenceRejector):
+        CorrespondenceRejectorMedianDistance()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void 
+        # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+        #                              pcl::Correspondences& remaining_correspondences);
+        # /** \brief Get the median distance used for thresholding in correspondence rejection. */
+        # inline double getMedianDistance () const
+        # /** \brief Provide a source point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # /** \brief Provide a target point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+        # /** \brief Set the factor for correspondence rejection. Points with distance greater than median times factor
+        #  *  will be rejected
+        #  *  \param[in] factor value
+        #  */
+        # inline void setMedianFactor (double factor)
+        # /** \brief Get the factor used for thresholding in correspondence rejection. */
+        # inline double getMedianFactor () const { return factor_; };
+
+
+###
+
+# correspondence_rejection_one_to_one.h
+# class CorrespondenceRejectorOneToOne: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_one_to_one.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorOneToOne(CorrespondenceRejector):
+        CorrespondenceRejectorOneToOne()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       public:
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void 
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                      pcl::Correspondences& remaining_correspondences);
+# 
+#       protected:
+#         /** \brief Apply the rejection algorithm.
+#           * \param[out] correspondences the set of resultant correspondences.
+#           */
+#         inline void 
+#         applyRejection (pcl::Correspondences &correspondences)
+#         {
+#           getRemainingCorrespondences (*input_correspondences_, correspondences);
+#         }
+#     };
+
+# 
+###
+
+# correspondence_rejection_organized_boundary.h
+# namespace pcl
+# namespace registration
+# class PCL_EXPORTS CorrespondenceRejectionOrganizedBoundary : public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_organized_boundary.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectionOrganizedBoundary(CorrespondenceRejector):
+        CorrespondenceRejectionOrganizedBoundary()
+        # public:
+        # /** @brief Empty constructor. */
+        # CorrespondenceRejectionOrganizedBoundary ()
+        #   : boundary_nans_threshold_ (8)
+        #   , window_size_ (5)
+        #   , depth_step_threshold_ (0.025f)
+        #   , data_container_ ()
+        # { }
+        # 
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        
+        # inline void setNumberOfBoundaryNaNs (int val)
+        
+        # template <typename PointT> inline void setInputSource (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # template <typename PointT> inline void setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        
+        # /** \brief See if this rejector requires source points */
+        # bool requiresSourcePoints () const
+        
+        # /** \brief Blob method for setting the source cloud */
+        # void setSourcePoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief See if this rejector requires a target cloud */
+        # bool requiresTargetPoints () const
+        
+        # /** \brief Method for setting the target cloud */
+        # void setTargetPoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # virtual bool updateSource (const Eigen::Matrix4d &)
+
+
+###
+
+# correspondence_rejection_poly.h
+# namespace pcl
+# namespace registration
+# template <typename SourceT, typename TargetT>
+cdef extern from "pcl/registration/correspondence_rejection_poly.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorPoly(CorrespondenceRejector):
+        CorrespondenceRejectorPoly ()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceRejectorPoly> Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceRejectorPoly> ConstPtr;
+        # typedef pcl::PointCloud<SourceT> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<TargetT> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # 
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences)
+        
+        # /** \brief Provide a source point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # inline void setInputSource (const PointCloudSourceConstPtr &cloud)
+        # void setInputSource (const PointCloudSourceConstPtr &cloud)
+        
+        # 
+        # /** \brief Provide a source point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # inline void setInputCloud (const PointCloudSourceConstPtr &cloud)
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud)
+        
+        # /** \brief Provide a target point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &target)
+        # void setInputTarget (const PointCloudTargetConstPtr &target)
+        
+        # /** \brief See if this rejector requires source points */
+        # bool requiresSourcePoints () const
+        bool requiresSourcePoints ()
+        
+        # /** \brief Blob method for setting the source cloud */
+        # void setSourcePoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setSourcePoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief See if this rejector requires a target cloud */
+        # bool requiresTargetPoints () const
+        bool requiresTargetPoints ()
+        
+        # /** \brief Method for setting the target cloud */
+        # void setTargetPoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setTargetPoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief Set the polygon cardinality
+        #   * \param cardinality polygon cardinality
+        #   */
+        # inline void setCardinality (int cardinality)
+        void setCardinality (int cardinality)
+        
+        # /** \brief Get the polygon cardinality
+        #   * \return polygon cardinality
+        #   */
+        # inline int getCardinality ()
+        int getCardinality ()
+        
+        # /** \brief Set the similarity threshold in [0,1[ between edge lengths,
+        #   * where 1 is a perfect match
+        #   * \param similarity_threshold similarity threshold
+        #   */
+        # inline void setSimilarityThreshold (float similarity_threshold)
+        void setSimilarityThreshold (float similarity_threshold)
+        
+        # /** \brief Get the similarity threshold between edge lengths
+        #   * \return similarity threshold
+        #   */
+        # inline float getSimilarityThreshold ()
+        float getSimilarityThreshold ()
+        
+        # /** \brief Set the number of iterations
+        #   * \param iterations number of iterations
+        #   */
+        # inline void setIterations (int iterations)
+        void setIterations (int iterations)
+        
+        # /** \brief Get the number of iterations
+        #   * \return number of iterations
+        #   */
+        # inline int getIterations ()
+        int getIterations ()
+        
+        # /** \brief Polygonal rejection of a single polygon, indexed by a subset of correspondences
+        #   * \param corr all correspondences into \ref input_ and \ref target_
+        #   * \param idx sampled indices into \b correspondences, must have a size equal to \ref cardinality_
+        #   * \return true if all edge length ratios are larger than or equal to \ref similarity_threshold_
+        #   */
+        # inline bool thresholdPolygon (const pcl::Correspondences& corr, const std::vector<int>& idx)
+        # bool thresholdPolygon (const pcl::Correspondences& corr, const std::vector[int]& idx)
+        
+        # /** \brief Polygonal rejection of a single polygon, indexed by two point index vectors
+        #   * \param source_indices indices of polygon points in \ref input_, must have a size equal to \ref cardinality_
+        #   * \param target_indices corresponding indices of polygon points in \ref target_, must have a size equal to \ref cardinality_
+        #   * \return true if all edge length ratios are larger than or equal to \ref similarity_threshold_
+        #   */
+        # inline bool thresholdPolygon (const std::vector<int>& source_indices, const std::vector<int>& target_indices)
+        # bool thresholdPolygon (const vector[int]& source_indices, const vector[int]& target_indices)
+
+
+###
+
+# correspondence_rejection_sample_consensus.h
+# template <typename PointT>
+# class CorrespondenceRejectorSampleConsensus: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_sample_consensus.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSampleConsensus[T](CorrespondenceRejector):
+        CorrespondenceRejectorSampleConsensus()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       public:
+#       /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#         * \param[in] original_correspondences the set of initial correspondences given
+#         * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#         */
+#       inline void 
+#       getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                    pcl::Correspondences& remaining_correspondences);
+# 
+#       /** \brief Provide a source point cloud dataset (must contain XYZ data!)
+#         * \param[in] cloud a cloud containing XYZ data
+#         */
+#       virtual inline void 
+#       setInputCloud (const PointCloudConstPtr &cloud) { input_ = cloud; }
+# 
+#       /** \brief Provide a target point cloud dataset (must contain XYZ data!)
+#         * \param[in] cloud a cloud containing XYZ data
+#         */
+#       virtual inline void 
+#       setTargetCloud (const PointCloudConstPtr &cloud) { target_ = cloud; }
+# 
+#       /** \brief Set the maximum distance between corresponding points.
+#         * Correspondences with distances below the threshold are considered as inliers.
+#         * \param[in] threshold Distance threshold in the same dimension as source and target data sets.
+#         */
+#       inline void 
+#       setInlierThreshold (double threshold) { inlier_threshold_ = threshold; };
+# 
+#       /** \brief Get the maximum distance between corresponding points.
+#         * \return Distance threshold in the same dimension as source and target data sets.
+#         */
+#       inline double 
+#       getInlierThreshold() { return inlier_threshold_; };
+# 
+#       /** \brief Set the maximum number of iterations.
+#         * \param[in] max_iterations Maximum number if iterations to run
+#         */
+#       inline void 
+#       setMaxIterations (int max_iterations) {max_iterations_ = std::max(max_iterations, 0); };
+# 
+#       /** \brief Get the maximum number of iterations.
+#         * \return max_iterations Maximum number if iterations to run
+#         */
+#       inline int 
+#       getMaxIterations () { return max_iterations_; };
+# 
+#       /** \brief Get the best transformation after RANSAC rejection.
+#         * \return The homogeneous 4x4 transformation yielding the largest number of inliers.
+#         */
+#       inline Eigen::Matrix4f 
+#       getBestTransformation () { return best_transformation_; };
+
+
+###
+
+# correspondence_rejection_sample_consensus_2d.h
+# namespace pcl
+# namespace registration
+# template <typename PointT>
+# class CorrespondenceRejectorSampleConsensus2D: public CorrespondenceRejectorSampleConsensus<PointT>
+cdef extern from "pcl/registration/correspondence_rejection_sample_consensus_2d.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSampleConsensus2D[T](CorrespondenceRejectorSampleConsensus):
+        CorrespondenceRejectorSampleConsensus2D()
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # using CorrespondenceRejectorSampleConsensus<PointT>::refine_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::input_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::target_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::input_correspondences_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::rejection_name_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::getClassName;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::inlier_threshold_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::max_iterations_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::best_transformation_;
+        # 
+        # typedef boost::shared_ptr<CorrespondenceRejectorSampleConsensus2D> Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceRejectorSampleConsensus2D> ConstPtr;
+        # 
+        # /** \brief Empty constructor. Sets the inlier threshold to 5cm (0.05m), 
+        #   * and the maximum number of iterations to 1000. 
+        #   */
+        # CorrespondenceRejectorSampleConsensus2D ()
+        #   : projection_matrix_ (Eigen::Matrix3f::Identity ())
+        # {
+        #   rejection_name_ = "CorrespondenceRejectorSampleConsensus2D";
+        #   // Put the projection matrix together
+        #   //projection_matrix_ (0, 0) = 525.f;
+        #   //projection_matrix_ (1, 1) = 525.f;
+        #   //projection_matrix_ (0, 2) = 320.f;
+        #   //projection_matrix_ (1, 2) = 240.f;
+        # }
+        # 
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        
+        # /** \brief Sets the focal length parameters of the target camera.
+        #   * \param[in] fx the focal length in pixels along the x-axis of the image
+        #   * \param[in] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void setFocalLengths (const float fx, const float fy)
+        
+        # /** \brief Reads back the focal length parameters of the target camera.
+        #   * \param[out] fx the focal length in pixels along the x-axis of the image
+        #   * \param[out] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void getFocalLengths (float &fx, float &fy) const
+        
+        # /** \brief Sets the camera center parameters of the target camera.
+        #   * \param[in] cx the x-coordinate of the camera center
+        #   * \param[in] cy the y-coordinate of the camera center
+        #   */
+        # inline void setCameraCenters (const float cx, const float cy)
+        
+        # /** \brief Reads back the camera center parameters of the target camera.
+        #   * \param[out] cx the x-coordinate of the camera center
+        #   * \param[out] cy the y-coordinate of the camera center
+        #   */
+        # inline void getCameraCenters (float &cx, float &cy) const
+
+
+###
+
+# correspondence_rejection_surface_normal.h
+# class CorrespondenceRejectorSurfaceNormal : public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_surface_normal.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSurfaceNormal(CorrespondenceRejector):
+        CorrespondenceRejectorSurfaceNormal()
+#       # using CorrespondenceRejector::input_correspondences_;
+#       # using CorrespondenceRejector::rejection_name_;
+#       # using CorrespondenceRejector::getClassName;
+#       # public:
+#       # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#       #   * \param[in] original_correspondences the set of initial correspondences given
+#       #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#       #   */
+#       # inline void 
+#       # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#       #                              pcl::Correspondences& remaining_correspondences);
+#       # 
+#       # /** \brief Set the thresholding angle between the normals for correspondence rejection. 
+#       #   * \param[in] threshold cosine of the thresholding angle between the normals for rejection
+#       #   */
+#       # inline void
+#       # setThreshold (double threshold) { threshold_ = threshold; };
+#       # 
+#       # /** \brief Get the thresholding angle between the normals for correspondence rejection. */
+#       # inline double getThreshold () const { return threshold_; };
+#       # 
+#       # /** \brief Initialize the data container object for the point type and the normal type
+#       #   */
+#       # template <typename PointT, typename NormalT> inline void initializeDataContainer ()
+#       # 
+#       # /** \brief Provide a source point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] cloud a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &input)
+#       # 
+#       # /** \brief Provide a target point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] target a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+#       # 
+#       # /** \brief Set the normals computed on the input point cloud
+#       #   * \param[in] normals the normals computed for the input cloud
+#       #   */
+#       # template <typename PointT, typename NormalT> inline void 
+#       # setInputNormals (const typename pcl::PointCloud<NormalT>::ConstPtr &normals)
+#       # 
+#       # /** \brief Set the normals computed on the target point cloud
+#       #   * \param[in] normals the normals computed for the input cloud
+#       #   */
+#       # template <typename PointT, typename NormalT> inline void 
+#       # setTargetNormals (const typename pcl::PointCloud<NormalT>::ConstPtr &normals)
+#       # 
+#       # /** \brief Get the normals computed on the input point cloud */
+#       # template <typename NormalT> inline typename pcl::PointCloud<NormalT>::Ptr
+#       # getInputNormals () const { return boost::static_pointer_cast<DataContainer<pcl::PointXYZ, NormalT> > (data_container_)->getInputNormals (); }
+#       # 
+#       # /** \brief Get the normals computed on the target point cloud */
+#       # template <typename NormalT> inline typename pcl::PointCloud<NormalT>::Ptr
+#       # getTargetNormals () const { return boost::static_pointer_cast<DataContainer<pcl::PointXYZ, NormalT> > (data_container_)->getTargetNormals (); }
+
+
+###
+
+# correspondence_rejection_trimmed.h
+#     class CorrespondenceRejectorTrimmed: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_trimmed.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorTrimmed(CorrespondenceRejector):
+        CorrespondenceRejectorTrimmed()
+#       # using CorrespondenceRejector::input_correspondences_;
+#       # using CorrespondenceRejector::rejection_name_;
+#       # using CorrespondenceRejector::getClassName;
+#       # public:
+#       # /** \brief Set the expected ratio of overlap between point clouds (in
+#       #   * terms of correspondences).
+#       #   * \param[in] ratio ratio of overlap between 0 (no overlap, no
+#       #   * correspondences) and 1 (full overlap, all correspondences)
+#       #   */
+#       # virtual inline void setOverlapRadio (float ratio)
+#       # 
+#       # /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+#       # inline float getOverlapRadio ()
+#       # 
+#       # /** \brief Set a minimum number of correspondences. If the specified overlap ratio causes to have
+#       #   * less correspondences,  \a CorrespondenceRejectorTrimmed will try to return at least
+#       #   * \a nr_min_correspondences_ correspondences (or all correspondences in case \a nr_min_correspondences_
+#       #   * is less than the number of given correspondences). 
+#       #   * \param[in] min_correspondences the minimum number of correspondences
+#       #   */
+#       # inline void setMinCorrespondences (unsigned int min_correspondences) { nr_min_correspondences_ = min_correspondences; };
+#       # 
+#       # /** \brief Get the minimum number of correspondences. */
+#       # inline unsigned int getMinCorrespondences ()
+#       # 
+#       # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#       #   * \param[in] original_correspondences the set of initial correspondences given
+#       #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#       #   */
+#       # inline void
+#       # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences,
+#       #                              pcl::Correspondences& remaining_correspondences);
+
+
+###
+
+# correspondence_rejection_var_trimmed.h
+#     class CorrespondenceRejectorVarTrimmed: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_var_trimmed.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorVarTrimmed(CorrespondenceRejector):
+        CorrespondenceRejectorVarTrimmed()
+#       # using CorrespondenceRejector::input_correspondences_;
+#       # using CorrespondenceRejector::rejection_name_;
+#       # using CorrespondenceRejector::getClassName;
+#       # public:
+#       # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#       #   * \param[in] original_correspondences the set of initial correspondences given
+#       #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#       #   */
+#       # inline void 
+#       # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#       #                              pcl::Correspondences& remaining_correspondences);
+#       # 
+#       # /** \brief Get the trimmed distance used for thresholding in correspondence rejection. */
+#       # inline double
+#       # getTrimmedDistance () const { return trimmed_distance_; };
+#       # 
+#       # /** \brief Provide a source point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] cloud a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+#       # 
+#       # /** \brief Provide a target point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] target a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+#       # 
+#       # /** \brief Get the computed inlier ratio used for thresholding in correspondence rejection. */
+#       # inline double
+#       # getTrimFactor () const { return factor_; }
+#       # 
+#       # /** brief set the minimum overlap ratio
+#       #   * \param[in] ratio the overlap ratio [0..1]
+#       #   */
+#       # inline void
+#       # setMinRatio (double ratio) { min_ratio_ = ratio; }
+#       # 
+#       # /** brief get the minimum overlap ratio
+#       #   */
+#       # inline double
+#       # getMinRatio () const { return min_ratio_; }
+#       # 
+#       # /** brief set the maximum overlap ratio
+#       #   * \param[in] ratio the overlap ratio [0..1]
+#       #   */
+#       # inline void
+#       # setMaxRatio (double ratio) { max_ratio_ = ratio; }
+#       # 
+#       # /** brief get the maximum overlap ratio
+#       #   */
+#       # inline double
+#       # getMaxRatio () const { return max_ratio_; }
+# 
+# 
+###
+
+# correspondence_sorting.h
+#     /** @b sortCorrespondencesByQueryIndex : a functor for sorting correspondences by query index
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByQueryIndex : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.index_query < b.index_query);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByMatchIndex : a functor for sorting correspondences by match index
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByMatchIndex : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.index_match < b.index_match);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByDistance : a functor for sorting correspondences by distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.distance < b.distance);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByQueryIndexAndDistance : a functor for sorting correspondences by query index _and_ distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByQueryIndexAndDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       inline bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         if (a.index_query < b.index_query)
+#           return (true);
+#         else if ( (a.index_query == b.index_query) && (a.distance < b.distance) )
+#           return (true);
+#         return (false);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByMatchIndexAndDistance : a functor for sorting correspondences by match index _and_ distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByMatchIndexAndDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       inline bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         if (a.index_match < b.index_match)
+#           return (true);
+#         else if ( (a.index_match == b.index_match) && (a.distance < b.distance) )
+#           return (true);
+#         return (false);
+#       }
+#     };
+
+# 
+###
+
+# correspondence_types.h
+#     /** \brief calculates the mean and standard deviation of descriptor distances from correspondences
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] mean the mean descriptor distance of correspondences
+#       * \param[out] stddev the standard deviation of descriptor distances.
+#       * \note The sample varaiance is used to determine the standard deviation
+#       */
+#     inline void 
+#     getCorDistMeanStd (const pcl::Correspondences& correspondences, double &mean, double &stddev);
+# 
+#     /** \brief extracts the query indices
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] indices array of extracted indices.
+#       * \note order of indices corresponds to input list of descriptor correspondences
+#       */
+#     inline void 
+#     getQueryIndices (const pcl::Correspondences& correspondences, std::vector<int>& indices);
+# 
+#     /** \brief extracts the match indices
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] indices array of extracted indices.
+#       * \note order of indices corresponds to input list of descriptor correspondences
+#       */
+#     inline void 
+#     getMatchIndices (const pcl::Correspondences& correspondences, std::vector<int>& indices);
+
+# 
+###
+
+# default_convergence_criteria.h
+# namespace pcl
+# namespace registration
+# /** \brief @b DefaultConvergenceCriteria represents an instantiation of
+#   * ConvergenceCriteria, and implements the following criteria for registration loop
+#   * evaluation:
+#   *
+#   *  * a maximum number of iterations has been reached
+#   *  * the transformation (R, t) cannot be further updated (the difference between current and previous is smaller than a threshold)
+#   *  * the Mean Squared Error (MSE) between the current set of correspondences and the previous one is smaller than some threshold (both relative and absolute tests)
+#   *
+#   * \note Convergence is considered reached if ANY of the above criteria are met.
+#   *
+#   * \author Radu B. Rusu
+#   * \ingroup registration
+#   */
+# template <typename Scalar = float>
+# class DefaultConvergenceCriteria : public ConvergenceCriteria
+# cdef extern from "pcl/registration/default_convergence_criteria.h" namespace "pcl::registration" nogil:
+#     cdef cppclass DefaultConvergenceCriteria(ConvergenceCriteria):
+        # DefaultConvergenceCriteria()
+        # public:
+        # typedef boost::shared_ptr<DefaultConvergenceCriteria<Scalar> > Ptr;
+        # typedef boost::shared_ptr<const DefaultConvergenceCriteria<Scalar> > ConstPtr;
+        # typedef Eigen::Matrix<Scalar, 4, 4> Matrix4;
+        # 
+        # enum ConvergenceState
+        # {
+        #   CONVERGENCE_CRITERIA_NOT_CONVERGED,
+        #   CONVERGENCE_CRITERIA_ITERATIONS,
+        #   CONVERGENCE_CRITERIA_TRANSFORM,
+        #   CONVERGENCE_CRITERIA_ABS_MSE,
+        #   CONVERGENCE_CRITERIA_REL_MSE,
+        #   CONVERGENCE_CRITERIA_NO_CORRESPONDENCES
+        # };
+        # 
+        # /** \brief Empty constructor.
+        #   * Sets:
+        #   *  * the maximum number of iterations to 1000
+        #   *  * the rotation threshold to 0.256 degrees (0.99999)
+        #   *  * the translation threshold to 0.0003 meters (3e-4^2)
+        #   *  * the MSE relative / absolute thresholds to 0.001% and 1e-12
+        #   *
+        #   * \param[in] iterations a reference to the number of iterations the loop has ran so far
+        #   * \param[in] transform a reference to the current transformation obtained by the transformation evaluation
+        #   * \param[in] correspondences a reference to the current set of point correspondences between source and target
+        #   */
+        # DefaultConvergenceCriteria (const int &iterations, const Matrix4 &transform, const pcl::Correspondences &correspondences)
+        #   : iterations_ (iterations)
+        #   , transformation_ (transform)
+        #   , correspondences_ (correspondences)
+        #   , correspondences_prev_mse_ (std::numeric_limits<double>::max ())
+        #   , correspondences_cur_mse_ (std::numeric_limits<double>::max ())
+        #   , max_iterations_ (100)                 // 100 iterations
+        #   , failure_after_max_iter_ (false)
+        #   , rotation_threshold_ (0.99999)         // 0.256 degrees
+        #   , translation_threshold_ (3e-4 * 3e-4)  // 0.0003 meters
+        #   , mse_threshold_relative_ (0.00001)     // 0.001% of the previous MSE (relative error)
+        #   , mse_threshold_absolute_ (1e-12)       // MSE (absolute error)
+        #   , iterations_similar_transforms_ (0)
+        #   , max_iterations_similar_transforms_ (0)
+        #   , convergence_state_ (CONVERGENCE_CRITERIA_NOT_CONVERGED)
+        # {
+        # }
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~DefaultConvergenceCriteria () {}
+        # 
+        # /** \brief Set the maximum number of iterations that the internal rotation, 
+        #   * translation, and MSE differences are allowed to be similar. 
+        #   * \param[in] nr_iterations the maximum number of iterations 
+        #   */
+        # inline void setMaximumIterationsSimilarTransforms (const int nr_iterations) { max_iterations_similar_transforms_ = nr_iterations; }
+        # 
+        # /** \brief Get the maximum number of iterations that the internal rotation, 
+        #   * translation, and MSE differences are allowed to be similar, as set by the user.
+        #   */
+        # inline int getMaximumIterationsSimilarTransforms () const { return (max_iterations_similar_transforms_); }
+        # 
+        # /** \brief Set the maximum number of iterations the internal optimization should run for.
+        #   * \param[in] nr_iterations the maximum number of iterations the internal optimization should run for
+        #   */
+        # inline void setMaximumIterations (const int nr_iterations) { max_iterations_ = nr_iterations; }
+        # 
+        # /** \brief Get the maximum number of iterations the internal optimization should run for, as set by the user. */
+        # inline int getMaximumIterations () const { return (max_iterations_); }
+        # 
+        # /** \brief Specifies if the registration fails or converges when the maximum number of iterations is reached.
+        #   * \param[in] failure_after_max_iter If true, the registration fails. If false, the registration is assumed to have converged.
+        #   */
+        # inline void setFailureAfterMaximumIterations (const bool failure_after_max_iter) { failure_after_max_iter_ = failure_after_max_iter; }
+        # 
+        # /** \brief Get whether the registration will fail or converge when the maximum number of iterations is reached. */
+        # inline bool getFailureAfterMaximumIterations () const { return (failure_after_max_iter_); }
+        # 
+        # /** \brief Set the rotation threshold cosine angle (maximum allowable difference between two consecutive transformations) in order for an optimization to be considered as having converged to the final solution.
+        #   * \param[in] threshold the rotation threshold in order for an optimization to be considered as having converged to the final solution.
+        #   */
+        # inline void setRotationThreshold (const double threshold) { rotation_threshold_ = threshold; }
+        # 
+        # /** \brief Get the rotation threshold cosine angle (maximum allowable difference between two consecutive transformations) as set by the user.
+        #   */
+        # inline double getRotationThreshold () const { return (rotation_threshold_); }
+        # 
+        # /** \brief Set the translation threshold (maximum allowable difference between two consecutive transformations) in order for an optimization to be considered as having converged to the final solution.
+        #   * \param[in] threshold the translation threshold in order for an optimization to be considered as having converged to the final solution.
+        #   */
+        # inline void setTranslationThreshold (const double threshold) { translation_threshold_ = threshold; }
+        # 
+        # /** \brief Get the rotation threshold cosine angle (maximum allowable difference between two consecutive transformations) as set by the user.
+        #   */
+        # inline double getTranslationThreshold () const { return (translation_threshold_); }
+        # 
+        # /** \brief Set the relative MSE between two consecutive sets of correspondences.
+        #   * \param[in] mse_relative the relative MSE threshold
+        #   */
+        # inline void setRelativeMSE (const double mse_relative) { mse_threshold_relative_ = mse_relative; }
+        # 
+        # /** \brief Get the relative MSE between two consecutive sets of correspondences. */
+        # inline double getRelativeMSE () const { return (mse_threshold_relative_); }
+        # 
+        # /** \brief Set the absolute MSE between two consecutive sets of correspondences.
+        #   * \param[in] mse_absolute the relative MSE threshold
+        #   */
+        # inline void setAbsoluteMSE (const double mse_absolute) { mse_threshold_absolute_ = mse_absolute; }
+        # 
+        # /** \brief Get the absolute MSE between two consecutive sets of correspondences. */
+        # inline double getAbsoluteMSE () const { return (mse_threshold_absolute_); }
+        # 
+        # /** \brief Check if convergence has been reached. */
+        # virtual bool hasConverged ();
+        # 
+        # /** \brief Return the convergence state after hasConverged () */
+        # ConvergenceState getConvergenceState ()
+        # 
+        # /** \brief Sets the convergence state externally (for example, when ICP does not find
+        #  * enough correspondences to estimate a transformation, the function is called setting
+        #  * the convergence state to ConvergenceState::CONVERGENCE_CRITERIA_NO_CORRESPONDENCES)
+        #  * \param[in] c the convergence state
+        #  */
+        # inline void setConvergenceState(ConvergenceState c)
+
+
+###
+
+# distances.h
+#     /** \brief Compute the median value from a set of doubles
+#       * \param[in] fvec the set of doubles
+#       * \param[in] m the number of doubles in the set
+#       */
+#     inline double 
+#     computeMedian (double *fvec, int m)
+#     {
+#       // Copy the values to vectors for faster sorting
+#       std::vector<double> data (m);
+#       memcpy (&data[0], fvec, sizeof (double) * m);
+#       
+#       std::nth_element(data.begin(), data.begin() + (data.size () >> 1), data.end());
+#       return (data[data.size () >> 1]);
+#     }
+# 
+#     /** \brief Use a Huber kernel to estimate the distance between two vectors
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       * \param[in] sigma the sigma value
+#       */
+#     inline double
+#     huber (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt, double sigma) 
+#     {
+#       Eigen::Array4f diff = (p_tgt.array () - p_src.array ()).abs ();
+#       double norm = 0.0;
+#       for (int i = 0; i < 3; ++i)
+#       {
+#         if (diff[i] < sigma)
+#           norm += diff[i] * diff[i];
+#         else
+#           norm += 2.0 * sigma * diff[i] - sigma * sigma;
+#       }
+#       return (norm);
+#     }
+# 
+#     /** \brief Use a Huber kernel to estimate the distance between two vectors
+#       * \param[in] diff the norm difference between two vectors
+#       * \param[in] sigma the sigma value
+#       */
+#     inline double
+#     huber (double diff, double sigma) 
+#     {
+#       double norm = 0.0;
+#       if (diff < sigma)
+#         norm += diff * diff;
+#       else
+#         norm += 2.0 * sigma * diff - sigma * sigma;
+#       return (norm);
+#     }
+# 
+#     /** \brief Use a Gedikli kernel to estimate the distance between two vectors
+#       * (for more information, see 
+#       * \param[in] val the norm difference between two vectors
+#       * \param[in] clipping the clipping value
+#       * \param[in] slope the slope. Default: 4
+#       */
+#     inline double
+#     gedikli (double val, double clipping, double slope = 4) 
+#     {
+#       return (1.0 / (1.0 + pow (fabs(val) / clipping, slope)));
+#     }
+# 
+#     /** \brief Compute the Manhattan distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l1 (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src.array () - p_tgt.array ()).abs ().sum ());
+#     }
+# 
+#     /** \brief Compute the Euclidean distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l2 (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src - p_tgt).norm ());
+#     }
+# 
+#     /** \brief Compute the squared Euclidean distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l2Sqr (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src - p_tgt).squaredNorm ());
+#     }
+
+
+###
+
+# eigen.h
+# # 
+# #include <Eigen/Core>
+# #include <Eigen/Geometry>
+# #include <unsupported/Eigen/Polynomials>
+# #include <Eigen/Dense>
+###
+
+# elch.h
+# template <typename PointT>
+# class ELCH : public PCLBase<PointT>
+cdef extern from "pcl/registration/elch.h" namespace "pcl::registration" nogil:
+    cdef cppclass ELCH[T](cpp.PCLBase[T]):
+        ELCH()
+#       public:
+#       typedef boost::shared_ptr< ELCH<PointT> > Ptr;
+#       typedef boost::shared_ptr< const ELCH<PointT> > ConstPtr;
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       struct Vertex
+#       {
+#         Vertex () : cloud () {}
+#         PointCloudPtr cloud;
+#       };
+# 
+#       /** \brief graph structure to hold the SLAM graph */
+#       typedef boost::adjacency_list<
+#         boost::listS, boost::vecS, boost::undirectedS,
+#         Vertex,
+#         boost::no_property>
+#       LoopGraph;
+#       typedef boost::shared_ptr< LoopGraph > LoopGraphPtr;
+#       typedef typename pcl::Registration<PointT, PointT> Registration;
+#       typedef typename Registration::Ptr RegistrationPtr;
+#       typedef typename Registration::ConstPtr RegistrationConstPtr;
+#
+#       /** \brief Add a new point cloud to the internal graph.
+#        * \param[in] cloud the new point cloud
+#        */
+#       inline void
+#       addPointCloud (PointCloudPtr cloud)
+# 
+#       /** \brief Getter for the internal graph. */
+#       inline LoopGraphPtr
+#       getLoopGraph ()
+# 
+#       /** \brief Setter for a new internal graph.
+#        * \param[in] loop_graph the new graph
+#        */
+#       inline void
+#       setLoopGraph (LoopGraphPtr loop_graph)
+# 
+#       /** \brief Getter for the first scan of a loop. */
+#       inline typename boost::graph_traits<LoopGraph>::vertex_descriptor
+#       getLoopStart ()
+#
+#       /** \brief Setter for the first scan of a loop.
+#        * \param[in] loop_start the scan that starts the loop
+#        */
+#       inline void
+#       setLoopStart (const typename boost::graph_traits<LoopGraph>::vertex_descriptor &loop_start)
+#
+#       /** \brief Getter for the last scan of a loop. */
+#       inline typename boost::graph_traits<LoopGraph>::vertex_descriptor
+#       getLoopEnd ()
+# 
+#       /** \brief Setter for the last scan of a loop.
+#        * \param[in] loop_end the scan that ends the loop
+#        */
+#       inline void
+#       setLoopEnd (const typename boost::graph_traits<LoopGraph>::vertex_descriptor &loop_end)
+# 
+#       /** \brief Getter for the registration algorithm. */
+#       inline RegistrationPtr
+#       getReg ()
+# 
+#       /** \brief Setter for the registration algorithm.
+#        * \param[in] reg the registration algorithm used to compute the transformation between the start and the end of the loop
+#        */
+#       inline void setReg (RegistrationPtr reg)
+# 
+#       /** \brief Getter for the transformation between the first and the last scan. */
+#       inline Eigen::Matrix4f getLoopTransform ()
+# 
+#       /** \brief Setter for the transformation between the first and the last scan.
+#        * \param[in] loop_transform the transformation between the first and the last scan
+#        */
+#       inline void setLoopTransform (const Eigen::Matrix4f &loop_transform)
+# 
+#       /** \brief Computes now poses for all point clouds by closing the loop
+#        * between start and end point cloud. This will transform all given point
+#        * clouds for now!
+#        */
+#       void compute ();
+
+
+###
+
+# exceptions.h
+# pcl/exceptions
+#  /** \class SolverDidntConvergeException
+#     * \brief An exception that is thrown when the non linear solver didn't converge
+#     */
+#   class PCL_EXPORTS SolverDidntConvergeException : public PCLException
+#   {
+#     public:
+#     
+#     SolverDidntConvergeException (const std::string& error_description,
+#                                   const std::string& file_name = "",
+#                                   const std::string& function_name = "" ,
+#                                   unsigned line_number = 0) throw ()
+#       : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+#   } ;
+# 
+#  /** \class NotEnoughPointsException
+#     * \brief An exception that is thrown when the number of correspondants is not equal
+#     * to the minimum required
+#     */
+#   class PCL_EXPORTS NotEnoughPointsException : public PCLException
+#   {
+#     public:
+#     
+#     NotEnoughPointsException (const std::string& error_description,
+#                               const std::string& file_name = "",
+#                               const std::string& function_name = "" ,
+#                               unsigned line_number = 0) throw ()
+#       : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+#   } ;
+# 
+###
+
+# gicp6d.h
+# namespace pcl
+#   struct EIGEN_ALIGN16 _PointXYZLAB
+#   {
+#     PCL_ADD_POINT4D; // this adds the members x,y,z
+#     union
+#     {
+#       struct
+#       {
+#         float L;
+#         float a;
+#         float b;
+#       };
+#       float data_lab[4];
+#     };
+#     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+#   /** \brief A custom point type for position and CIELAB color value */
+#   struct PointXYZLAB : public _PointXYZLAB
+#   {
+#     inline PointXYZLAB ()
+#     {
+#       x = y = z = 0.0f; data[3]     = 1.0f;  // important for homogeneous coordinates
+#       L = a = b = 0.0f; data_lab[3] = 0.0f;
+#     }
+#   };
+# }
+# 
+# // register the custom point type in PCL
+# POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::_PointXYZLAB,
+#     (float, x, x)
+#     (float, y, y)
+#     (float, z, z)
+#     (float, L, L)
+#     (float, a, a)
+#     (float, b, b)
+# )
+# POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZLAB, pcl::_PointXYZLAB)
+# 
+# namespace pcl
+# {
+# /** \brief GeneralizedIterativeClosestPoint6D integrates L*a*b* color space information into the
+#  * Generalized Iterative Closest Point (GICP) algorithm.
+#  *
+#  * The suggested input is PointXYZRGBA.
+#  *
+#  * \note If you use this code in any academic work, please cite:
+#  *
+#  * - M. Korn, M. Holzkothen, J. Pauli
+#  * Color Supported Generalized-ICP.
+#  * In Proceedings of VISAPP 2014 - International Conference on Computer Vision Theory and Applications,
+#  * Lisbon, Portugal, January 2014.
+#  *
+#  * \author Martin Holzkothen, Michael Korn
+#  * \ingroup registration
+#  */
+# class PCL_EXPORTS GeneralizedIterativeClosestPoint6D : public GeneralizedIterativeClosestPoint<PointXYZRGBA, PointXYZRGBA>
+# {
+#       typedef PointXYZRGBA PointSource;
+#       typedef PointXYZRGBA PointTarget;
+#       public:
+#       
+#       /** \brief constructor.
+#        *
+#        * \param[in] lab_weight the color weight
+#        */
+#       GeneralizedIterativeClosestPoint6D (float lab_weight = 0.032f);
+# 
+#       /** \brief Provide a pointer to the input source
+#        * (e.g., the point cloud that we want to align to the target)
+#        *
+#        * \param[in] cloud the input point cloud source
+#        */
+#       void
+#       setInputSource (const PointCloudSourceConstPtr& cloud);
+# 
+#       /** \brief Provide a pointer to the input target
+#        * (e.g., the point cloud that we want to align the input source to)
+#        *
+#        * \param[in] cloud the input point cloud target
+#        */
+#       void
+#       setInputTarget (const PointCloudTargetConstPtr& target);
+
+
+###
+
+# ia_ransac.h
+# template <typename PointSource, typename PointTarget, typename FeatureT>
+# class SampleConsensusInitialAlignment : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ia_ransac.h" namespace "pcl" nogil:
+    cdef cppclass SampleConsensusInitialAlignment[Source, Target, Feature](Registration[Source, Target, float]):
+        SampleConsensusInitialAlignment() except +
+        # public:
+        # using Registration<PointSource, PointTarget>::reg_name_;
+        # using Registration<PointSource, PointTarget>::input_;
+        # using Registration<PointSource, PointTarget>::indices_;
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # using Registration<PointSource, PointTarget>::corr_dist_threshold_;
+        # using Registration<PointSource, PointTarget>::min_number_correspondences_;
+        # using Registration<PointSource, PointTarget>::max_iterations_;
+        # using Registration<PointSource, PointTarget>::tree_;
+        # using Registration<PointSource, PointTarget>::transformation_estimation_;
+        # using Registration<PointSource, PointTarget>::getClassName;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # ctypedef pcl::PointCloud<FeatureT> FeatureCloud;
+        # ctypedef typename FeatureCloud::Ptr FeatureCloudPtr;
+        # ctypedef typename FeatureCloud::ConstPtr FeatureCloudConstPtr;
+        # cdef cppclass ErrorFunctor
+        # {
+        #   public:
+        #     virtual ~ErrorFunctor () {}
+        #     virtual float operator () (float d) const = 0;
+        # };
+        # 
+        # class HuberPenalty : public ErrorFunctor
+        # cdef cppclass HuberPenalty(ErrorFunctor)
+        #     HuberPenalty ()
+        #   public:
+        #     HuberPenalty (float threshold)
+        #     virtual float operator () (float e) const
+        #     { 
+        #       if (e <= threshold_)
+        #         return (0.5 * e*e); 
+        #       else
+        #         return (0.5 * threshold_ * (2.0 * fabs (e) - threshold_));
+        #     }
+        #   protected:
+        #     float threshold_;
+        # };
+        # 
+        # class TruncatedError : public ErrorFunctor
+        # cdef cppclass TruncatedError(ErrorFunctor)
+        #     TruncatedError ()
+        #   public:
+        #     virtual ~TruncatedError () {}
+        #     TruncatedError (float threshold) : threshold_ (threshold) {}
+        #     virtual float operator () (float e) const
+        #     { 
+        #       if (e <= threshold_)
+        #         return (e / threshold_);
+        #       else
+        #         return (1.0);
+        #     }
+        #   protected:
+        #     float threshold_;
+        # };
+        # 
+        # typedef typename KdTreeFLANN<FeatureT>::Ptr FeatureKdTreePtr; 
+        # 
+        # /** \brief Provide a boost shared pointer to the source point cloud's feature descriptors
+        #   * \param features the source point cloud's features
+        #   */
+        # void setSourceFeatures (const FeatureCloudConstPtr &features);
+        # 
+        # /** \brief Get a pointer to the source point cloud's features */
+        # inline FeatureCloudConstPtr const getSourceFeatures () { return (input_features_); }
+        # 
+        # /** \brief Provide a boost shared pointer to the target point cloud's feature descriptors
+        #   * \param features the target point cloud's features
+        #   */
+        # void setTargetFeatures (const FeatureCloudConstPtr &features);
+        # 
+        # /** \brief Get a pointer to the target point cloud's features */
+        # inline FeatureCloudConstPtr const getTargetFeatures () { return (target_features_); }
+        # 
+        # /** \brief Set the minimum distances between samples
+        #   * \param min_sample_distance the minimum distances between samples
+        #   */
+        # void setMinSampleDistance (float min_sample_distance) { min_sample_distance_ = min_sample_distance; }
+        # 
+        # /** \brief Get the minimum distances between samples, as set by the user */
+        # float getMinSampleDistance () { return (min_sample_distance_); }
+        # 
+        # /** \brief Set the number of samples to use during each iteration
+        #   * \param nr_samples the number of samples to use during each iteration
+        #   */
+        # void setNumberOfSamples (int nr_samples) { nr_samples_ = nr_samples; }
+        # 
+        # /** \brief Get the number of samples to use during each iteration, as set by the user */
+        # int getNumberOfSamples () { return (nr_samples_); }
+        # 
+        # /** \brief Set the number of neighbors to use when selecting a random feature correspondence.  A higher value will
+        #   * add more randomness to the feature matching.
+        #   * \param k the number of neighbors to use when selecting a random feature correspondence.
+        #   */
+        # void setCorrespondenceRandomness (int k) { k_correspondences_ = k; }
+        # 
+        # /** \brief Get the number of neighbors used when selecting a random feature correspondence, as set by the user */
+        # int getCorrespondenceRandomness () { return (k_correspondences_); }
+        # 
+        # /** \brief Specify the error function to minimize
+        #  * \note This call is optional.  TruncatedError will be used by default
+        #  * \param[in] error_functor a shared pointer to a subclass of SampleConsensusInitialAlignment::ErrorFunctor
+        #  */
+        # void setErrorFunction (const boost::shared_ptr<ErrorFunctor> & error_functor) { error_functor_ = error_functor; }
+        # 
+        # /** \brief Get a shared pointer to the ErrorFunctor that is to be minimized  
+        #  * \return A shared pointer to a subclass of SampleConsensusInitialAlignment::ErrorFunctor
+        #  */
+        # boost::shared_ptr<ErrorFunctor> getErrorFunction () { return (error_functor_); }
+
+
+###
+
+# pcl 1.7.2 error(linux pcl package)
+# joint_icp.h
+# /** \brief @b JointIterativeClosestPoint extends ICP to multiple frames which
+#   *  share the same transform. This is particularly useful when solving for 
+#   *  camera extrinsics using multiple observations. When given a single pair of 
+#   *  clouds, this reduces to vanilla ICP.
+#   * \author Stephen Miller
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class JointIterativeClosestPoint : public IterativeClosestPoint<PointSource, PointTarget, Scalar>
+# cdef extern from "pcl/registration/joint_icp.h" namespace "pcl" nogil:
+#     cdef cppclass JointIterativeClosestPoint[Source, Target, float](IterativeClosestPoint[Source, Target, float]):
+#         JointIterativeClosestPoint() except +
+        # public:
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudTarget PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::search::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::search::KdTree<PointSource> KdTreeReciprocal;
+        # typedef typename KdTree::Ptr KdTreeReciprocalPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # typedef boost::shared_ptr<JointIterativeClosestPoint<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const JointIterativeClosestPoint<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename pcl::registration::CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> CorrespondenceEstimation;
+        # typedef typename CorrespondenceEstimation::Ptr CorrespondenceEstimationPtr;
+        # typedef typename CorrespondenceEstimation::ConstPtr CorrespondenceEstimationConstPtr;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::reg_name_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::getClassName;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::setInputSource;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::input_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::indices_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::target_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::nr_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::max_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::previous_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::final_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_epsilon_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::converged_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::corr_dist_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::inlier_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::min_number_correspondences_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::update_visualizer_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::euclidean_fitness_epsilon_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondences_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_estimation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondence_estimation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondence_rejectors_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::use_reciprocal_correspondence_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::convergence_criteria_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::source_has_normals_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::target_has_normals_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::need_source_blob_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::need_target_blob_;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Empty constructor. */
+        # JointIterativeClosestPoint ()
+        
+        # /** \brief Empty destructor */
+        # virtual ~JointIterativeClosestPoint () {}
+        
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   */
+        # virtual void setInputSource (const PointCloudSourceConstPtr& /*cloud*/)
+        # void setInputSource (const PointCloudSourceConstPtr& /*cloud*/)
+        
+        # /** \brief Add a source cloud to the joint solver
+        #   * \param[in] cloud source cloud
+        #   */
+        # inline void addInputSource (const PointCloudSourceConstPtr &cloud)
+        # void addInputSource (const PointCloudSourceConstPtr &cloud)
+        
+        # /** \brief Provide a pointer to the input target 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   */
+        # virtual void setInputTarget (const PointCloudTargetConstPtr& /*cloud*/)
+        # void setInputTarget (const PointCloudTargetConstPtr& /*cloud*/)
+        
+        # /** \brief Add a target cloud to the joint solver
+        #   *
+        #   * \param[in] cloud target cloud
+        #   */
+        # inline void addInputTarget (const PointCloudTargetConstPtr &cloud)
+        # void addInputTarget (const PointCloudTargetConstPtr &cloud)
+        
+        # /** \brief Add a manual correspondence estimator
+        #   * If you choose to do this, you must add one for each 
+        #   * input source / target pair. They do not need to have trees 
+        #   * or input clouds set ahead of time.
+        #   *
+        #   * \param[in] ce Correspondence estimation
+        #   */
+        # inline void addCorrespondenceEstimation (CorrespondenceEstimationPtr ce)
+        # void addCorrespondenceEstimation (CorrespondenceEstimationPtr ce)
+        
+        # /** \brief Reset my list of input sources
+        #   */
+        # inline void clearInputSources ()
+        void clearInputSources ()
+        
+        # /** \brief Reset my list of input targets
+        #   */
+        # inline void clearInputTargets ()
+        void clearInputTargets ()
+        
+        # /** \brief Reset my list of correspondence estimation methods.
+        #   */
+        # inline void clearCorrespondenceEstimations ()
+
+
+###
+
+# lum.h
+# namespace Eigen
+# {
+#   typedef Eigen::Matrix<float, 6, 1> Vector6f;
+#   typedef Eigen::Matrix<float, 6, 6> Matrix6f;
+# }
+# 
+
+# lum.h
+# namespace pcl
+# namespace registration
+# /** \brief Globally Consistent Scan Matching based on an algorithm by Lu and Milios.
+#   * \details A GraphSLAM algorithm where registration data is managed in a graph:
+#   * <ul>
+#   *  <li>Vertices represent poses and hold the point cloud data and relative transformations.</li>
+#   *  <li>Edges represent pose constraints and hold the correspondence data between two point clouds.</li>
+#   * </ul>
+#   * Computation uses the first point cloud in the SLAM graph as a reference pose and attempts to align all other point clouds to it simultaneously.
+#   * For more information:
+#   * <ul><li>
+#   * F. Lu, E. Milios,
+#   * Globally Consistent Range Scan Alignment for Environment Mapping,
+#   * Autonomous Robots 4, April 1997
+#   * </li><li>
+#   * Dorit Borrmann, Jan Elseberg, Kai Lingemann, Andreas Nuchter, and Joachim Hertzberg,
+#   * The Efficient Extension of Globally Consistent Scan Matching to 6 DoF,
+#   * In Proceedings of the 4th International Symposium on 3D Data Processing, Visualization and Transmission (3DPVT '08), June 2008
+#   * </li></ul>
+#   * Usage example:
+#   * \code
+#   * pcl::registration::LUM<pcl::PointXYZ> lum;
+#   * // Add point clouds as vertices to the SLAM graph
+#   * lum.addPointCloud (cloud_0);
+#   * lum.addPointCloud (cloud_1);
+#   * lum.addPointCloud (cloud_2);
+#   * // Use your favorite pairwise correspondence estimation algorithm(s)
+#   * corrs_0_to_1 = someAlgo (cloud_0, cloud_1);
+#   * corrs_1_to_2 = someAlgo (cloud_1, cloud_2);
+#   * corrs_2_to_0 = someAlgo (lum.getPointCloud (2), lum.getPointCloud (0));
+#   * // Add the correspondence results as edges to the SLAM graph
+#   * lum.setCorrespondences (0, 1, corrs_0_to_1);
+#   * lum.setCorrespondences (1, 2, corrs_1_to_2);
+#   * lum.setCorrespondences (2, 0, corrs_2_to_0);
+#   * // Change the computation parameters
+#   * lum.setMaxIterations (5);
+#   * lum.setConvergenceThreshold (0.0);
+#   * // Perform the actual LUM computation
+#   * lum.compute ();
+#   * // Return the concatenated point cloud result
+#   * cloud_out = lum.getConcatenatedCloud ();
+#   * // Return the separate point cloud transformations
+#   * for(int i = 0; i < lum.getNumVertices (); i++)
+#   * {
+#   *   transforms_out[i] = lum.getTransformation (i);
+#   * }
+#   * \endcode
+#   * \author Frits Florentinus, Jochen Sprickerhof
+#   * \ingroup registration
+#   */
+# template<typename PointT>
+# class LUM
+cdef extern from "pcl/registration/lum.h" namespace "pcl" nogil:
+    cdef cppclass LUM[Point]:
+        LUM()
+        # public:
+        # typedef boost::shared_ptr<LUM<PointT> > Ptr;
+        # typedef boost::shared_ptr<const LUM<PointT> > ConstPtr;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # 
+        # struct VertexProperties
+        # {
+        #   PointCloudPtr cloud_;
+        #   Eigen::Vector6f pose_;
+        #   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+        # };
+        # struct EdgeProperties
+        # {
+        #   pcl::CorrespondencesPtr corrs_;
+        #   Eigen::Matrix6f cinv_;
+        #   Eigen::Vector6f cinvd_;
+        #   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+        # };
+        # 
+        # typedef boost::adjacency_list<boost::eigen_vecS, boost::eigen_vecS, boost::bidirectionalS, VertexProperties, EdgeProperties, boost::no_property, boost::eigen_listS> SLAMGraph;
+        # typedef boost::shared_ptr<SLAMGraph> SLAMGraphPtr;
+        # typedef typename SLAMGraph::vertex_descriptor Vertex;
+        # typedef typename SLAMGraph::edge_descriptor Edge;
+        # 
+        # /** \brief Empty constructor.
+        #   */
+        # LUM () 
+        #   : slam_graph_ (new SLAMGraph)
+        #   , max_iterations_ (5)
+        #   , convergence_threshold_ (0.0)
+        # {
+        # }
+        # 
+        # /** \brief Set the internal SLAM graph structure.
+        #   * \details All data used and produced by LUM is stored in this boost::adjacency_list.
+        #   * It is recommended to use the LUM class itself to build the graph.
+        #   * This method could otherwise be useful for managing several SLAM graphs in one instance of LUM.
+        #   * \param[in] slam_graph The new SLAM graph.
+        #   */
+        # inline void setLoopGraph (const SLAMGraphPtr &slam_graph);
+        # 
+        # /** \brief Get the internal SLAM graph structure.
+        #   * \details All data used and produced by LUM is stored in this boost::adjacency_list.
+        #   * It is recommended to use the LUM class itself to build the graph.
+        #   * This method could otherwise be useful for managing several SLAM graphs in one instance of LUM.
+        #   * \return The current SLAM graph.
+        #   */
+        # inline SLAMGraphPtr getLoopGraph () const;
+        # 
+        # /** \brief Get the number of vertices in the SLAM graph.
+        #   * \return The current number of vertices in the SLAM graph.
+        #   */
+        # typename SLAMGraph::vertices_size_type getNumVertices () const;
+        # 
+        # /** \brief Set the maximum number of iterations for the compute() method.
+        #   * \details The compute() method finishes when max_iterations are met or when the convergence criteria is met.
+        #   * \param[in] max_iterations The new maximum number of iterations (default = 5).
+        #   */
+        # void setMaxIterations (int max_iterations);
+        # 
+        # /** \brief Get the maximum number of iterations for the compute() method.
+        #   * \details The compute() method finishes when max_iterations are met or when the convergence criteria is met.
+        #   * \return The current maximum number of iterations (default = 5).
+        #   */
+        # inline int getMaxIterations () const;
+        # 
+        # /** \brief Set the convergence threshold for the compute() method.
+        #   * \details When the compute() method computes the new poses relative to the old poses, it will determine the length of the difference vector.
+        #   * When the average length of all difference vectors becomes less than the convergence_threshold the convergence is assumed to be met.
+        #   * \param[in] convergence_threshold The new convergence threshold (default = 0.0).
+        #   */
+        # void setConvergenceThreshold (float convergence_threshold);
+        # 
+        # /** \brief Get the convergence threshold for the compute() method.
+        #   * \details When the compute() method computes the new poses relative to the old poses, it will determine the length of the difference vector.
+        #   * When the average length of all difference vectors becomes less than the convergence_threshold the convergence is assumed to be met.
+        #   * \return The current convergence threshold (default = 0.0).
+        #   */
+        # inline float getConvergenceThreshold () const;
+        # 
+        # /** \brief Add a new point cloud to the SLAM graph.
+        #   * \details This method will add a new vertex to the SLAM graph and attach a point cloud to that vertex.
+        #   * Optionally you can specify a pose estimate for this point cloud.
+        #   * A vertex' pose is always relative to the first vertex in the SLAM graph, i.e. the first point cloud that was added.
+        #   * Because this first vertex is the reference, you can not set a pose estimate for this vertex.
+        #   * Providing pose estimates to the vertices in the SLAM graph will reduce overall computation time of LUM.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] cloud The new point cloud.
+        #   * \param[in] pose (optional) The pose estimate relative to the reference pose (first point cloud that was added).
+        #   * \return The vertex descriptor of the newly created vertex.
+        #   */
+        # Vertex addPointCloud (const PointCloudPtr &cloud, const Eigen::Vector6f &pose = Eigen::Vector6f::Zero ());
+        # 
+        # /** \brief Change a point cloud on one of the SLAM graph's vertices.
+        #   * \details This method will change the point cloud attached to an existing vertex and will not alter the SLAM graph structure.
+        #   * Note that the correspondences attached to this vertex will not change and may need to be updated manually.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to change the point cloud.
+        #   * \param[in] cloud The new point cloud for that vertex.
+        #   */
+        # inline void setPointCloud (const Vertex &vertex, const PointCloudPtr &cloud);
+        # 
+        # /** \brief Return a point cloud from one of the SLAM graph's vertices.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the point cloud.
+        #   * \return The current point cloud for that vertex.
+        #   */
+        # inline PointCloudPtr getPointCloud (const Vertex &vertex) const;
+        # 
+        # /** \brief Change a pose estimate on one of the SLAM graph's vertices.
+        #   * \details A vertex' pose is always relative to the first vertex in the SLAM graph, i.e. the first point cloud that was added.
+        #   * Because this first vertex is the reference, you can not set a pose estimate for this vertex.
+        #   * Providing pose estimates to the vertices in the SLAM graph will reduce overall computation time of LUM.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to set the pose estimate.
+        #   * \param[in] pose The new pose estimate for that vertex.
+        #   */
+        # inline void setPose (const Vertex &vertex, const Eigen::Vector6f &pose);
+        # 
+        # /** \brief Return a pose estimate from one of the SLAM graph's vertices.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the pose estimate.
+        #   * \return The current pose estimate of that vertex.
+        #   */
+        # inline Eigen::Vector6f getPose (const Vertex &vertex) const;
+        # 
+        # /** \brief Return a pose estimate from one of the SLAM graph's vertices as an affine transformation matrix.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the transformation matrix.
+        #   * \return The current transformation matrix of that vertex.
+        #   */
+        # inline Eigen::Affine3f getTransformation (const Vertex &vertex) const;
+        # 
+        # /** \brief Add/change a set of correspondences for one of the SLAM graph's edges.
+        #   * \details The edges in the SLAM graph are directional and point from source vertex to target vertex.
+        #   * The query indices of the correspondences, index the points at the source vertex' point cloud.
+        #   * The matching indices of the correspondences, index the points at the target vertex' point cloud.
+        #   * If no edge was present at the specified location, this method will add a new edge to the SLAM graph and attach the correspondences to that edge.
+        #   * If the edge was already present, this method will overwrite the correspondence information of that edge and will not alter the SLAM graph structure.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] source_vertex The vertex descriptor of the correspondences' source point cloud.
+        #   * \param[in] target_vertex The vertex descriptor of the correspondences' target point cloud.
+        #   * \param[in] corrs The new set of correspondences for that edge.
+        #   */
+        # void setCorrespondences (const Vertex &source_vertex, 
+        #                     const Vertex &target_vertex, 
+        #                     const pcl::CorrespondencesPtr &corrs);
+        # 
+        # /** \brief Return a set of correspondences from one of the SLAM graph's edges.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] source_vertex The vertex descriptor of the correspondences' source point cloud.
+        #   * \param[in] target_vertex The vertex descriptor of the correspondences' target point cloud.
+        #   * \return The current set of correspondences of that edge.
+        #   */
+        # inline pcl::CorrespondencesPtr getCorrespondences (const Vertex &source_vertex, const Vertex &target_vertex) const;
+        # 
+        # /** \brief Perform LUM's globally consistent scan matching.
+        #   * \details Computation uses the first point cloud in the SLAM graph as a reference pose and attempts to align all other point clouds to it simultaneously.
+        #   * <br>
+        #   * Things to keep in mind:
+        #   * <ul>
+        #   *  <li>Only those parts of the graph connected to the reference pose will properly align to it.</li>
+        #   *  <li>All sets of correspondences should span the same space and need to be sufficient to determine a rigid transformation.</li>
+        #   *  <li>The algorithm draws it strength from loops in the graph because it will distribute errors evenly amongst those loops.</li>
+        #   * </ul>
+        #   * Computation ends when either of the following conditions hold:
+        #   * <ul>
+        #   *  <li>The number of iterations reaches max_iterations. Use setMaxIterations() to change.</li>
+        #   *  <li>The convergence criteria is met. Use setConvergenceThreshold() to change.</li>
+        #   * </ul>
+        #   * Computation will change the pose estimates for the vertices of the SLAM graph, not the point clouds attached to them.
+        #   * The results can be retrieved with getPose(), getTransformation(), getTransformedCloud() or getConcatenatedCloud().
+        #   */
+        # void compute ();
+        # 
+        # /** \brief Return a point cloud from one of the SLAM graph's vertices compounded onto its current pose estimate.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the transformed point cloud.
+        #   * \return The transformed point cloud of that vertex.
+        #   */
+        # PointCloudPtr getTransformedCloud (const Vertex &vertex) const;
+        # 
+        # /** \brief Return a concatenated point cloud of all the SLAM graph's point clouds compounded onto their current pose estimates.
+        #   * \return The concatenated transformed point clouds of the entire SLAM graph.
+        #   */
+        # PointCloudPtr getConcatenatedCloud () const;
+
+
+###
+
+# ndt.h
+# namespace pcl
+# /** \brief A 3D Normal Distribution Transform registration implementation for point cloud data.
+#   * \note For more information please see
+#   * <b>Magnusson, M. (2009). The Three-Dimensional Normal-Distributions Transform  
+#   * an Ef
珣ient Representation for Registration, Surface Analysis, and Loop Detection.
+#   * PhD thesis, Orebro University. Orebro Studies in Technology 36.</b>,
+#   * <b>More, J., and Thuente, D. (1994). Line Search Algorithm with Guaranteed Sufficient Decrease
+#   * In ACM Transactions on Mathematical Software.</b> and
+#   * Sun, W. and Yuan, Y, (2006) Optimization Theory and Methods: Nonlinear Programming. 89-100
+#   * \note Math refactored by Todor Stoyanov.
+#   * \author Brian Okorn (Space and Naval Warfare Systems Center Pacific)
+#   */
+# template<typename PointSource, typename PointTarget>
+# class NormalDistributionsTransform : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ndt.h" namespace "pcl" nogil:
+    cdef cppclass NormalDistributionsTransform[Source, Target](Registration[Source, Target, float]):
+        NormalDistributionsTransform()
+        # protected:
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # /** \brief Typename of searchable voxel grid containing mean and covariance. */
+        # typedef VoxelGridCovariance<PointTarget> TargetGrid;
+        # /** \brief Typename of pointer to searchable voxel grid. */
+        # typedef TargetGrid* TargetGridPtr;
+        # /** \brief Typename of const pointer to searchable voxel grid. */
+        # typedef const TargetGrid* TargetGridConstPtr;
+        # /** \brief Typename of const pointer to searchable voxel grid leaf. */
+        # typedef typename TargetGrid::LeafConstPtr TargetGridLeafConstPtr;
+        # 
+        # public:
+        # typedef boost::shared_ptr< NormalDistributionsTransform<PointSource, PointTarget> > Ptr;
+        # typedef boost::shared_ptr< const NormalDistributionsTransform<PointSource, PointTarget> > ConstPtr;
+        # /** \brief Constructor.
+        #   * Sets \ref outlier_ratio_ to 0.35, \ref step_size_ to 0.05 and \ref resolution_ to 1.0
+        #   */
+        # NormalDistributionsTransform ();
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~NormalDistributionsTransform () {}
+        # 
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to).
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &cloud)
+        # void setInputTarget (const Registration[Source, Target, float] &cloud)
+        
+        # 
+        # /** \brief Set/change the voxel grid resolution.
+        #   * \param[in] resolution side length of voxels
+        #   */
+        # inline void setResolution (float resolution)
+        void setResolution (float resolution)
+        
+        # /** \brief Get voxel grid resolution.
+        #   * \return side length of voxels
+        #   */
+        # inline float getResolution () const
+        float getResolution ()
+        
+        # /** \brief Get the newton line search maximum step length.
+        #   * \return maximum step length
+        #   */
+        # inline double getStepSize () const
+        double getStepSize ()
+        
+        # /** \brief Set/change the newton line search maximum step length.
+        #   * \param[in] step_size maximum step length
+        #   */
+        # inline void setStepSize (double step_size)
+        void setStepSize (double step_size)
+        
+        # /** \brief Get the point cloud outlier ratio.
+        #   * \return outlier ratio
+        #   */
+        # inline double getOulierRatio () const
+        double getOulierRatio ()
+        
+        # /** \brief Set/change the point cloud outlier ratio.
+        #   * \param[in] outlier_ratio outlier ratio
+        #   */
+        # inline void setOulierRatio (double outlier_ratio)
+        void setOulierRatio (double outlier_ratio)
+        
+        # /** \brief Get the registration alignment probability.
+        #   * \return transformation probability
+        #   */
+        # inline double getTransformationProbability () const
+        double getTransformationProbability ()
+        
+        # /** \brief Get the number of iterations required to calculate alignment.
+        #   * \return final number of iterations
+        #   */
+        # inline int getFinalNumIteration () const
+        int getFinalNumIteration ()
+        
+        # /** \brief Convert 6 element transformation vector to affine transformation.
+        #   * \param[in] x transformation vector of the form [x, y, z, roll, pitch, yaw]
+        #   * \param[out] trans affine transform corresponding to given transfomation vector
+        #   */
+        # static void convertTransform (const Eigen::Matrix<double, 6, 1> &x, Eigen::Affine3f &trans)
+        # 
+        # /** \brief Convert 6 element transformation vector to transformation matrix.
+        #   * \param[in] x transformation vector of the form [x, y, z, roll, pitch, yaw]
+        #   * \param[out] trans 4x4 transformation matrix corresponding to given transfomation vector
+        #   */
+        # static void convertTransform (const Eigen::Matrix<double, 6, 1> &x, Eigen::Matrix4f &trans)
+
+
+ctypedef NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ] NormalDistributionsTransform_t
+ctypedef NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI] NormalDistributionsTransform_PointXYZI_t
+ctypedef NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB] NormalDistributionsTransform_PointXYZRGB_t
+ctypedef NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA] NormalDistributionsTransform_PointXYZRGBA_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ]] NormalDistributionsTransformPtr_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI]] NormalDistributionsTransform_PointXYZI_Ptr_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB]] NormalDistributionsTransform_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] NormalDistributionsTransform_PointXYZRGBA_Ptr_t
+###
+
+# ndt_2d.h
+# namespace pcl
+# /** \brief @b NormalDistributionsTransform2D provides an implementation of the
+#   * Normal Distributions Transform algorithm for scan matching.
+#   * This implementation is intended to match the definition:
+#   * Peter Biber and Wolfgang Straser. The normal distributions transform: A
+#   * new approach to laser scan matching. In Proceedings of the IEEE In-
+#   * ternational Conference on Intelligent Robots and Systems (IROS), pages
+#   * 2743 2748, Las Vegas, USA, October 2003.
+#   * \author James Crosby
+#   */
+# template <typename PointSource, typename PointTarget>
+# class NormalDistributionsTransform2D : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ndt_2d.h" namespace "pcl" nogil:
+    cdef cppclass NormalDistributionsTransform2D[Source, Target, float](Registration[Source, Target, float]):
+        NormalDistributionsTransform2D()
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # public:
+        # typedef boost::shared_ptr< NormalDistributionsTransform2D<PointSource, PointTarget> > Ptr;
+        # typedef boost::shared_ptr< const NormalDistributionsTransform2D<PointSource, PointTarget> > ConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # NormalDistributionsTransform2D ()
+        #   : Registration<PointSource,PointTarget> (),
+        #     grid_centre_ (0,0), grid_step_ (1,1), grid_extent_ (20,20), newton_lambda_ (1,1,1)
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~NormalDistributionsTransform2D () {}
+        # 
+        # /** \brief centre of the ndt grid (target coordinate system)
+        #   * \param centre value to set
+        #   */
+        # virtual void setGridCentre (const Eigen::Vector2f& centre) { grid_centre_ = centre; }
+        # 
+        # /** \brief Grid spacing (step) of the NDT grid
+        #   * \param[in] step value to set
+        #   */
+        # virtual void setGridStep (const Eigen::Vector2f& step) { grid_step_ = step; }
+        # 
+        # /** \brief NDT Grid extent (in either direction from the grid centre)
+        #   * \param[in] extent value to set
+        #   */
+        # virtual void setGridExtent (const Eigen::Vector2f& extent) { grid_extent_ = extent; }
+        # 
+        # /** \brief NDT Newton optimisation step size parameter
+        #   * \param[in] lambda step size: 1 is simple newton optimisation, smaller values may improve convergence
+        #   */
+        #  virtual void setOptimizationStepSize (const double& lambda) { newton_lambda_ = Eigen::Vector3d (lambda, lambda, lambda); }
+        # 
+        # /** \brief NDT Newton optimisation step size parameter
+        #   * \param[in] lambda step size: (1,1,1) is simple newton optimisation,
+        #   * smaller values may improve convergence, or elements may be set to
+        #   * zero to prevent optimisation over some parameters
+        #   *
+        #   * This overload allows control of updates to the individual (x, y,
+        #   * theta) free parameters in the optimisation. If, for example, theta is
+        #   * believed to be close to the correct value a small value of lambda[2]
+        #   * should be used.
+        #   */
+        #  virtual void setOptimizationStepSize (const Eigen::Vector3d& lambda) { newton_lambda_ = lambda; }
+
+
+###
+
+# NG : PCL1.7.2 AppVeyor
+# ErrorLog
+# C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\xhash(29): error C2440: 'type cast': cannot convert from 'const pcl::PPFHashMapSearch::HashKeyStruct' to 'std::size_t'
+# C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\xhash(29): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
+# ppf_registration.h
+# template <typename PointSource, typename PointTarget>
+# class PPFRegistration : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ppf_registration.h" namespace "pcl" nogil:
+    cdef cppclass PPFRegistration[Source, Target, float](Registration[Source, Target, float]):
+        PPFRegistration() except +
+        # public:
+        # cdef struct PoseWithVotes
+        #   PoseWithVotes(Eigen::Affine3f &a_pose, unsigned int &a_votes)
+        #   Eigen::Affine3f pose;
+        #   unsigned int votes;
+        # ctypedef std::vector<PoseWithVotes, Eigen::aligned_allocator<PoseWithVotes> > PoseWithVotesList;
+        # /// input_ is the model cloud
+        # using Registration<PointSource, PointTarget>::input_;
+        # /// target_ is the scene cloud
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::converged_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # ctypedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # 
+        # /** \brief Method for setting the position difference clustering parameter
+        #    * \param clustering_position_diff_threshold distance threshold below which two poses are
+        #  * considered close enough to be in the same cluster (for the clustering phase of the algorithm)
+        #  */
+        # inline void setPositionClusteringThreshold (float clustering_position_diff_threshold)
+        void setPositionClusteringThreshold (float clustering_position_diff_threshold)
+        
+        # /** \brief Returns the parameter defining the position difference clustering parameter -
+        #  * distance threshold below which two poses are considered close enough to be in the same cluster
+        #    * (for the clustering phase of the algorithm)
+        #  */
+        # inline float getPositionClusteringThreshold ()
+        float getPositionClusteringThreshold ()
+        
+        # /** \brief Method for setting the rotation clustering parameter
+        #  * \param clustering_rotation_diff_threshold rotation difference threshold below which two
+        #  * poses are considered to be in the same cluster (for the clustering phase of the algorithm)
+        #  */
+        # inline void setRotationClusteringThreshold (float clustering_rotation_diff_threshold)
+        void setRotationClusteringThreshold (float clustering_rotation_diff_threshold)
+        
+        # /** \brief Returns the parameter defining the rotation clustering threshold
+        #  */
+        # inline float getRotationClusteringThreshold ()
+        float getRotationClusteringThreshold ()
+        
+        # /** \brief Method for setting the scene reference point sampling rate
+        #  * \param scene_reference_point_sampling_rate sampling rate for the scene reference point
+        #  */
+        # inline void setSceneReferencePointSamplingRate (unsigned int scene_reference_point_sampling_rate) { scene_reference_point_sampling_rate_ = scene_reference_point_sampling_rate; }
+        void setSceneReferencePointSamplingRate (unsigned int scene_reference_point_sampling_rate)
+        
+        # /** \brief Returns the parameter for the scene reference point sampling rate of the algorithm */
+        # inline unsigned int getSceneReferencePointSamplingRate ()
+        unsigned int getSceneReferencePointSamplingRate ()
+        
+        # 
+        # /** \brief Function that sets the search method for the algorithm
+        #  * \note Right now, the only available method is the one initially proposed by
+        #  * the authors - by using a hash map with discretized feature vectors
+        #  * \param search_method smart pointer to the search method to be set
+        #  */
+        # inline void setSearchMethod (PPFHashMapSearch::Ptr search_method)
+        # void setSearchMethod (PPFHashMapSearch::Ptr search_method)
+        
+        # 
+        # /** \brief Getter function for the search method of the class */
+        # inline PPFHashMapSearch::Ptr getSearchMethod ()
+        # PPFHashMapSearch::Ptr getSearchMethod ()
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #  * \param cloud the input point cloud target
+        #  */
+        # void setInputTarget (const PointCloudTargetConstPtr &cloud);
+        # void setInputTarget (const cpp.PointCloud[Target] &cloud);
+
+
+###
+
+# pyramid_feature_matching.h
+# template <typename PointFeature>
+# class PyramidFeatureHistogram : public PCLBase<PointFeature>
+# cdef cppclass PyramidFeatureHistogram[PointFeature](PCLBase[PointFeature]):
+cdef extern from "pcl/registration/pyramid_feature_matching.h" namespace "pcl" nogil:
+    cdef cppclass PyramidFeatureHistogram[PointFeature]:
+        PyramidFeatureHistogram() except +
+        # public:
+        # using PCLBase<PointFeature>::input_;
+        # ctypedef boost::shared_ptr<PyramidFeatureHistogram<PointFeature> > Ptr;
+        # ctypedef Ptr PyramidFeatureHistogramPtr;
+        # ctypedef boost::shared_ptr<const pcl::PointRepresentation<PointFeature> > FeatureRepresentationConstPtr;
+        # /** \brief Method for setting the input dimension range parameter.
+        #  * \note Please check the PyramidHistogram class description for more details about this parameter.
+        #  */
+        # inline void setInputDimensionRange (std::vector<std::pair<float, float> > &dimension_range_input)
+        # void setInputDimensionRange (vector[pair[float, float] ] &dimension_range_input)
+        
+        # /** \brief Method for retrieving the input dimension range vector */
+        # inline std::vector<std::pair<float, float> > getInputDimensionRange () { return dimension_range_input_; }
+        # vector[pair[float, float] ] getInputDimensionRange ()
+        
+        # /** \brief Method to set the target dimension range parameter.
+        #  * \note Please check the PyramidHistogram class description for more details about this parameter.
+        #  */
+        # inline void setTargetDimensionRange (std::vector<std::pair<float, float> > &dimension_range_target)
+        void setTargetDimensionRange (vector[pair[float, float] ] &dimension_range_target)
+        
+        # /** \brief Method for retrieving the target dimension range vector */
+        # inline std::vector<std::pair<float, float> > getTargetDimensionRange () { return dimension_range_target_; }
+        vector[pair[float, float] ] getTargetDimensionRange ()
+        
+        # /** \brief Provide a pointer to the feature representation to use to convert features to k-D vectors.
+        #  * \param feature_representation the const boost shared pointer to a PointRepresentation
+        #  */
+        # inline void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation) { feature_representation_ = feature_representation; }
+        # void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation)
+        
+        # /** \brief Get a pointer to the feature representation used when converting features into k-D vectors. */
+        # inline FeatureRepresentationConstPtr const getPointRepresentation () { return feature_representation_; }
+        # FeatureRepresentationConstPtr const getPointRepresentation ()
+        
+        # /** \brief The central method for inserting the feature set inside the pyramid and obtaining the complete pyramid */
+        # void compute ();
+        void compute ()
+        
+        # /** \brief Checks whether the pyramid histogram has been computed */
+        # inline bool isComputed () { return is_computed_; }
+        bool isComputed ()
+        
+        # /** \brief Static method for comparing two pyramid histograms that returns a floating point value between 0 and 1,
+        #  * representing the similiarity between the feature sets on which the two pyramid histograms are based.
+        #  * \param pyramid_a Pointer to the first pyramid to be compared (needs to be computed already).
+        #  * \param pyramid_b Pointer to the second pyramid to be compared (needs to be computed already).
+        #  */
+        # static float comparePyramidFeatureHistograms (const PyramidFeatureHistogramPtr &pyramid_a, const PyramidFeatureHistogramPtr &pyramid_b);
+
+
+###
+
+# sample_consensus_prerejective.h
+# namespace pcl
+# /** \brief Pose estimation and alignment class using a prerejective RANSAC routine.
+#  * This class inserts a simple, yet effective "prerejection" step into the standard
+#  * RANSAC pose estimation loop in order to avoid verification of pose hypotheses
+#  * that are likely to be wrong. This is achieved by local pose-invariant geometric
+#  * constraints, as also implemented in the class
+#  * \ref registration::CorrespondenceRejectorPoly "CorrespondenceRejectorPoly".
+#  * In order to robustly align partial/occluded models, this routine performs
+#  * fit error evaluation using only inliers, i.e. points closer than a
+#  * Euclidean threshold, which is specifiable using \ref setInlierFraction().
+#  * The amount of prerejection or "greedyness" of the algorithm can be specified
+#  * using \ref setSimilarityThreshold() in [0,1[, where a value of 0 means disabled,
+#  * and 1 is maximally rejective.
+#  * If you use this in academic work, please cite:
+#  * A. G. Buch, D. Kraft, J.-K. Kamarainen, H. G. Petersen and N. Kruger.
+#  * Pose Estimation using Local Structure-Specific Shape and Appearance Context.
+#  * International Conference on Robotics and Automation (ICRA), 2013.
+#  * \author Anders Glent Buch (andersgb1@gmail.com)
+#  * \ingroup registration
+#  */
+# template <typename PointSource, typename PointTarget, typename FeatureT>
+# class SampleConsensusPrerejective : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/sample_consensus_prerejective.h" namespace "pcl" nogil:
+    cdef cppclass SampleConsensusPrerejective[Source, Target, Feature](Registration[Source, Target, float]):
+        SampleConsensusPrerejective()
+        # public:
+        # typedef typename Registration<PointSource, PointTarget>::Matrix4 Matrix4;
+        # using Registration<PointSource, PointTarget>::reg_name_;
+        # using Registration<PointSource, PointTarget>::getClassName;
+        # using Registration<PointSource, PointTarget>::input_;
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::tree_;
+        # using Registration<PointSource, PointTarget>::max_iterations_;
+        # using Registration<PointSource, PointTarget>::corr_dist_threshold_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_estimation_;
+        # using Registration<PointSource, PointTarget>::getFitnessScore;
+        # using Registration<PointSource, PointTarget>::converged_;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # typedef pcl::PointCloud<FeatureT> FeatureCloud;
+        # typedef typename FeatureCloud::Ptr FeatureCloudPtr;
+        # typedef typename FeatureCloud::ConstPtr FeatureCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusPrerejective<PointSource, PointTarget, FeatureT> > Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusPrerejective<PointSource, PointTarget, FeatureT> > ConstPtr;
+        # typedef typename KdTreeFLANN<FeatureT>::Ptr FeatureKdTreePtr;
+        # typedef pcl::registration::CorrespondenceRejectorPoly<PointSource, PointTarget> CorrespondenceRejectorPoly;
+        # typedef typename CorrespondenceRejectorPoly::Ptr CorrespondenceRejectorPolyPtr;
+        # typedef typename CorrespondenceRejectorPoly::ConstPtr CorrespondenceRejectorPolyConstPtr;
+        # 
+        # /** \brief Constructor */
+        # SampleConsensusPrerejective ()
+        #   : input_features_ ()
+        #   , target_features_ ()
+        #   , nr_samples_(3)
+        #   , k_correspondences_ (2)
+        #   , feature_tree_ (new pcl::KdTreeFLANN<FeatureT>)
+        #   , correspondence_rejector_poly_ (new CorrespondenceRejectorPoly)
+        #   , inlier_fraction_ (0.0f)
+        # 
+        # /** \brief Destructor */
+        # virtual ~SampleConsensusPrerejective ()
+        # 
+        # /** \brief Provide a boost shared pointer to the source point cloud's feature descriptors
+        #   * \param features the source point cloud's features
+        #   */
+        # void setSourceFeatures (const FeatureCloudConstPtr &features);
+        # void setSourceFeatures (const shared_ptr[cpp.PointCloud[float]] &features);
+        
+        # /** \brief Get a pointer to the source point cloud's features */
+        # inline const FeatureCloudConstPtr getSourceFeatures () const
+        # const shared_ptr[cpp.PointCloud[float]] getSourceFeatures ()
+        
+        # /** \brief Provide a boost shared pointer to the target point cloud's feature descriptors
+        #   * \param features the target point cloud's features
+        #   */
+        # void setTargetFeatures (const FeatureCloudConstPtr &features);
+        # void setTargetFeatures (const shared_ptr[cpp.PointCloud[float]] &features)
+        
+        # 
+        # /** \brief Get a pointer to the target point cloud's features */
+        # inline const FeatureCloudConstPtr getTargetFeatures () const
+        # const shared_ptr[cpp.PointCloud[float]] getTargetFeatures ()
+        
+        # /** \brief Set the number of samples to use during each iteration
+        #   * \param nr_samples the number of samples to use during each iteration
+        #   */
+        # inline void setNumberOfSamples (int nr_samples)
+        void setNumberOfSamples (int nr_samples)
+        
+        # /** \brief Get the number of samples to use during each iteration, as set by the user */
+        # inline int  getNumberOfSamples () const
+        int  getNumberOfSamples ()
+        
+        # /** \brief Set the number of neighbors to use when selecting a random feature correspondence.  A higher value will
+        #   * add more randomness to the feature matching.
+        #   * \param k the number of neighbors to use when selecting a random feature correspondence.
+        #   */
+        # inline void setCorrespondenceRandomness (int k)
+        void setCorrespondenceRandomness (int k)
+        
+        # /** \brief Get the number of neighbors used when selecting a random feature correspondence, as set by the user */
+        # inline int getCorrespondenceRandomness () const
+        int getCorrespondenceRandomness ()
+        
+        # /** \brief Set the similarity threshold in [0,1[ between edge lengths of the underlying polygonal correspondence rejector object,
+        #  * where 1 is a perfect match
+        #  * \param similarity_threshold edge length similarity threshold
+        #  */
+        # inline void setSimilarityThreshold (float similarity_threshold)
+        void setSimilarityThreshold (float similarity_threshold)
+        
+        # /** \brief Get the similarity threshold between edge lengths of the underlying polygonal correspondence rejector object,
+        #  * \return edge length similarity threshold
+        #  */
+        # inline float getSimilarityThreshold () const
+        float getSimilarityThreshold ()
+        
+        # /** \brief Set the required inlier fraction (of the input)
+        #  * \param inlier_fraction required inlier fraction, must be in [0,1]
+        #  */
+        # inline void setInlierFraction (float inlier_fraction)
+        void setInlierFraction (float inlier_fraction)
+        
+        # /** \brief Get the required inlier fraction
+        #  * \return required inlier fraction in [0,1]
+        #  */
+        # inline float getInlierFraction () const
+        float getInlierFraction ()
+        
+        # /** \brief Get the inlier indices of the source point cloud under the final transformation
+        #  * @return inlier indices
+        #  */
+        # inline const std::vector<int>& getInliers () const
+        const vector[int]& getInliers ()
+
+
+###
+
+# transformation_estimation.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimation
+cdef extern from "pcl/registration/transformation_estimation.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimation[Source, Target, float]:
+        TransformationEstimation() except +
+        # public:
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+
+
+# ctypedef shared_ptr[TransformationEstimation<PointSource, PointTarget> > Ptr;
+# ctypedef shared_ptr[const TransformationEstimation<PointSource, PointTarget> > ConstPtr;
+###
+
+# transformation_estimation_2D.h
+# namespace pcl
+# namespace registration
+# /** @b TransformationEstimation2D implements a simple 2D rigid transformation 
+#   * estimation (x, y, theta) for a given pair of datasets. 
+#   *
+#   * The two datasets should already be transformed so that the reference plane 
+#   * equals z = 0.
+#   *
+#   * \note The class is templated on the source and target point types as well as on the output scalar of the transformation matrix (i.e., float or double). Default: float.
+#   *
+#   * \author Suat Gedikli
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimation2D : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_2D.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimation2D[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimation2D() except +
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimation2D<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimation2D<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # TransformationEstimation2D () {};
+        # virtual ~TransformationEstimation2D () {};
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+
+
+###
+
+# transformation_estimation_dual_quaternion.h
+# namespace pcl
+# namespace registration
+# /** @b TransformationEstimationDualQuaternion implements dual quaternion based estimation of
+#   * the transformation aligning the given correspondences.
+#   *
+#   * \note The class is templated on the source and target point types as well as on the output scalar of the transformation matrix (i.e., float or double). Default: float.
+#   * \author Sergey Zagoruyko
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationDualQuaternion : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_dual_quaternion.h" namespace "pcl::registration" nogil:
+    cdef cppclass TransformationEstimationDualQuaternion[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationDualQuaternion() except +
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationDualQuaternion<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationDualQuaternion<PointSource, PointTarget, Scalar> > ConstPtr;
+        # 
+        # typedef typename TransformationEstimation<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # TransformationEstimationDualQuaternion () {};
+        # virtual ~TransformationEstimationDualQuaternion () {};
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+
+
+###
+
+# transformation_estimation_lm.h
+# template <typename PointSource, typename PointTarget, typename MatScalar = float>
+# class TransformationEstimationLM : public TransformationEstimation<PointSource, PointTarget, MatScalar>
+cdef extern from "pcl/registration/transformation_estimation_lm.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationLM[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationLM() except +
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationLM<PointSource, PointTarget, MatScalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationLM<PointSource, PointTarget, MatScalar> > ConstPtr;
+        # typedef Eigen::Matrix<MatScalar, Eigen::Dynamic, 1> VectorX;
+        # typedef Eigen::Matrix<MatScalar, 4, 1> Vector4;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, MatScalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Constructor. */
+        # TransformationEstimationLM ();
+        # 
+        # /** \brief Copy constructor. 
+        #   * \param[in] src the  object to copy into this 
+        #   */
+        # TransformationEstimationLM (const TransformationEstimationLM &src) : 
+        #   tmp_src_ (src.tmp_src_), 
+        #   tmp_tgt_ (src.tmp_tgt_), 
+        #   tmp_idx_src_ (src.tmp_idx_src_), 
+        #   tmp_idx_tgt_ (src.tmp_idx_tgt_), 
+        #   warp_point_ (src.warp_point_)
+        # 
+        # /** \brief Copy operator. 
+        #   * \param[in] src the TransformationEstimationLM object to copy into this 
+        #   */
+        # TransformationEstimationLM& operator = (const TransformationEstimationLM &src)
+        # 
+        #  /** \brief Destructor. */
+        # virtual ~TransformationEstimationLM () {};
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from 
+        #   * \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Set the function we use to warp points. Defaults to rigid 6D warp.
+        #   * \param[in] warp_fcn a shared pointer to an object that warps points
+        #   */
+        # void setWarpFunction (const boost::shared_ptr<WarpPointRigid<PointSource, PointTarget, MatScalar> > &warp_fcn)
+
+
+###
+
+# transformation_estimation_point_to_plane.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationPointToPlane : public TransformationEstimationLM<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlane[Source, Target, float](TransformationEstimationLM[Source, Target, float]):
+        TransformationEstimationPointToPlane ()
+        # public:
+        # ctypedef boost::shared_ptr<TransformationEstimationPointToPlane<PointSource, PointTarget> > Ptr;
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+###
+
+# transformation_estimation_point_to_plane_lls.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationEstimationPointToPlaneLLS : public TransformationEstimation<PointSource, PointTarget>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane_lls.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlaneLLS[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationPointToPlaneLLS ()
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix);
+
+###
+
+# transformation_estimation_point_to_plane_lls_weighted.h
+# namespace pcl
+# namespace registration
+# /** \brief @b TransformationEstimationPointToPlaneLLSWeighted implements a Linear Least Squares (LLS) approximation
+#   * for minimizing the point-to-plane distance between two clouds of corresponding points with normals, with the
+#   * possibility of assigning weights to the correspondences.
+#   *
+#   * For additional details, see 
+#   *   "Linear Least-Squares Optimization for Point-to-Plane ICP Surface Registration", Kok-Lim Low, 2004
+#   *
+#   * \note The class is templated on the source and target point types as well as on the output scalar of the
+#   * transformation matrix (i.e., float or double). Default: float.
+#   * \author Alex Ichim
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationPointToPlaneLLSWeighted : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane_lls_weighted.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlaneLLSWeighted[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationPointToPlaneLLS ()
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationPointToPlaneLLSWeighted<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationPointToPlaneLLSWeighted<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # TransformationEstimationPointToPlaneLLSWeighted () { };
+        # virtual ~TransformationEstimationPointToPlaneLLSWeighted () { };
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Set the weights for the correspondences.
+        #   * \param[in] weights the weights for each correspondence
+        #   */
+        # inline void setCorrespondenceWeights (const std::vector<Scalar> &weights)
+
+
+###
+
+# transformation_estimation_point_to_plane_weighted.h
+# namespace pcl
+# namespace registration
+# template <typename PointSource, typename PointTarget, typename MatScalar = float>
+# class TransformationEstimationPointToPlaneWeighted : public TransformationEstimationPointToPlane<PointSource, PointTarget, MatScalar>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane_weighted.h" namespace "pcl::registration" nogil:
+    cdef cppclass TransformationEstimationPointToPlaneWeighted[Source, Target, float](TransformationEstimationPointToPlane[Source, Target, float]):
+        TransformationEstimationPointToPlaneWeighted ()
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationPointToPlaneWeighted<PointSource, PointTarget, MatScalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationPointToPlaneWeighted<PointSource, PointTarget, MatScalar> > ConstPtr;
+        # typedef Eigen::Matrix<MatScalar, Eigen::Dynamic, 1> VectorX;
+        # typedef Eigen::Matrix<MatScalar, 4, 1> Vector4;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, MatScalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Constructor. */
+        # TransformationEstimationPointToPlaneWeighted ();
+        # 
+        # /** \brief Copy constructor. 
+        #   * \param[in] src the TransformationEstimationPointToPlaneWeighted object to copy into this
+        #   */
+        # TransformationEstimationPointToPlaneWeighted (const TransformationEstimationPointToPlaneWeighted &src) :
+        #   tmp_src_ (src.tmp_src_), 
+        #   tmp_tgt_ (src.tmp_tgt_), 
+        #   tmp_idx_src_ (src.tmp_idx_src_), 
+        #   tmp_idx_tgt_ (src.tmp_idx_tgt_), 
+        #   warp_point_ (src.warp_point_),
+        #   correspondence_weights_ (src.correspondence_weights_),
+        #   use_correspondence_weights_ (src.use_correspondence_weights_)
+        # {};
+        # 
+        # /** \brief Copy operator. 
+        #   * \param[in] src the TransformationEstimationPointToPlaneWeighted object to copy into this
+        #   */
+        # TransformationEstimationPointToPlaneWeighted&
+        # operator = (const TransformationEstimationPointToPlaneWeighted &src)
+        # {
+        #   tmp_src_ = src.tmp_src_; 
+        #   tmp_tgt_ = src.tmp_tgt_; 
+        #   tmp_idx_src_ = src.tmp_idx_src_;
+        #   tmp_idx_tgt_ = src.tmp_idx_tgt_; 
+        #   warp_point_ = src.warp_point_;
+        #   correspondence_weights_ = src.correspondence_weights_;
+        #   use_correspondence_weights_ = src.use_correspondence_weights_;
+        # }
+        # 
+        #  /** \brief Destructor. */
+        # virtual ~TransformationEstimationPointToPlaneWeighted () {};
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from 
+        #   * \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;  
+        # 
+        # inline void setWeights (const std::vector<double> &weights)
+        # 
+        # /// use the weights given in the pcl::CorrespondencesPtr for one of the estimateTransformation (...) methods
+        # inline void setUseCorrespondenceWeights (bool use_correspondence_weights)
+        # 
+        # /** \brief Set the function we use to warp points. Defaults to rigid 6D warp.
+        #   * \param[in] warp_fcn a shared pointer to an object that warps points
+        #   */
+        # void setWarpFunction (const boost::shared_ptr<WarpPointRigid<PointSource, PointTarget, MatScalar> > &warp_fcn)
+
+
+###
+
+# transformation_estimation_svd.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationSVD : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_svd.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationSVD[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationSVD ()
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # protected:
+        # /** \brief Obtain a 4x4 rigid transformation matrix from a correlation matrix H = src * tgt'
+        #   * \param[in] cloud_src_demean the input source cloud, demeaned, in Eigen format
+        #   * \param[in] centroid_src the input source centroid, in Eigen format
+        #   * \param[in] cloud_tgt_demean the input target cloud, demeaned, in Eigen format
+        #   * \param[in] centroid_tgt the input target cloud, in Eigen format
+        #   * \param[out] transformation_matrix the resultant 4x4 rigid transformation matrix
+        #   */ 
+        # void
+        # getTransformationFromCorrelation (const Eigen::MatrixXf &cloud_src_demean,
+        #                                   const Eigen::Vector4f &centroid_src,
+        #                                   const Eigen::MatrixXf &cloud_tgt_demean,
+        #                                   const Eigen::Vector4f &centroid_tgt,
+        #                                   Eigen::Matrix4f &transformation_matrix);
+###
+
+# transformation_estimation_svd_scale.h
+# namespace pcl
+# namespace registration
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationSVDScale : public TransformationEstimationSVD<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_svd_scale.h" namespace "pcl::registration" nogil:
+    cdef cppclass TransformationEstimationSVDScale[Source, Target, float](TransformationEstimationSVD[Source, Target, float]):
+        TransformationEstimationSVDScale ()
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationSVDScale<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationSVDScale<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename TransformationEstimationSVD<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Inherits from TransformationEstimationSVD, but forces it to not use the Umeyama method */
+        # TransformationEstimationSVDScale ():
+        # TransformationEstimationSVD<PointSource, PointTarget, Scalar> (false)
+
+
+###
+
+# transformation_validation.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationValidation
+cdef extern from "pcl/registration/transformation_validation.h" namespace "pcl" nogil:
+    cdef cppclass TransformationValidation[Source, Target, float]:
+        TransformationValidation ()
+        # public:
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # ctypedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # /** \brief Validate the given transformation with respect to the input cloud data, and return a score.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \return the score or confidence measure for the given
+        #   * transformation_matrix with respect to the input data
+        #   */
+        # virtual double validateTransformation (
+        #    const cpp.PointCloudPtr_t &cloud_src,
+        #    const cpp.PointCloudPtr_t &cloud_tgt,
+        #    const Matrix4f &transformation_matrix) = 0;
+        # 
+        # ctypedef shared_ptr[TransformationValidation[PointSource, PointTarget] ] Ptr;
+        # ctypedef shared_ptr[const TransformationValidation[PointSource, PointTarget] ] ConstPtr;
+
+
+###
+
+# transformation_validation_euclidean.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationValidationEuclidean
+cdef extern from "pcl/registration/transformation_validation_euclidean.h" namespace "pcl" nogil:
+    cdef cppclass TransformationValidationEuclidean[Source, Target, float]:
+        TransformationValidationEuclidean ()
+        # public:
+        # ctypedef boost::shared_ptr<TransformationValidation<PointSource, PointTarget> > Ptr;
+        # ctypedef boost::shared_ptr<const TransformationValidation<PointSource, PointTarget> > ConstPtr;
+        # ctypedef typename pcl::KdTree<PointTarget> KdTree;
+        # ctypedef typename pcl::KdTree<PointTarget>::Ptr KdTreePtr;
+        # ctypedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # ctypedef typename TransformationValidation<PointSource, PointTarget>::PointCloudSourceConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename TransformationValidation<PointSource, PointTarget>::PointCloudTargetConstPtr PointCloudTargetConstPtr;
+        inline void setMaxRange (double max_range)
+        # double validateTransformation (const cpp.PointCloudPtr_t &cloud_src, const cpp.PointCloudPtr_t &cloud_tgt, const Matrix4f &transformation_matrix)
+
+
+###
+
+# transforms.h
+# common/transforms.h
+###
+
+# warp_point_rigid_3d.h
+# template <class PointSourceT, class PointTargetT>
+# class WarpPointRigid3D : public WarpPointRigid<PointSourceT, PointTargetT>
+cdef extern from "pcl/registration/warp_point_rigid_3d.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid3D[Source, Target, float](WarpPointRigid[Source, Target, float]):
+        WarpPointRigid3D ()
+        # public:
+        # virtual void setParam (const Eigen::VectorXf & p)
+
+
+###
+
+# warp_point_rigid_6d.h
+# template <class PointSourceT, class PointTargetT>
+# class WarpPointRigid6D : public WarpPointRigid<PointSourceT, PointTargetT>
+cdef extern from "pcl/registration/warp_point_rigid_6d.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid6D[Source, Target, float](WarpPointRigid[Source, Target, float]):
+        WarpPointRigid6D ()
+        # public:
+        # virtual void setParam (const Eigen::VectorXf & p)
+
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# bfgs.h
+# template<typename _Scalar, int NX=Eigen::Dynamic>
+# struct BFGSDummyFunctor
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+#     # cdef struct BFGSDummyFunctor[_Scalar, NX]:
+#         # enum { InputsAtCompileTime = NX };
+# 
+# cdef extern from "pcl/registration/bfgs.h" namespace "pcl":
+#     ctypedef enum "pcl::BFGSDummyFunctor":
+#             INPUTSATCOMPILETIME "pcl::BFGSDummyFunctor::InputsAtCompileTime"
+# 
+###
+
+# bfgs.h
+# namespace BFGSSpace {
+#   enum Status {
+#     NegativeGradientEpsilon = -3,
+#     NotStarted = -2,
+#     Running = -1,
+#     Success = 0,
+#     NoProgress = 1
+#   };
+# }
+cdef extern from "pcl/registration/bfgs.h" namespace "pcl":
+    cdef enum Status:
+        NegativeGradientEpsilon = -3
+        NotStarted = -2
+        Running = -1
+        Success = 0
+        NoProgress = 1
+
+# /** Base functor all the models that need non linear optimization must
+#   * define their own one and implement operator() (const Eigen::VectorXd& x, Eigen::VectorXd& fvec)
+#   * or operator() (const Eigen::VectorXf& x, Eigen::VectorXf& fvec) dependening on the choosen _Scalar
+#   */
+# template<typename _Scalar, int NX=Eigen::Dynamic, int NY=Eigen::Dynamic>
+# struct Functor
+# {
+#   typedef _Scalar Scalar;
+#   enum 
+#   {
+#     InputsAtCompileTime = NX,
+#     ValuesAtCompileTime = NY
+#   };
+#   typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> InputType;
+#   typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,1> ValueType;
+#   typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,InputsAtCompileTime> JacobianType;
+# 
+#   /** \brief Empty Construtor. */
+#   Functor () : m_data_points_ (ValuesAtCompileTime) {}
+#   /** \brief Constructor
+#     * \param[in] m_data_points number of data points to evaluate.
+#     */
+#   Functor (int m_data_points) : m_data_points_ (m_data_points) {}
+# 
+#   /** \brief Destructor. */
+#   virtual ~Functor () {}
+# 
+#   /** \brief Get the number of values. */ 
+#   int
+#   values () const { return (m_data_points_); }
+# 
+#   protected:
+#     int m_data_points_;
+# };
+
+#####
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_registration_180.pxd b/pcl/pcl_registration_180.pxd
new file mode 100644
index 0000000..3e0d0d7
--- /dev/null
+++ b/pcl/pcl_registration_180.pxd
@@ -0,0 +1,4413 @@
+# -*- coding: utf-8 -*-
+
+from libcpp cimport bool
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libcpp.pair cimport pair
+
+# main
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+# base
+from eigen cimport Matrix4f
+
+# registration.h
+# /** \brief @b Registration represents the base registration class for general purpose, ICP-like methods.
+#  * \author Radu B. Rusu, Michael Dixon
+#  * \ingroup registration
+#  */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class Registration : public PCLBase<PointSource>
+cdef extern from "pcl/registration/registration.h" namespace "pcl" nogil:
+    cdef cppclass Registration[Source, Target, float](cpp.PCLBase[Source]):
+        Registration()
+        # public:
+        # /** \brief Provide a pointer to the transformation estimation object.
+        #   * (e.g., SVD, point to plane etc.) 
+        #   * \param[in] te is the pointer to the corresponding transformation estimation object
+        #   * Code example:
+        #   * \code
+        #   * TransformationEstimationPointToPlaneLLS<PointXYZ, PointXYZ>::Ptr trans_lls (new TransformationEstimationPointToPlaneLLS<PointXYZ, PointXYZ>);
+        #   * icp.setTransformationEstimation (trans_lls);
+        #   * // or...
+        #   * TransformationEstimationSVD<PointXYZ, PointXYZ>::Ptr trans_svd (new TransformationEstimationSVD<PointXYZ, PointXYZ>);
+        #   * icp.setTransformationEstimation (trans_svd);
+        #   * \endcode
+        #   */
+        # void setTransformationEstimation (const TransformationEstimationPtr &te)
+        
+        # /** \brief Provide a pointer to the correspondence estimation object.
+        #   * (e.g., regular, reciprocal, normal shooting etc.) 
+        #   * \param[in] ce is the pointer to the corresponding correspondence estimation object
+        #   * Code example:
+        #   * \code
+        #   * CorrespondenceEstimation<PointXYZ, PointXYZ>::Ptr ce (new CorrespondenceEstimation<PointXYZ, PointXYZ>);
+        #   * ce->setInputSource (source);
+        #   * ce->setInputTarget (target);
+        #   * icp.setCorrespondenceEstimation (ce);
+        #   * // or...
+        #   * CorrespondenceEstimationNormalShooting<PointNormal, PointNormal, PointNormal>::Ptr cens (new CorrespondenceEstimationNormalShooting<PointNormal, PointNormal>);
+        #   * ce->setInputSource (source);
+        #   * ce->setInputTarget (target);
+        #   * ce->setSourceNormals (source);
+        #   * ce->setTargetNormals (target);
+        #   * icp.setCorrespondenceEstimation (cens);
+        #   * \endcode
+        #   */
+        # void setCorrespondenceEstimation (const CorrespondenceEstimationPtr &ce)
+        
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # PCL_DEPRECATED ("[pcl::registration::Registration::setInputCloud] setInputCloud is deprecated. Please use setInputSource instead.")
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud);
+        void setInputCloud(cpp.PointCloudPtr_t ptcloud) except +
+        
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # PCL_DEPRECATED ("[pcl::registration::Registration::getInputCloud] getInputCloud is deprecated. Please use getInputSource instead.")
+        # PointCloudSourceConstPtr const getInputCloud ();
+        
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        # virtual void setInputSource (const PointCloudSourceConstPtr &cloud)
+        void setInputSource(cpp.PointCloudPtr_t) except +
+        # void setInputSource(cpp.PointCloudPtr2_t pt2cloud) except +
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudSourceConstPtr const getInputSource ()
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # virtual inline void setInputTarget (const PointCloudTargetConstPtr &cloud); 
+        void setInputTarget(cpp.PointCloudPtr_t)
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudTargetConstPtr const getInputTarget ()
+        cpp.PointCloudPtr_t getInputTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the target cloud.
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputTarget. Only use if you are 
+        #   * confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute = false) 
+        # void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute) 
+        
+        # /** \brief Get a pointer to the search method used to find correspondences in the
+        #   * target cloud. */
+        # inline KdTreePtr getSearchMethodTarget () const
+        # KdTreePtr getSearchMethodTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the source cloud (usually used by reciprocal correspondence finding).
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputSource. Only use if you are 
+        #   * extremely confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodSource (const KdTreeReciprocalPtr &tree, bool force_no_recompute = false) 
+        # 
+        # /** \brief Get a pointer to the search method used to find correspondences in the
+        #   * source cloud. */
+        # inline KdTreeReciprocalPtr getSearchMethodSource () const
+        # 
+        # /** \brief Get the final transformation matrix estimated by the registration method. */
+        # inline Matrix4 getFinalTransformation ()
+        Matrix4f getFinalTransformation ()
+        
+        # /** \brief Get the last incremental transformation matrix estimated by the registration method. */
+        Matrix4f getLastIncrementalTransformation ()
+        
+        # Set the maximum number of iterations the internal optimization should run for.
+        # param nr_iterations the maximum number of iterations the internal optimization should run for
+        void setMaximumIterations (int nr_iterations) except +
+        
+        # /** \brief Get the maximum number of iterations the internal optimization should run for, as set by the user. */
+        int getMaximumIterations () 
+        
+        # /** \brief Set the number of iterations RANSAC should run for.
+        #   * \param[in] ransac_iterations is the number of iterations RANSAC should run for
+        #   */
+        void setRANSACIterations (int ransac_iterations)
+        
+        # /** \brief Get the number of iterations RANSAC should run for, as set by the user. */
+        # inline double getRANSACIterations ()
+        double getRANSACIterations ()
+        
+        # /** \brief Set the inlier distance threshold for the internal RANSAC outlier rejection loop.
+        #   * The method considers a point to be an inlier, if the distance between the target data index and the transformed 
+        #   * source index is smaller than the given inlier distance threshold. 
+        #   * The value is set by default to 0.05m.
+        #   * \param[in] inlier_threshold the inlier distance threshold for the internal RANSAC outlier rejection loop
+        #   */
+        # inline void setRANSACOutlierRejectionThreshold (double inlier_threshold) { inlier_threshold_ = inlier_threshold; }
+        void setRANSACOutlierRejectionThreshold (double inlier_threshold)
+        
+        # /** \brief Get the inlier distance threshold for the internal outlier rejection loop as set by the user. */
+        # inline double getRANSACOutlierRejectionThreshold ()
+        double getRANSACOutlierRejectionThreshold ()
+        
+        # /** \brief Set the maximum distance threshold between two correspondent points in source <-> target. If the 
+        #   * distance is larger than this threshold, the points will be ignored in the alignment process.
+        #   * \param[in] distance_threshold the maximum distance threshold between a point and its nearest neighbor 
+        #   * correspondent in order to be considered in the alignment process
+        #   */
+        # inline void setMaxCorrespondenceDistance (double distance_threshold)
+        void setMaxCorrespondenceDistance (double distance_threshold)
+        
+        # /** \brief Get the maximum distance threshold between two correspondent points in source <-> target. If the 
+        #   * distance is larger than this threshold, the points will be ignored in the alignment process.
+        #   */
+        # inline double getMaxCorrespondenceDistance ()
+        double getMaxCorrespondenceDistance ()
+        
+        # /** \brief Set the transformation epsilon (maximum allowable difference between two consecutive 
+        #   * transformations) in order for an optimization to be considered as having converged to the final 
+        #   * solution.
+        #   * \param[in] epsilon the transformation epsilon in order for an optimization to be considered as having 
+        #   * converged to the final solution.
+        #   */
+        # inline void setTransformationEpsilon (double epsilon)
+        void setTransformationEpsilon (double epsilon)
+        
+        # /** \brief Get the transformation epsilon (maximum allowable difference between two consecutive 
+        #   * transformations) as set by the user.
+        #   */
+        # inline double getTransformationEpsilon ()
+        double getTransformationEpsilon ()
+        
+        # /** \brief Set the maximum allowed Euclidean error between two consecutive steps in the ICP loop, before 
+        #   * the algorithm is considered to have converged. 
+        #   * The error is estimated as the sum of the differences between correspondences in an Euclidean sense, 
+        #   * divided by the number of correspondences.
+        #   * \param[in] epsilon the maximum allowed distance error before the algorithm will be considered to have
+        #   * converged
+        #   */
+        # inline void setEuclideanFitnessEpsilon (double epsilon)
+        void setEuclideanFitnessEpsilon (double epsilon)
+        
+        # /** \brief Get the maximum allowed distance error before the algorithm will be considered to have converged,
+        #   * as set by the user. See \ref setEuclideanFitnessEpsilon
+        #   */
+        # inline double getEuclideanFitnessEpsilon ()
+        double getEuclideanFitnessEpsilon ()
+        
+        # 
+        # /** \brief Provide a boost shared pointer to the PointRepresentation to be used when comparing points
+        #   * \param[in] point_representation the PointRepresentation to be used by the k-D tree
+        #   */
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # 
+        # /** \brief Register the user callback function which will be called from registration thread
+        #  * in order to update point cloud obtained after each iteration
+        #  * \param[in] visualizerCallback reference of the user callback function
+        #  */
+        # template<typename FunctionSignature> inline bool registerVisualizationCallback (boost::function<FunctionSignature> &visualizerCallback)
+        
+        # /** \brief Obtain the Euclidean fitness score (e.g., sum of squared distances from the source to the target)
+        #   * \param[in] max_range maximum allowable distance between a point and its correspondence in the target 
+        #   * (default: double::max)
+        #   */
+        # double getFitnessScore (double max_range = numeric_limits[double]::max ());
+        # double getFitnessScore (double max_range)
+        double getFitnessScore()
+        
+        # /** \brief Obtain the Euclidean fitness score (e.g., sum of squared distances from the source to the target)
+        #   * from two sets of correspondence distances (distances between source and target points)
+        #   * \param[in] distances_a the first set of distances between correspondences
+        #   * \param[in] distances_b the second set of distances between correspondences
+        #   */
+        # inline double getFitnessScore (const std::vector<float> &distances_a, const std::vector<float> &distances_b);
+        double getFitnessScore (const vector[float] &distances_a, const vector[float] &distances_b)
+        
+        # /** \brief Return the state of convergence after the last align run */
+        # inline bool hasConverged ()
+        bool hasConverged ()
+        
+        # /** \brief Call the registration algorithm which estimates the transformation and returns the transformed source 
+        #   * (input) as \a output.
+        #   * \param[out] output the resultant input transfomed point cloud dataset
+        #   */
+        # inline void align (PointCloudSource &output);
+        void align(cpp.PointCloud[Source] &) except +
+        
+        # /** \brief Call the registration algorithm which estimates the transformation and returns the transformed source 
+        #   * (input) as \a output.
+        #   * \param[out] output the resultant input transfomed point cloud dataset
+        #   * \param[in] guess the initial gross estimation of the transformation
+        #   */
+        # inline void align (PointCloudSource &output, const Matrix4f& guess);
+        void align (cpp.PointCloud[Source] &output, const Matrix4f& guess)
+        
+        # /** \brief Abstract class get name method. */
+        # inxline const std::string& getClassName () const
+        string& getClassName ()
+        
+        # /** \brief Internal computation initalization. */
+        # bool initCompute ();
+        bool initCompute ()
+        
+        # /** \brief Internal computation when reciprocal lookup is needed */
+        # bool initComputeReciprocal ();
+        bool initComputeReciprocal ()
+        
+        # /** \brief Add a new correspondence rejector to the list
+        #   * \param[in] rejector the new correspondence rejector to concatenate
+        # inline void addCorrespondenceRejector (const CorrespondenceRejectorPtr &rejector)
+        # void addCorrespondenceRejector (const CorrespondenceRejectorPtr &rejector)
+        
+        # /** \brief Get the list of correspondence rejectors. */
+        # inline std::vector<CorrespondenceRejectorPtr> getCorrespondenceRejectors ()
+        # vector[CorrespondenceRejectorPtr] getCorrespondenceRejectors ()
+        
+        # /** \brief Remove the i-th correspondence rejector in the list
+        #   * \param[in] i the position of the correspondence rejector in the list to remove
+        # inline bool removeCorrespondenceRejector (unsigned int i)
+        bool removeCorrespondenceRejector (unsigned int i)
+        
+        # /** \brief Clear the list of correspondence rejectors. */
+        # inline void clearCorrespondenceRejectors ()
+        void clearCorrespondenceRejectors ()
+
+
+###
+
+# warp_point_rigid.h
+# template <typename PointSourceT, typename PointTargetT, typename Scalar = float>
+# class WarpPointRigid
+cdef extern from "pcl/registration/warp_point_rigid.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid[Source, Target, float]:
+        WarpPointRigid (int nr_dim)
+        # public:
+        # virtual void setParam (const Eigen::VectorXf& p) = 0;
+        # void warpPoint (const PointSourceT& pnt_in, PointSourceT& pnt_out) const
+        # int getDimension () const {return nr_dim_;}
+        # const Eigen::Matrix4f& getTransform () const { return transform_matrix_; }
+
+
+###
+
+# correspondence_rejection.h
+# class CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejector:
+        CorrespondenceRejector()
+        # /** \brief Provide a pointer to the vector of the input correspondences.
+        #   * \param[in] correspondences the const boost shared pointer to a correspondence vector
+        #   */
+        # virtual inline void setInputCorrespondences (const CorrespondencesConstPtr &correspondences) 
+        
+        # /** \brief Get a pointer to the vector of the input correspondences.
+        #   * \return correspondences the const boost shared pointer to a correspondence vector
+        #   */
+        # inline CorrespondencesConstPtr getInputCorrespondences ()
+        # CorrespondencesConstPtr getInputCorrespondences ()
+        
+        # /** \brief Run correspondence rejection
+        #   * \param[out] correspondences Vector of correspondences that have not been rejected.
+        #   */
+        # inline void getCorrespondences (pcl::Correspondences &correspondences)
+        # void getCorrespondences (pcl::Correspondences &correspondences)
+        
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * Pure virtual. Compared to \a getCorrespondences this function is
+        #   * stateless, i.e., input correspondences do not need to be provided beforehand,
+        #   * but are directly provided in the function call.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # virtual inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences) = 0;
+        
+        # /** \brief Determine the indices of query points of
+        #   * correspondences that have been rejected, i.e., the difference
+        #   * between the input correspondences (set via \a setInputCorrespondences)
+        #   * and the given correspondence vector.
+        #   * \param[in] correspondences Vector of correspondences after rejection
+        #   * \param[out] indices Vector of query point indices of those correspondences
+        #   * that have been rejected.
+        #   */
+        # inline void getRejectedQueryIndices (const pcl::Correspondences &correspondences, std::vector<int>& indices)
+        # void getRejectedQueryIndices (const pcl::Correspondences &correspondences, vector[int]& indices)
+        
+        # /** @b DataContainerInterface provides a generic interface for computing correspondence scores between correspondent
+        # * points in the input and target clouds
+        # * \ingroup registration
+        # */
+        # class DataContainerInterface
+        # {
+        #   public:
+        #       virtual ~DataContainerInterface () {}
+        #       virtual double getCorrespondenceScore (int index) = 0;
+        #       virtual double getCorrespondenceScore (const pcl::Correspondence &) = 0;
+        # };
+        
+        # /** @b DataContainer is a container for the input and target point clouds and implements the interface 
+        #  * to compute correspondence scores between correspondent points in the input and target clouds
+        #  * \ingroup registration
+        #  */
+        # template <typename PointT, typename NormalT=pcl::PointNormal>
+        # class DataContainer : public DataContainerInterface
+        # {
+        #   typedef typename pcl::PointCloud<PointT>::ConstPtr PointCloudConstPtr;
+        #   typedef typename pcl::KdTree<PointT>::Ptr KdTreePtr;
+        #   typedef typename pcl::PointCloud<NormalT>::ConstPtr NormalsPtr;
+        #   public:
+        #   /** \brief Empty constructor. */
+        #   DataContainer ()
+        #   
+        #   /** \brief Provide a source point cloud dataset (must contain XYZ
+        #    * data!), used to compute the correspondence distance.  
+        #    * \param[in] cloud a cloud containing XYZ data
+        #    */
+        #   inline void setInputCloud (const PointCloudConstPtr &cloud)
+        #   
+        #   /** \brief Provide a target point cloud dataset (must contain XYZ
+        #    * data!), used to compute the correspondence distance.  
+        #    * \param[in] target a cloud containing XYZ data
+        #    */
+        #   inline void setInputTarget (const PointCloudConstPtr &target)
+        #   
+        #   /** \brief Set the normals computed on the input point cloud
+        #    * \param[in] normals the normals computed for the input cloud
+        #    */
+        #   inline void setInputNormals (const NormalsPtr &normals)
+        # 
+        #   /** \brief Set the normals computed on the target point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        #   */
+        #   inline void setTargetNormals (const NormalsPtr &normals)
+        # 
+        #   /** \brief Get the normals computed on the input point cloud */
+        #   inline NormalsPtr getInputNormals ()
+        # 
+        #   /** \brief Get the normals computed on the target point cloud */
+        #   inline NormalsPtr getTargetNormals ()
+        # 
+        #   /** \brief Get the correspondence score for a point in the input cloud
+        #    *  \param[index] index of the point in the input cloud
+        #    */
+        #   inline double getCorrespondenceScore (int index)
+        # 
+        #   /** \brief Get the correspondence score for a given pair of correspondent points
+        #    *  \param[corr] Correspondent points
+        #    */
+        #   inline double getCorrespondenceScore (const pcl::Correspondence &corr)
+        # 
+        #   /** \brief Get the correspondence score for a given pair of correspondent points based on 
+        #    * the angle betweeen the normals. The normmals for the in put and target clouds must be 
+        #    * set before using this function
+        #    * \param[in] corr Correspondent points
+        #    */
+        #   double getCorrespondenceScoreFromNormals (const pcl::Correspondence &corr)
+        # };
+
+
+###
+
+# correspondence_estimation.h
+# /** \brief Abstract @b CorrespondenceEstimationBase class. 
+#   * All correspondence estimation methods should inherit from this.
+#   * \author Radu B. Rusu
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class CorrespondenceEstimationBase: public PCLBase<PointSource>
+cdef extern from "pcl/registration/correspondence_estimation.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationBase[Source, Target, float](cpp.PCLBase[Source]):
+        CorrespondenceEstimationBase()
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > ConstPtr;
+        # // using PCLBase<PointSource>::initCompute;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using PCLBase<PointSource>::setIndices;
+        # typedef pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::search::KdTree<PointSource> KdTreeReciprocal;
+        # typedef typename KdTree::Ptr KdTreeReciprocalPtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # 
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # PCL_DEPRECATED ("[pcl::registration::CorrespondenceEstimationBase::setInputCloud] setInputCloud is deprecated. Please use setInputSource instead.")
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud);
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud)
+        
+        # 
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # PCL_DEPRECATED ("[pcl::registration::CorrespondenceEstimationBase::getInputCloud] getInputCloud is deprecated. Please use getInputSource instead.")
+        # PointCloudSourceConstPtr const getInputCloud ();
+        # PointCloudSourceConstPtr const getInputCloud ()
+        
+        # 
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # inline void setInputSource (const PointCloudSourceConstPtr &cloud)
+        # void setInputSource (const PointCloudSourceConstPtr &cloud)
+        
+        # 
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudSourceConstPtr const getInputSource () 
+        # PointCloudSourceConstPtr const getInputSource () 
+        
+        # /** \brief Provide a pointer to the input target 
+        #   * (e.g., the point cloud that we want to align the input source to)
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &cloud);
+        # void setInputTarget (const PointCloudTargetConstPtr &cloud)
+        
+        # /** \brief Get a pointer to the input point cloud dataset target. */
+        # inline PointCloudTargetConstPtr const getInputTarget () { return (target_ ); }
+        # PointCloudTargetConstPtr const getInputTarget ()
+        
+        # /** \brief See if this rejector requires source normals */
+        # virtual bool requiresSourceNormals () const
+        # 
+        # /** \brief Abstract method for setting the source normals */
+        # virtual void setSourceNormals (pcl::PCLPointCloud2::ConstPtr /*cloud2*/)
+        # 
+        # /** \brief See if this rejector requires target normals */
+        # virtual bool requiresTargetNormals () const
+        # 
+        # /** \brief Abstract method for setting the target normals */
+        # virtual void setTargetNormals (pcl::PCLPointCloud2::ConstPtr /*cloud2*/)
+        # 
+        # /** \brief Provide a pointer to the vector of indices that represent the 
+        #   * input source point cloud.
+        #   * \param[in] indices a pointer to the vector of indices 
+        #   */
+        # inline void setIndicesSource (const IndicesPtr &indices)
+        # void setIndicesSource (const IndicesPtr &indices)
+        
+        # /** \brief Get a pointer to the vector of indices used for the source dataset. */
+        # inline IndicesPtr const getIndicesSource () { return (indices_); }
+        # IndicesPtr const getIndicesSource ()
+        
+        # 
+        # /** \brief Provide a pointer to the vector of indices that represent the input target point cloud.
+        #   * \param[in] indices a pointer to the vector of indices 
+        #   */
+        # inline void setIndicesTarget (const IndicesPtr &indices)
+        # void setIndicesTarget (const IndicesPtr &indices)
+        
+        # /** \brief Get a pointer to the vector of indices used for the target dataset. */
+        # inline IndicesPtr const getIndicesTarget () { return (target_indices_); }
+        # IndicesPtr const getIndicesTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the target cloud.
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputTarget. Only use if you are 
+        #   * confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute = false) 
+        # void setSearchMethodTarget (const KdTreePtr &tree, bool force_no_recompute = false) 
+        
+        # /** \brief Get a pointer to the search method used to find correspondences in the target cloud. */
+        # inline KdTreePtr getSearchMethodTarget () const
+        # KdTreePtr getSearchMethodTarget ()
+        
+        # /** \brief Provide a pointer to the search object used to find correspondences in
+        #   * the source cloud (usually used by reciprocal correspondence finding).
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   * \param[in] force_no_recompute If set to true, this tree will NEVER be 
+        #   * recomputed, regardless of calls to setInputSource. Only use if you are 
+        #   * extremely confident that the tree will be set correctly.
+        #   */
+        # inline void setSearchMethodSource (const KdTreeReciprocalPtr &tree, bool force_no_recompute = false) 
+        # void setSearchMethodSource (const KdTreeReciprocalPtr &tree, bool force_no_recompute = false)
+        
+        # /** \brief Get a pointer to the search method used to find correspondences in the source cloud. */
+        # inline KdTreeReciprocalPtr getSearchMethodSource () const
+        # KdTreeReciprocalPtr getSearchMethodSource ()
+        
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ()) = 0;
+        # 
+        # /** \brief Determine the reciprocal correspondences between input and target cloud.
+        #   * A correspondence is considered reciprocal if both Src_i has Tgt_i as a 
+        #   * correspondence, and Tgt_i has Src_i as one.
+        #   * \param[out] correspondences the found correspondences (index of query and target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineReciprocalCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ()) = 0;
+        # 
+        # /** \brief Provide a boost shared pointer to the PointRepresentation to be used when searching for nearest neighbors.
+        #   * \param[in] point_representation the PointRepresentation to be used by the 
+        #   * k-D tree for nearest neighbor search
+        #   */
+        # inline void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const = 0;
+
+
+###
+
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class CorrespondenceEstimation : public CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/correspondence_estimation.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimation[Source, Target, float](CorrespondenceEstimationBase[Source, Target, float]):
+        CorrespondenceEstimation()
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceEstimation<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceEstimation<PointSource, PointTarget, Scalar> > ConstPtr;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::point_representation_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_transformed_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::tree_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::tree_reciprocal_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::corr_name_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::getClassName;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initCompute;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initComputeReciprocal;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_fields_;
+        # using PCLBase<PointSource>::deinitCompute;
+        # 
+        # typedef pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::search::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~CorrespondenceEstimation () {}
+        # 
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # 
+        # /** \brief Determine the reciprocal correspondences between input and target cloud.
+        #   * A correspondence is considered reciprocal if both Src_i has Tgt_i as a 
+        #   * correspondence, and Tgt_i has Src_i as one.
+        #   *
+        #   * \param[out] correspondences the found correspondences (index of query and target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineReciprocalCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # 
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const
+
+
+###
+
+### Inheritance ###
+
+# icp.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class IterativeClosestPoint : public Registration<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/icp.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPoint[Source, Target, Scalar](Registration[Source, Target, Scalar]):
+        IterativeClosestPoint() except +
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+        
+        # /** \brief Returns a pointer to the DefaultConvergenceCriteria used by the IterativeClosestPoint class.
+        #   * This allows to check the convergence state after the align() method as well as to configure
+        #   * DefaultConvergenceCriteria's parameters not available through the ICP API before the align()
+        #   * method is called. Please note that the align method sets max_iterations_,
+        #   * euclidean_fitness_epsilon_ and transformation_epsilon_ and therefore overrides the default / set
+        #   * values of the DefaultConvergenceCriteria instance.
+        #   * \return Pointer to the IterativeClosestPoint's DefaultConvergenceCriteria.
+        #   */
+        # inline typename pcl::registration::DefaultConvergenceCriteria<Scalar>::Ptr getConvergeCriteria ()
+        # 
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud source
+        #   */
+        # virtual void setInputSource (const PointCloudSourceConstPtr &cloud)
+        # 
+        # /** \brief Provide a pointer to the input target 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # virtual void setInputTarget (const PointCloudTargetConstPtr &cloud)
+        # 
+        # /** \brief Set whether to use reciprocal correspondence or not
+        #   * \param[in] use_reciprocal_correspondence whether to use reciprocal correspondence or not
+        #   */
+        # inline void setUseReciprocalCorrespondences (bool use_reciprocal_correspondence)
+        # 
+        # /** \brief Obtain whether reciprocal correspondence are used or not */
+        # inline bool getUseReciprocalCorrespondences () const
+
+
+ctypedef IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPoint_t
+ctypedef IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPoint_PointXYZI_t
+ctypedef IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPoint_PointXYZRGB_t
+ctypedef IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPoint_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointPtr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPoint_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPoint_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPoint_PointXYZRGBA_Ptr_t
+###
+
+# /** \brief @b IterativeClosestPointWithNormals is a special case of
+#  * IterativeClosestPoint, that uses a transformation estimated based on
+#  * Point to Plane distances by default.
+#  *
+#  * \author Radu B. Rusu
+#  * \ingroup registration
+#  */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class IterativeClosestPointWithNormals : public IterativeClosestPoint<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/icp.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPointWithNormals[Source, Target, Scalar](IterativeClosestPoint[Source, Target, Scalar]):
+        IterativeClosestPointWithNormals() except +
+        # public:
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudSource PointCloudSource;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudTarget PointCloudTarget;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::reg_name_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_estimation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondence_rejectors_;
+        # typedef boost::shared_ptr<IterativeClosestPoint<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const IterativeClosestPoint<PointSource, PointTarget, Scalar> > ConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # IterativeClosestPointWithNormals () 
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~IterativeClosestPointWithNormals () {}
+
+
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointWithNormals_t
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointWithNormals_PointXYZI_t
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointWithNormals_PointXYZRGB_t
+ctypedef IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointWithNormals_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointWithNormalsPtr_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointWithNormals_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointWithNormals_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointWithNormals[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointWithNormals_PointXYZRGBA_Ptr_t
+###
+
+# gicp.h
+# Version 1.7.2
+# namespace pcl
+# /** \brief GeneralizedIterativeClosestPoint is an ICP variant that implements the 
+#   * generalized iterative closest point algorithm as described by Alex Segal et al. in 
+#   * http://www.stanford.edu/~avsegal/resources/papers/Generalized_ICP.pdf
+#   * The approach is based on using anistropic cost functions to optimize the alignment 
+#   * after closest point assignments have been made.
+#   * The original code uses GSL and ANN while in ours we use an eigen mapped BFGS and 
+#   * FLANN.
+#   * \author Nizar Sallem
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget>
+# class GeneralizedIterativeClosestPoint : public IterativeClosestPoint<PointSource, PointTarget>
+cdef extern from "pcl/registration/gicp.h" namespace "pcl" nogil:
+    cdef cppclass GeneralizedIterativeClosestPoint[Source, Target](IterativeClosestPoint[Source, Target, float]):
+        GeneralizedIterativeClosestPoint() except +
+        # using IterativeClosestPoint<PointSource, PointTarget>::reg_name_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::getClassName;
+        # using IterativeClosestPoint<PointSource, PointTarget>::indices_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::target_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::input_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::tree_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::nr_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::max_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::previous_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::final_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::transformation_epsilon_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::converged_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::corr_dist_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::inlier_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::min_number_correspondences_;
+        # using IterativeClosestPoint<PointSource, PointTarget>::update_visualizer_;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # typedef typename pcl::KdTree<PointSource> InputKdTree;
+        # typedef typename pcl::KdTree<PointSource>::Ptr InputKdTreePtr;
+        # typedef Eigen::Matrix<double, 6, 1> Vector6d;
+        # public:
+        # /** \brief Provide a pointer to the input dataset
+        #  * \param cloud the const boost shared pointer to a PointCloud message
+        #  */
+        # void setInputCloud (cpp.PointCloudPtr_t ptcloud)
+        # void setInputCloud (cpp.PointCloudPtr_t ptcloud)
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #  * \param[in] target the input point cloud target
+        #  */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &target)
+        # void setInputTarget (const PointCloudTargetConstPtr &target)
+        
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using an iterative
+        #  * non-linear Levenberg-Marquardt approach.
+        #  * \param[in] cloud_src the source point cloud dataset
+        #  * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #  * \param[in] cloud_tgt the target point cloud dataset
+        #  * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #  * \param[out] transformation_matrix the resultant transformation matrix
+        #  */
+        # void estimateRigidTransformationBFGS (
+        #                                const PointCloudSource &cloud_src,
+        #                                const std::vector<int> &indices_src,
+        #                                const PointCloudTarget &cloud_tgt,
+        #                                const std::vector<int> &indices_tgt,
+        #                                Eigen::Matrix4f &transformation_matrix);
+        # void estimateRigidTransformationBFGS (
+        #                                 const PointCloudSource &cloud_src,
+        #                                 const std::vector<int> &indices_src,
+        #                                 const PointCloudTarget &cloud_tgt,
+        #                                 const vector[int] &indices_tgt, 
+        #                                 Matrix4f &transformation_matrix);
+        
+        # /** \brief \return Mahalanobis distance matrix for the given point index */
+        # inline const Eigen::Matrix3d& mahalanobis(size_t index) const
+        # const Matrix3d& mahalanobis(size_t index)
+        
+        # /** \brief Computes rotation matrix derivative.
+        #  * rotation matrix is obtainded from rotation angles x[3], x[4] and x[5]
+        #  * \return d/d_rx, d/d_ry and d/d_rz respectively in g[3], g[4] and g[5]
+        #  * param x array representing 3D transformation
+        #  * param R rotation matrix
+        #  * param g gradient vector
+        #  */
+        # void computeRDerivative(const Vector6d &x, const Eigen::Matrix3d &R, Vector6d &g) const;
+        # void computeRDerivative(const Vector6d &x, const Matrix3d &R, Vector6d &g)
+        
+        # /** \brief Set the rotation epsilon (maximum allowable difference between two 
+        #  * consecutive rotations) in order for an optimization to be considered as having 
+        #  * converged to the final solution.
+        #  * \param epsilon the rotation epsilon
+        #  */
+        # inline void setRotationEpsilon (double epsilon)
+        void setRotationEpsilon (double epsilon)
+        
+        # /** \brief Get the rotation epsilon (maximum allowable difference between two 
+        #  * consecutive rotations) as set by the user.
+        #  */
+        # inline double getRotationEpsilon ()
+        double getRotationEpsilon ()
+        
+        # /** \brief Set the number of neighbors used when selecting a point neighbourhood
+        #   * to compute covariances. 
+        #   * A higher value will bring more accurate covariance matrix but will make 
+        #   * covariances computation slower.
+        #   * \param k the number of neighbors to use when computing covariances
+        #   */
+        void setCorrespondenceRandomness (int k)
+        
+        # /** \brief Get the number of neighbors used when computing covariances as set by the user 
+        #   */
+        int getCorrespondenceRandomness ()
+        
+        # /** set maximum number of iterations at the optimization step
+        #  * \param[in] max maximum number of iterations for the optimizer
+        #  */
+        void setMaximumOptimizerIterations (int max)
+        
+        # ///\return maximum number of iterations at the optimization step
+        int getMaximumOptimizerIterations ()
+
+
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] GeneralizedIterativeClosestPoint_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI] GeneralizedIterativeClosestPoint_PointXYZI_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB] GeneralizedIterativeClosestPoint_PointXYZRGB_t
+ctypedef GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA] GeneralizedIterativeClosestPoint_PointXYZRGBA_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ]] GeneralizedIterativeClosestPointPtr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZI, cpp.PointXYZI]] GeneralizedIterativeClosestPoint_PointXYZI_Ptr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGB, cpp.PointXYZRGB]] GeneralizedIterativeClosestPoint_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[GeneralizedIterativeClosestPoint[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] GeneralizedIterativeClosestPoint_PointXYZRGBA_Ptr_t
+###
+
+# icp_nl.h
+# /** \brief @b IterativeClosestPointNonLinear is an ICP variant that uses Levenberg-Marquardt optimization 
+#     * backend. The resultant transformation is optimized as a quaternion.
+#     * The algorithm has several termination criteria:
+#     * <ol>
+#     * <li>Number of iterations has reached the maximum user imposed number of iterations 
+#     *     (via \ref setMaximumIterations)</li>
+#     * <li>The epsilon (difference) between the previous transformation and the current estimated transformation is 
+#     *     smaller than an user imposed value (via \ref setTransformationEpsilon)</li>
+#     * <li>The sum of Euclidean squared errors is smaller than a user defined threshold 
+#     *     (via \ref setEuclideanFitnessEpsilon)</li>
+#     * </ol>
+#     * \author Radu B. Rusu, Michael Dixon
+#     * \ingroup registration
+#     */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class IterativeClosestPointNonLinear : public IterativeClosestPoint<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/icp_nl.h" namespace "pcl" nogil:
+    cdef cppclass IterativeClosestPointNonLinear[Source, Target, Scalar](IterativeClosestPoint[Source, Target, Scalar]):
+        IterativeClosestPointNonLinear() except +
+
+
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float] IterativeClosestPointNonLinear_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float] IterativeClosestPointNonLinear_PointXYZI_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float] IterativeClosestPointNonLinear_PointXYZRGB_t
+ctypedef IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float] IterativeClosestPointNonLinear_PointXYZRGBA_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZ, cpp.PointXYZ, float]] IterativeClosestPointNonLinearPtr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZI, cpp.PointXYZI, float]] IterativeClosestPointNonLinear_PointXYZI_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGB, cpp.PointXYZRGB, float]] IterativeClosestPointNonLinear_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[IterativeClosestPointNonLinear[cpp.PointXYZRGBA, cpp.PointXYZRGBA, float]] IterativeClosestPointNonLinear_PointXYZRGBA_Ptr_t
+###
+
+# bfgs.h
+# template< typename _Scalar >
+# class PolynomialSolver<_Scalar,2> : public PolynomialSolverBase<_Scalar,2>
+# cdef extern from "pcl/registration/bfgs.h" namespace "Eigen" nogil:
+#     cdef cppclass PolynomialSolver[_Scalar, 2](PolynomialSolverBase[_Scalar, 2]):
+#         PolynomialSolver (int nr_dim)
+        # public:
+        # typedef PolynomialSolverBase<_Scalar,2>    PS_Base;
+        # EIGEN_POLYNOMIAL_SOLVER_BASE_INHERITED_TYPES( PS_Base )
+        # public:
+        # template< typename OtherPolynomial >
+        # inline PolynomialSolver( const OtherPolynomial& poly, bool& hasRealRoot )
+        # /** Computes the complex roots of a new polynomial. */
+        # template< typename OtherPolynomial >
+        # void compute( const OtherPolynomial& poly, bool& hasRealRoot)
+        # template< typename OtherPolynomial > 
+        # void compute( const OtherPolynomial& poly)
+
+###
+
+# bfgs.h
+# template<typename _Scalar, int NX=Eigen::Dynamic>
+# struct BFGSDummyFunctor
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+#   cdef struct BFGSDummyFunctor[_Scalar, NX]:
+#       BFGSDummyFunctor ()
+#       BFGSDummyFunctor(int inputs)
+#       typedef _Scalar Scalar;
+#       enum { InputsAtCompileTime = NX };
+#       typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> VectorType;
+#       const int m_inputs;
+#       int inputs() const { return m_inputs; }
+#       virtual double operator() (const VectorType &x) = 0;
+#       virtual void  df(const VectorType &x, VectorType &df) = 0;
+#       virtual void fdf(const VectorType &x, Scalar &f, VectorType &df) = 0;
+# 
+###
+
+# bfgs.h
+# namespace BFGSSpace {
+#   enum Status {
+#     NegativeGradientEpsilon = -3,
+#     NotStarted = -2,
+#     Running = -1,
+#     Success = 0,
+#     NoProgress = 1
+#   };
+# }
+# 
+###
+
+# bfgs.h
+# /**
+#  * BFGS stands for Broydenletcheroldfarbhanno (BFGS) method for solving 
+#  * unconstrained nonlinear optimization problems. 
+#  * For further details please visit: http://en.wikipedia.org/wiki/BFGS_method
+#  * The method provided here is almost similar to the one provided by GSL.
+#  * It reproduces Fletcher's original algorithm in Practical Methods of Optimization
+#  * algorithms : 2.6.2 and 2.6.4 and uses the same politics in GSL with cubic 
+#  * interpolation whenever it is possible else falls to quadratic interpolation for 
+#  * alpha parameter.
+#  */
+# template<typename FunctorType>
+# class BFGS
+# cdef extern from "pcl/registration/bfgs.h" nogil:
+#     cdef cppclass BFGS[FunctorType]:
+#         # BFGS (FunctorType &_functor) 
+# public:
+#   typedef typename FunctorType::Scalar Scalar;
+#   typedef typename FunctorType::VectorType FVectorType;
+#   typedef Eigen::DenseIndex Index;
+# 
+#   struct Parameters {
+#     Parameters()
+#     : max_iters(400)
+#       , bracket_iters(100)
+#       , section_iters(100)
+#       , rho(0.01)
+#       , sigma(0.01)
+#       , tau1(9)
+#       , tau2(0.05)
+#       , tau3(0.5)
+#       , step_size(1)
+#       , order(3) {}
+#     Index max_iters;   // maximum number of function evaluation
+#     Index bracket_iters;
+#     Index section_iters;
+#     Scalar rho;
+#     Scalar sigma;
+#     Scalar tau1;
+#     Scalar tau2;
+#     Scalar tau3;
+#     Scalar step_size;
+#     Index order;
+# 
+#   BFGSSpace::Status minimize(FVectorType &x);
+#   BFGSSpace::Status minimizeInit(FVectorType &x);
+#   BFGSSpace::Status minimizeOneStep(FVectorType &x);
+#   BFGSSpace::Status testGradient(Scalar epsilon);
+#   void resetParameters(void) { parameters = Parameters(); }
+#   
+#   Parameters parameters;
+#   Scalar f;
+#   FVectorType gradient;
+# 
+#
+# template<typename FunctorType> void
+# BFGS<FunctorType>::checkExtremum(const Eigen::Matrix<Scalar, 4, 1>& coefficients, Scalar x, Scalar& xmin, Scalar& fmin)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::moveTo(Scalar alpha)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::slope()
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::applyF(Scalar alpha)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar
+# BFGS<FunctorType>::applyDF(Scalar alpha)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::applyFDF(Scalar alpha, Scalar& f, Scalar& df)
+# 
+# template<typename FunctorType> void
+# BFGS<FunctorType>::updatePosition (Scalar alpha, FVectorType &x, Scalar &f, FVectorType &g)
+#
+# template<typename FunctorType> void
+# BFGS<FunctorType>::changeDirection ()
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimize(FVectorType  &x)
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimizeInit(FVectorType  &x)
+# 
+# template<typename FunctorType> BFGSSpace::Status
+# BFGS<FunctorType>::minimizeOneStep(FVectorType  &x)
+# 
+# template<typename FunctorType> typename BFGSSpace::Status 
+# BFGS<FunctorType>::testGradient(Scalar epsilon)
+# 
+# template<typename FunctorType> typename BFGS<FunctorType>::Scalar 
+# BFGS<FunctorType>::interpolate (Scalar a, Scalar fa, Scalar fpa,
+#                                 Scalar b, Scalar fb, Scalar fpb, 
+#                                 Scalar xmin, Scalar xmax,
+#                                 int order)
+# 
+# template<typename FunctorType> BFGSSpace::Status 
+# BFGS<FunctorType>::lineSearch(Scalar rho, Scalar sigma, 
+#                               Scalar tau1, Scalar tau2, Scalar tau3,
+#                               int order, Scalar alpha1, Scalar &alpha_new)
+###
+
+# correspondence_estimation_backprojection.h
+# namespace pcl
+# namespace registration
+# /** \brief @b CorrespondenceEstimationBackprojection computes
+#   * correspondences as points in the target cloud which have minimum
+#   * \author Suat Gedikli
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename NormalT, typename Scalar = float>
+# class CorrespondenceEstimationBackProjection : public CorrespondenceEstimationBase <PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/correspondence_estimation.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationBackProjection[Source, Target, Normal](CorrespondenceEstimationBase[Source, Target, float]):
+        CorrespondenceEstimationBackProjection ()
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceEstimationBackProjection<PointSource, PointTarget, NormalT, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceEstimationBackProjection<PointSource, PointTarget, NormalT, Scalar> > ConstPtr;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initCompute;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initComputeReciprocal;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_transformed_;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::getClassName;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::point_representation_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_indices_;
+        # typedef typename pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::search::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef pcl::PointCloud<NormalT> PointCloudNormals;
+        # typedef typename PointCloudNormals::Ptr NormalsPtr;
+        # typedef typename PointCloudNormals::ConstPtr NormalsConstPtr;
+        # /** \brief Set the normals computed on the source point cloud
+        #   * \param[in] normals the normals computed for the source cloud
+        #   */
+        # inline void setSourceNormals (const NormalsConstPtr &normals) { source_normals_ = normals; }
+        # void setSourceNormals (const NormalsConstPtr &normals)
+        
+        # /** \brief Get the normals of the source point cloud
+        #   */
+        # inline NormalsConstPtr getSourceNormals () const { return (source_normals_); }
+        # NormalsConstPtr getSourceNormals ()
+        
+        # /** \brief Set the normals computed on the target point cloud
+        #   * \param[in] normals the normals computed for the target cloud
+        #   */
+        # inline void setTargetNormals (const NormalsConstPtr &normals) { target_normals_ = normals; }
+        # void setTargetNormals (const NormalsConstPtr &normals)
+        
+        # /** \brief Get the normals of the target point cloud
+        #   */
+        # inline NormalsConstPtr getTargetNormals () const { return (target_normals_); }
+        # NormalsConstPtr getTargetNormals ()
+        
+        # /** \brief See if this rejector requires source normals */
+        # bool requiresSourceNormals () const
+        bool requiresSourceNormals ()
+        
+        # /** \brief Blob method for setting the source normals */
+        # void setSourceNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setSourceNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief See if this rejector requires target normals*/
+        # bool requiresTargetNormals () const
+        bool requiresTargetNormals ()
+        
+        # /** \brief Method for setting the target normals */
+        # void setTargetNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setTargetNormals (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum distance between the normal on the source point cloud and the corresponding point in the target
+        #   * point cloud
+        #   */
+        # void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # void determineCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        
+        # /** \brief Determine the reciprocal correspondences between input and target cloud.
+        #   * A correspondence is considered reciprocal if both Src_i has Tgt_i as a 
+        #   * correspondence, and Tgt_i has Src_i as one.
+        #   *
+        #   * \param[out] correspondences the found correspondences (index of query and target point, distance)
+        #   * \param[in] max_distance maximum allowed distance between correspondences
+        #   */
+        # virtual void determineReciprocalCorrespondences (pcl::Correspondences &correspondences, double max_distance = std::numeric_limits<double>::max ());
+        # 
+        # /** \brief Set the number of nearest neighbours to be considered in the target 
+        #   * point cloud. By default, we use k = 10 nearest neighbors.
+        #   *
+        #   * \param[in] k the number of nearest neighbours to be considered
+        #   */
+        # inline void setKSearch (unsigned int k)
+        # void setKSearch (unsigned int k)
+        
+        # /** \brief Get the number of nearest neighbours considered in the target point 
+        #   * cloud for computing correspondences. By default we use k = 10 nearest 
+        #   * neighbors.
+        #   */
+        # inline void getKSearch ()
+        # void getKSearch ()
+        
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const
+
+
+###
+
+# correspondence_estimation_normal_shooting.h
+# template <typename PointSource, typename PointTarget, typename NormalT>
+# class CorrespondenceEstimationNormalShooting : public CorrespondenceEstimation <PointSource, PointTarget>
+cdef extern from "pcl/registration/correspondence_estimation_normal_shooting.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationNormalShooting[Source, Target, NormalT](CorrespondenceEstimation[Source, Target, NormalT]):
+        CorrespondenceEstimationNormalShooting()
+        # public:
+        # using PCLBase<PointSource>::initCompute;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using CorrespondenceEstimation<PointSource, PointTarget>::getClassName;
+        # typedef typename pcl::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # typedef typename pcl::PointCloud<NormalT>::Ptr NormalsPtr;
+        
+        # /** \brief Set the normals computed on the input point cloud
+        #   * \param[in] normals the normals computed for the input cloud
+        #   */
+        # inline void setSourceNormals (const NormalsPtr &normals)
+        # void setSourceNormals (const NormalsPtr &normals)
+        
+        # 
+        # /** \brief Get the normals of the input point cloud
+        #   */
+        # inline NormalsPtr getSourceNormals () const
+        # NormalsPtr getSourceNormals ()
+        
+        # /** \brief Determine the correspondences between input and target cloud.
+        #   * \param[out] correspondences the found correspondences (index of query point, index of target point, distance)
+        #   * \param[in] max_distance maximum distance between the normal on the source point cloud and the corresponding point in the target
+        #   * point cloud
+        #   */
+        # void determineCorrespondences (pcl::Correspondences &correspondences, float max_distance = std::numeric_limits<float>::max ());
+        
+        # /** \brief Set the number of nearest neighbours to be considered in the target point cloud
+        #   * \param[in] k the number of nearest neighbours to be considered
+        #   */
+        # inline void setKSearch (unsigned int k)
+        void setKSearch (unsigned int k)
+        
+        # /** \brief Get the number of nearest neighbours considered in the target point cloud for computing correspondence
+        #   */
+        # inline void getKSearch ()
+        void getKSearch ()
+
+
+###
+
+# correspondence_estimation_organized_projection.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class CorrespondenceEstimationOrganizedProjection : public CorrespondenceEstimationBase <PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/correspondence_estimation_organized_projection.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceEstimationOrganizedProjection[Source, Target, float](CorrespondenceEstimationBase[Source, Target, float]):
+        # CorrespondenceEstimationOrganizedProjection ()
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::initCompute;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::input_transformed_;
+        # using PCLBase<PointSource>::deinitCompute;
+        # using PCLBase<PointSource>::input_;
+        # using PCLBase<PointSource>::indices_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::getClassName;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::point_representation_;
+        # using CorrespondenceEstimationBase<PointSource, PointTarget, Scalar>::target_cloud_updated_;
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef boost::shared_ptr< CorrespondenceEstimationOrganizedProjection<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr< const CorrespondenceEstimationOrganizedProjection<PointSource, PointTarget, Scalar> > ConstPtr;
+        
+        # /** \brief Empty constructor that sets all the intrinsic calibration to the default Kinect values. */
+        # CorrespondenceEstimationOrganizedProjection ()
+        
+        # /** \brief Sets the focal length parameters of the target camera.
+        #   * \param[in] fx the focal length in pixels along the x-axis of the image
+        #   * \param[in] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void setFocalLengths (const float fx, const float fy)
+        void setFocalLengths (const float fx, const float fy)
+        
+        # /** \brief Reads back the focal length parameters of the target camera.
+        #   * \param[out] fx the focal length in pixels along the x-axis of the image
+        #   * \param[out] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void getFocalLengths (float &fx, float &fy) const
+        void getFocalLengths (float &fx, float &fy)
+        
+        # /** \brief Sets the camera center parameters of the target camera.
+        #   * \param[in] cx the x-coordinate of the camera center
+        #   * \param[in] cy the y-coordinate of the camera center
+        #   */
+        # inline void setCameraCenters (const float cx, const float cy)
+        void setCameraCenters (const float cx, const float cy)
+        
+        # /** \brief Reads back the camera center parameters of the target camera.
+        #   * \param[out] cx the x-coordinate of the camera center
+        #   * \param[out] cy the y-coordinate of the camera center
+        #   */
+        # inline void getCameraCenters (float &cx, float &cy) const
+        void getCameraCenters (float &cx, float &cy)
+        
+        # /** \brief Sets the transformation from the source point cloud to the target point cloud.
+        #   * \note The target point cloud must be in its local camera coordinates, so use this transformation to correct
+        #   * for that.
+        #   * \param[in] src_to_tgt_transformation the transformation
+        #   */
+        # inline void setSourceTransformation (const Eigen::Matrix4f &src_to_tgt_transformation)
+        void setSourceTransformation (const Matrix4f &src_to_tgt_transformation)
+        
+        # /** \brief Reads back the transformation from the source point cloud to the target point cloud.
+        #   * \note The target point cloud must be in its local camera coordinates, so use this transformation to correct
+        #   * for that.
+        #   * \return the transformation
+        #   */
+        # inline Eigen::Matrix4f getSourceTransformation () const
+        Matrix4f getSourceTransformation ()
+        
+        # /** \brief Sets the depth threshold; after projecting the source points in the image space of the target camera,
+        #   * this threshold is applied on the depths of corresponding dexels to eliminate the ones that are too far from
+        #   * each other.
+        #   * \param[in] depth_threshold the depth threshold
+        #   */
+        # inline void setDepthThreshold (const float depth_threshold)
+        void setDepthThreshold (const float depth_threshold)
+        
+        # /** \brief Reads back the depth threshold; after projecting the source points in the image space of the target
+        #   * camera, this threshold is applied on the depths of corresponding dexels to eliminate the ones that are too
+        #   * far from each other.
+        #   * \return the depth threshold
+        #   */
+        # inline float getDepthThreshold ()
+        float getDepthThreshold ()
+        
+        # /** \brief Computes the correspondences, applying a maximum Euclidean distance threshold.
+        #   * \param correspondences
+        #   * \param[in] max_distance Euclidean distance threshold above which correspondences will be rejected
+        #   */
+        # void determineCorrespondences (Correspondences &correspondences, double max_distance);
+        # void determineCorrespondences (Correspondences &correspondences, double max_distance)
+        
+        # /** \brief Computes the correspondences, applying a maximum Euclidean distance threshold.
+        #   * \param correspondences
+        #   * \param[in] max_distance Euclidean distance threshold above which correspondences will be rejected
+        #   */
+        # void determineReciprocalCorrespondences (Correspondences &correspondences, double max_distance);
+        # void determineReciprocalCorrespondences (Correspondences &correspondences, double max_distance)
+        
+        # /** \brief Clone and cast to CorrespondenceEstimationBase */
+        # virtual boost::shared_ptr< CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> > clone () const
+
+
+###
+
+# correspondence_rejection_distance.h
+# class CorrespondenceRejectorDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorDistance(CorrespondenceRejector):
+        CorrespondenceRejectorDistance()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Set the maximum distance used for thresholding in correspondence rejection.
+        #   * \param[in] distance Distance to be used as maximum distance between correspondences. 
+        #   * Correspondences with larger distances are rejected.
+        #   * \note Internally, the distance will be stored squared.
+        #   */
+        # virtual inline void setMaximumDistance (float distance)
+        # 
+        # /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+        # inline float getMaximumDistance ()
+        # 
+        # /** \brief Provide a source point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # 
+        # /** \brief Provide a target point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+
+
+###
+
+# correspondence_rejection_features.h
+# class CorrespondenceRejectorFeatures: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_features.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorFeatures(CorrespondenceRejector):
+        CorrespondenceRejectorFeatures()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] source_feature a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setSourceFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &source_feature, const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setSourceFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr getSourceFeature (const std::string &key);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] target_feature a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setTargetFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &target_feature, const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setTargetFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr getTargetFeature (const std::string &key);
+        # 
+        # /** \brief Set a hard distance threshold in the feature \a FeatureT space, between source and target
+        #   * features. Any feature correspondence that is above this threshold will be considered bad and will be
+        #   * filtered out.
+        #   * \param[in] thresh the distance threshold
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void setDistanceThreshold (double thresh, const std::string &key);
+        # 
+        # /** \brief Test that all features are valid (i.e., does each key have a valid source cloud, target cloud, 
+        #   * and search method)
+        #   */
+        # inline bool hasValidFeatures ();
+        # 
+        # /** \brief Provide a boost shared pointer to a PointRepresentation to be used when comparing features
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   * \param[in] fr the point feature representation to be used 
+        #   */
+        # template <typename FeatureT> inline void setFeatureRepresentation (const typename pcl::PointRepresentation<FeatureT>::ConstPtr &fr, const std::string &key);
+
+
+###
+
+# correspondence_rejection_median_distance.h
+# class CorrespondenceRejectorMedianDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_median_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorMedianDistance(CorrespondenceRejector):
+        CorrespondenceRejectorMedianDistance()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void 
+        # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+        #                              pcl::Correspondences& remaining_correspondences);
+        # /** \brief Set the maximum distance used for thresholding in correspondence rejection.
+        #   * \param[in] distance Distance to be used as maximum distance between correspondences. 
+        #   * Correspondences with larger distances are rejected.
+        #   * \note Internally, the distance will be stored squared.
+        #   */
+        # virtual inline void setMaximumDistance (float distance)
+        # /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+        # inline float getMaximumDistance ()
+        # /** \brief Provide a source point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # 
+        # /** \brief Provide a target point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+
+
+###
+
+# correspondence_rejection_features.h
+# class CorrespondenceRejectorFeatures: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_features.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorFeatures(CorrespondenceRejector):
+        CorrespondenceRejectorFeatures()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # void 
+        # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+        #                              pcl::Correspondences& remaining_correspondences);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] source_feature a cloud of feature descriptors associated with the source point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void 
+        # setSourceFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &source_feature, 
+        #                   const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setSourceFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr 
+        # getSourceFeature (const std::string &key);
+        # 
+        # /** \brief Provide a pointer to a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] target_feature a cloud of feature descriptors associated with the target point cloud
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void 
+        # setTargetFeature (const typename pcl::PointCloud<FeatureT>::ConstPtr &target_feature, 
+        #                   const std::string &key);
+        # 
+        # /** \brief Get a pointer to the source cloud's feature descriptors, specified by the given \a key
+        #   * \param[in] key a string that uniquely identifies the feature (must match the key provided by setTargetFeature)
+        #   */
+        # template <typename FeatureT> inline typename pcl::PointCloud<FeatureT>::ConstPtr 
+        # getTargetFeature (const std::string &key);
+        # 
+        # /** \brief Set a hard distance threshold in the feature \a FeatureT space, between source and target
+        #   * features. Any feature correspondence that is above this threshold will be considered bad and will be
+        #   * filtered out.
+        #   * \param[in] thresh the distance threshold
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   */
+        # template <typename FeatureT> inline void 
+        # setDistanceThreshold (double thresh, const std::string &key);
+        # 
+        # /** \brief Test that all features are valid (i.e., does each key have a valid source cloud, target cloud, 
+        #   * and search method)
+        #   */
+        # inline bool hasValidFeatures ();
+        # 
+        # /** \brief Provide a boost shared pointer to a PointRepresentation to be used when comparing features
+        #   * \param[in] key a string that uniquely identifies the feature
+        #   * \param[in] fr the point feature representation to be used 
+        #   */
+        # template <typename FeatureT> inline void
+        # setFeatureRepresentation (const typename pcl::PointRepresentation<FeatureT>::ConstPtr &fr,
+        #                           const std::string &key);
+        # 
+
+
+###
+
+# correspondence_rejection_median_distance.h
+# class CorrespondenceRejectorMedianDistance: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_median_distance.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorMedianDistance(CorrespondenceRejector):
+        CorrespondenceRejectorMedianDistance()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void 
+        # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+        #                              pcl::Correspondences& remaining_correspondences);
+        # /** \brief Get the median distance used for thresholding in correspondence rejection. */
+        # inline double getMedianDistance () const
+        # /** \brief Provide a source point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # /** \brief Provide a target point cloud dataset (must contain XYZ
+        #   * data!), used to compute the correspondence distance.  
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # template <typename PointT> inline void 
+        # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+        # /** \brief Set the factor for correspondence rejection. Points with distance greater than median times factor
+        #  *  will be rejected
+        #  *  \param[in] factor value
+        #  */
+        # inline void setMedianFactor (double factor)
+        # /** \brief Get the factor used for thresholding in correspondence rejection. */
+        # inline double getMedianFactor () const { return factor_; };
+
+
+###
+
+# correspondence_rejection_one_to_one.h
+# class CorrespondenceRejectorOneToOne: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_one_to_one.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorOneToOne(CorrespondenceRejector):
+        CorrespondenceRejectorOneToOne()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       public:
+#         /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#           * \param[in] original_correspondences the set of initial correspondences given
+#           * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#           */
+#         inline void 
+#         getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                      pcl::Correspondences& remaining_correspondences);
+# 
+#       protected:
+#         /** \brief Apply the rejection algorithm.
+#           * \param[out] correspondences the set of resultant correspondences.
+#           */
+#         inline void 
+#         applyRejection (pcl::Correspondences &correspondences)
+#         {
+#           getRemainingCorrespondences (*input_correspondences_, correspondences);
+#         }
+#     };
+
+# 
+###
+
+# correspondence_rejection_organized_boundary.h
+# namespace pcl
+# namespace registration
+# class PCL_EXPORTS CorrespondenceRejectionOrganizedBoundary : public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_organized_boundary.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectionOrganizedBoundary(CorrespondenceRejector):
+        CorrespondenceRejectionOrganizedBoundary()
+        # public:
+        # /** @brief Empty constructor. */
+        # CorrespondenceRejectionOrganizedBoundary ()
+        #   : boundary_nans_threshold_ (8)
+        #   , window_size_ (5)
+        #   , depth_step_threshold_ (0.025f)
+        #   , data_container_ ()
+        # { }
+        # 
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        
+        # inline void setNumberOfBoundaryNaNs (int val)
+        
+        # template <typename PointT> inline void setInputSource (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        # template <typename PointT> inline void setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+        
+        # /** \brief See if this rejector requires source points */
+        # bool requiresSourcePoints () const
+        
+        # /** \brief Blob method for setting the source cloud */
+        # void setSourcePoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief See if this rejector requires a target cloud */
+        # bool requiresTargetPoints () const
+        
+        # /** \brief Method for setting the target cloud */
+        # void setTargetPoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # virtual bool updateSource (const Eigen::Matrix4d &)
+
+
+###
+
+# correspondence_rejection_poly.h
+# namespace pcl
+# namespace registration
+# template <typename SourceT, typename TargetT>
+cdef extern from "pcl/registration/correspondence_rejection_poly.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorPoly(CorrespondenceRejector):
+        CorrespondenceRejectorPoly ()
+        # using CorrespondenceRejector::input_correspondences_;
+        # using CorrespondenceRejector::rejection_name_;
+        # using CorrespondenceRejector::getClassName;
+        # public:
+        # typedef boost::shared_ptr<CorrespondenceRejectorPoly> Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceRejectorPoly> ConstPtr;
+        # typedef pcl::PointCloud<SourceT> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<TargetT> PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # 
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        # void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences)
+        
+        # /** \brief Provide a source point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # inline void setInputSource (const PointCloudSourceConstPtr &cloud)
+        # void setInputSource (const PointCloudSourceConstPtr &cloud)
+        
+        # 
+        # /** \brief Provide a source point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.
+        #   * \param[in] cloud a cloud containing XYZ data
+        #   */
+        # inline void setInputCloud (const PointCloudSourceConstPtr &cloud)
+        # void setInputCloud (const PointCloudSourceConstPtr &cloud)
+        
+        # /** \brief Provide a target point cloud dataset (must contain XYZ data!), used to compute the correspondence distance.
+        #   * \param[in] target a cloud containing XYZ data
+        #   */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &target)
+        # void setInputTarget (const PointCloudTargetConstPtr &target)
+        
+        # /** \brief See if this rejector requires source points */
+        # bool requiresSourcePoints () const
+        bool requiresSourcePoints ()
+        
+        # /** \brief Blob method for setting the source cloud */
+        # void setSourcePoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setSourcePoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief See if this rejector requires a target cloud */
+        # bool requiresTargetPoints () const
+        bool requiresTargetPoints ()
+        
+        # /** \brief Method for setting the target cloud */
+        # void setTargetPoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        # void setTargetPoints (pcl::PCLPointCloud2::ConstPtr cloud2)
+        
+        # /** \brief Set the polygon cardinality
+        #   * \param cardinality polygon cardinality
+        #   */
+        # inline void setCardinality (int cardinality)
+        void setCardinality (int cardinality)
+        
+        # /** \brief Get the polygon cardinality
+        #   * \return polygon cardinality
+        #   */
+        # inline int getCardinality ()
+        int getCardinality ()
+        
+        # /** \brief Set the similarity threshold in [0,1[ between edge lengths,
+        #   * where 1 is a perfect match
+        #   * \param similarity_threshold similarity threshold
+        #   */
+        # inline void setSimilarityThreshold (float similarity_threshold)
+        void setSimilarityThreshold (float similarity_threshold)
+        
+        # /** \brief Get the similarity threshold between edge lengths
+        #   * \return similarity threshold
+        #   */
+        # inline float getSimilarityThreshold ()
+        float getSimilarityThreshold ()
+        
+        # /** \brief Set the number of iterations
+        #   * \param iterations number of iterations
+        #   */
+        # inline void setIterations (int iterations)
+        void setIterations (int iterations)
+        
+        # /** \brief Get the number of iterations
+        #   * \return number of iterations
+        #   */
+        # inline int getIterations ()
+        int getIterations ()
+        
+        # /** \brief Polygonal rejection of a single polygon, indexed by a subset of correspondences
+        #   * \param corr all correspondences into \ref input_ and \ref target_
+        #   * \param idx sampled indices into \b correspondences, must have a size equal to \ref cardinality_
+        #   * \return true if all edge length ratios are larger than or equal to \ref similarity_threshold_
+        #   */
+        # inline bool thresholdPolygon (const pcl::Correspondences& corr, const std::vector<int>& idx)
+        # bool thresholdPolygon (const pcl::Correspondences& corr, const std::vector[int]& idx)
+        
+        # /** \brief Polygonal rejection of a single polygon, indexed by two point index vectors
+        #   * \param source_indices indices of polygon points in \ref input_, must have a size equal to \ref cardinality_
+        #   * \param target_indices corresponding indices of polygon points in \ref target_, must have a size equal to \ref cardinality_
+        #   * \return true if all edge length ratios are larger than or equal to \ref similarity_threshold_
+        #   */
+        # inline bool thresholdPolygon (const std::vector<int>& source_indices, const std::vector<int>& target_indices)
+        # bool thresholdPolygon (const vector[int]& source_indices, const vector[int]& target_indices)
+
+
+###
+
+# correspondence_rejection_sample_consensus.h
+# template <typename PointT>
+# class CorrespondenceRejectorSampleConsensus: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_sample_consensus.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSampleConsensus[T](CorrespondenceRejector):
+        CorrespondenceRejectorSampleConsensus()
+#       using CorrespondenceRejector::input_correspondences_;
+#       using CorrespondenceRejector::rejection_name_;
+#       using CorrespondenceRejector::getClassName;
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       public:
+#       /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#         * \param[in] original_correspondences the set of initial correspondences given
+#         * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#         */
+#       inline void 
+#       getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#                                    pcl::Correspondences& remaining_correspondences);
+# 
+#       /** \brief Provide a source point cloud dataset (must contain XYZ data!)
+#         * \param[in] cloud a cloud containing XYZ data
+#         */
+#       virtual inline void 
+#       setInputCloud (const PointCloudConstPtr &cloud) { input_ = cloud; }
+# 
+#       /** \brief Provide a target point cloud dataset (must contain XYZ data!)
+#         * \param[in] cloud a cloud containing XYZ data
+#         */
+#       virtual inline void 
+#       setTargetCloud (const PointCloudConstPtr &cloud) { target_ = cloud; }
+# 
+#       /** \brief Set the maximum distance between corresponding points.
+#         * Correspondences with distances below the threshold are considered as inliers.
+#         * \param[in] threshold Distance threshold in the same dimension as source and target data sets.
+#         */
+#       inline void 
+#       setInlierThreshold (double threshold) { inlier_threshold_ = threshold; };
+# 
+#       /** \brief Get the maximum distance between corresponding points.
+#         * \return Distance threshold in the same dimension as source and target data sets.
+#         */
+#       inline double 
+#       getInlierThreshold() { return inlier_threshold_; };
+# 
+#       /** \brief Set the maximum number of iterations.
+#         * \param[in] max_iterations Maximum number if iterations to run
+#         */
+#       inline void 
+#       setMaxIterations (int max_iterations) {max_iterations_ = std::max(max_iterations, 0); };
+# 
+#       /** \brief Get the maximum number of iterations.
+#         * \return max_iterations Maximum number if iterations to run
+#         */
+#       inline int 
+#       getMaxIterations () { return max_iterations_; };
+# 
+#       /** \brief Get the best transformation after RANSAC rejection.
+#         * \return The homogeneous 4x4 transformation yielding the largest number of inliers.
+#         */
+#       inline Eigen::Matrix4f 
+#       getBestTransformation () { return best_transformation_; };
+
+
+###
+
+# correspondence_rejection_sample_consensus_2d.h
+# namespace pcl
+# namespace registration
+# template <typename PointT>
+# class CorrespondenceRejectorSampleConsensus2D: public CorrespondenceRejectorSampleConsensus<PointT>
+cdef extern from "pcl/registration/correspondence_rejection_sample_consensus_2d.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSampleConsensus2D[T](CorrespondenceRejectorSampleConsensus):
+        CorrespondenceRejectorSampleConsensus2D()
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # using CorrespondenceRejectorSampleConsensus<PointT>::refine_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::input_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::target_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::input_correspondences_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::rejection_name_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::getClassName;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::inlier_threshold_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::max_iterations_;
+        # using CorrespondenceRejectorSampleConsensus<PointT>::best_transformation_;
+        # 
+        # typedef boost::shared_ptr<CorrespondenceRejectorSampleConsensus2D> Ptr;
+        # typedef boost::shared_ptr<const CorrespondenceRejectorSampleConsensus2D> ConstPtr;
+        # 
+        # /** \brief Empty constructor. Sets the inlier threshold to 5cm (0.05m), 
+        #   * and the maximum number of iterations to 1000. 
+        #   */
+        # CorrespondenceRejectorSampleConsensus2D ()
+        #   : projection_matrix_ (Eigen::Matrix3f::Identity ())
+        # {
+        #   rejection_name_ = "CorrespondenceRejectorSampleConsensus2D";
+        #   // Put the projection matrix together
+        #   //projection_matrix_ (0, 0) = 525.f;
+        #   //projection_matrix_ (1, 1) = 525.f;
+        #   //projection_matrix_ (0, 2) = 320.f;
+        #   //projection_matrix_ (1, 2) = 240.f;
+        # }
+        # 
+        # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+        #   * \param[in] original_correspondences the set of initial correspondences given
+        #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+        #   */
+        # inline void getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, pcl::Correspondences& remaining_correspondences);
+        
+        # /** \brief Sets the focal length parameters of the target camera.
+        #   * \param[in] fx the focal length in pixels along the x-axis of the image
+        #   * \param[in] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void setFocalLengths (const float fx, const float fy)
+        
+        # /** \brief Reads back the focal length parameters of the target camera.
+        #   * \param[out] fx the focal length in pixels along the x-axis of the image
+        #   * \param[out] fy the focal length in pixels along the y-axis of the image
+        #   */
+        # inline void getFocalLengths (float &fx, float &fy) const
+        
+        # /** \brief Sets the camera center parameters of the target camera.
+        #   * \param[in] cx the x-coordinate of the camera center
+        #   * \param[in] cy the y-coordinate of the camera center
+        #   */
+        # inline void setCameraCenters (const float cx, const float cy)
+        
+        # /** \brief Reads back the camera center parameters of the target camera.
+        #   * \param[out] cx the x-coordinate of the camera center
+        #   * \param[out] cy the y-coordinate of the camera center
+        #   */
+        # inline void getCameraCenters (float &cx, float &cy) const
+
+
+###
+
+# correspondence_rejection_surface_normal.h
+# class CorrespondenceRejectorSurfaceNormal : public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_surface_normal.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorSurfaceNormal(CorrespondenceRejector):
+        CorrespondenceRejectorSurfaceNormal()
+#       # using CorrespondenceRejector::input_correspondences_;
+#       # using CorrespondenceRejector::rejection_name_;
+#       # using CorrespondenceRejector::getClassName;
+#       # public:
+#       # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#       #   * \param[in] original_correspondences the set of initial correspondences given
+#       #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#       #   */
+#       # inline void 
+#       # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#       #                              pcl::Correspondences& remaining_correspondences);
+#       # 
+#       # /** \brief Set the thresholding angle between the normals for correspondence rejection. 
+#       #   * \param[in] threshold cosine of the thresholding angle between the normals for rejection
+#       #   */
+#       # inline void
+#       # setThreshold (double threshold) { threshold_ = threshold; };
+#       # 
+#       # /** \brief Get the thresholding angle between the normals for correspondence rejection. */
+#       # inline double getThreshold () const { return threshold_; };
+#       # 
+#       # /** \brief Initialize the data container object for the point type and the normal type
+#       #   */
+#       # template <typename PointT, typename NormalT> inline void initializeDataContainer ()
+#       # 
+#       # /** \brief Provide a source point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] cloud a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &input)
+#       # 
+#       # /** \brief Provide a target point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] target a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+#       # 
+#       # /** \brief Set the normals computed on the input point cloud
+#       #   * \param[in] normals the normals computed for the input cloud
+#       #   */
+#       # template <typename PointT, typename NormalT> inline void 
+#       # setInputNormals (const typename pcl::PointCloud<NormalT>::ConstPtr &normals)
+#       # 
+#       # /** \brief Set the normals computed on the target point cloud
+#       #   * \param[in] normals the normals computed for the input cloud
+#       #   */
+#       # template <typename PointT, typename NormalT> inline void 
+#       # setTargetNormals (const typename pcl::PointCloud<NormalT>::ConstPtr &normals)
+#       # 
+#       # /** \brief Get the normals computed on the input point cloud */
+#       # template <typename NormalT> inline typename pcl::PointCloud<NormalT>::Ptr
+#       # getInputNormals () const { return boost::static_pointer_cast<DataContainer<pcl::PointXYZ, NormalT> > (data_container_)->getInputNormals (); }
+#       # 
+#       # /** \brief Get the normals computed on the target point cloud */
+#       # template <typename NormalT> inline typename pcl::PointCloud<NormalT>::Ptr
+#       # getTargetNormals () const { return boost::static_pointer_cast<DataContainer<pcl::PointXYZ, NormalT> > (data_container_)->getTargetNormals (); }
+
+
+###
+
+# correspondence_rejection_trimmed.h
+#     class CorrespondenceRejectorTrimmed: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_trimmed.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorTrimmed(CorrespondenceRejector):
+        CorrespondenceRejectorTrimmed()
+#       # using CorrespondenceRejector::input_correspondences_;
+#       # using CorrespondenceRejector::rejection_name_;
+#       # using CorrespondenceRejector::getClassName;
+#       # public:
+#       # /** \brief Set the expected ratio of overlap between point clouds (in
+#       #   * terms of correspondences).
+#       #   * \param[in] ratio ratio of overlap between 0 (no overlap, no
+#       #   * correspondences) and 1 (full overlap, all correspondences)
+#       #   */
+#       # virtual inline void setOverlapRadio (float ratio)
+#       # 
+#       # /** \brief Get the maximum distance used for thresholding in correspondence rejection. */
+#       # inline float getOverlapRadio ()
+#       # 
+#       # /** \brief Set a minimum number of correspondences. If the specified overlap ratio causes to have
+#       #   * less correspondences,  \a CorrespondenceRejectorTrimmed will try to return at least
+#       #   * \a nr_min_correspondences_ correspondences (or all correspondences in case \a nr_min_correspondences_
+#       #   * is less than the number of given correspondences). 
+#       #   * \param[in] min_correspondences the minimum number of correspondences
+#       #   */
+#       # inline void setMinCorrespondences (unsigned int min_correspondences) { nr_min_correspondences_ = min_correspondences; };
+#       # 
+#       # /** \brief Get the minimum number of correspondences. */
+#       # inline unsigned int getMinCorrespondences ()
+#       # 
+#       # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#       #   * \param[in] original_correspondences the set of initial correspondences given
+#       #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#       #   */
+#       # inline void
+#       # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences,
+#       #                              pcl::Correspondences& remaining_correspondences);
+
+
+###
+
+# correspondence_rejection_var_trimmed.h
+#     class CorrespondenceRejectorVarTrimmed: public CorrespondenceRejector
+cdef extern from "pcl/registration/correspondence_rejection_var_trimmed.h" namespace "pcl::registration" nogil:
+    cdef cppclass CorrespondenceRejectorVarTrimmed(CorrespondenceRejector):
+        CorrespondenceRejectorVarTrimmed()
+#       # using CorrespondenceRejector::input_correspondences_;
+#       # using CorrespondenceRejector::rejection_name_;
+#       # using CorrespondenceRejector::getClassName;
+#       # public:
+#       # /** \brief Get a list of valid correspondences after rejection from the original set of correspondences.
+#       #   * \param[in] original_correspondences the set of initial correspondences given
+#       #   * \param[out] remaining_correspondences the resultant filtered set of remaining correspondences
+#       #   */
+#       # inline void 
+#       # getRemainingCorrespondences (const pcl::Correspondences& original_correspondences, 
+#       #                              pcl::Correspondences& remaining_correspondences);
+#       # 
+#       # /** \brief Get the trimmed distance used for thresholding in correspondence rejection. */
+#       # inline double
+#       # getTrimmedDistance () const { return trimmed_distance_; };
+#       # 
+#       # /** \brief Provide a source point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] cloud a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud)
+#       # 
+#       # /** \brief Provide a target point cloud dataset (must contain XYZ
+#       #   * data!), used to compute the correspondence distance.  
+#       #   * \param[in] target a cloud containing XYZ data
+#       #   */
+#       # template <typename PointT> inline void 
+#       # setInputTarget (const typename pcl::PointCloud<PointT>::ConstPtr &target)
+#       # 
+#       # /** \brief Get the computed inlier ratio used for thresholding in correspondence rejection. */
+#       # inline double
+#       # getTrimFactor () const { return factor_; }
+#       # 
+#       # /** brief set the minimum overlap ratio
+#       #   * \param[in] ratio the overlap ratio [0..1]
+#       #   */
+#       # inline void
+#       # setMinRatio (double ratio) { min_ratio_ = ratio; }
+#       # 
+#       # /** brief get the minimum overlap ratio
+#       #   */
+#       # inline double
+#       # getMinRatio () const { return min_ratio_; }
+#       # 
+#       # /** brief set the maximum overlap ratio
+#       #   * \param[in] ratio the overlap ratio [0..1]
+#       #   */
+#       # inline void
+#       # setMaxRatio (double ratio) { max_ratio_ = ratio; }
+#       # 
+#       # /** brief get the maximum overlap ratio
+#       #   */
+#       # inline double
+#       # getMaxRatio () const { return max_ratio_; }
+# 
+# 
+###
+
+# correspondence_sorting.h
+#     /** @b sortCorrespondencesByQueryIndex : a functor for sorting correspondences by query index
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByQueryIndex : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.index_query < b.index_query);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByMatchIndex : a functor for sorting correspondences by match index
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByMatchIndex : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.index_match < b.index_match);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByDistance : a functor for sorting correspondences by distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         return (a.distance < b.distance);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByQueryIndexAndDistance : a functor for sorting correspondences by query index _and_ distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByQueryIndexAndDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       inline bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         if (a.index_query < b.index_query)
+#           return (true);
+#         else if ( (a.index_query == b.index_query) && (a.distance < b.distance) )
+#           return (true);
+#         return (false);
+#       }
+#     };
+# 
+#     /** @b sortCorrespondencesByMatchIndexAndDistance : a functor for sorting correspondences by match index _and_ distance
+#       * \author Dirk Holz
+#       * \ingroup registration
+#       */
+#     struct sortCorrespondencesByMatchIndexAndDistance : public std::binary_function<pcl::Correspondence, pcl::Correspondence, bool>
+#     {
+#       inline bool 
+#       operator()( pcl::Correspondence a, pcl::Correspondence b)
+#       {
+#         if (a.index_match < b.index_match)
+#           return (true);
+#         else if ( (a.index_match == b.index_match) && (a.distance < b.distance) )
+#           return (true);
+#         return (false);
+#       }
+#     };
+
+# 
+###
+
+# correspondence_types.h
+#     /** \brief calculates the mean and standard deviation of descriptor distances from correspondences
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] mean the mean descriptor distance of correspondences
+#       * \param[out] stddev the standard deviation of descriptor distances.
+#       * \note The sample varaiance is used to determine the standard deviation
+#       */
+#     inline void 
+#     getCorDistMeanStd (const pcl::Correspondences& correspondences, double &mean, double &stddev);
+# 
+#     /** \brief extracts the query indices
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] indices array of extracted indices.
+#       * \note order of indices corresponds to input list of descriptor correspondences
+#       */
+#     inline void 
+#     getQueryIndices (const pcl::Correspondences& correspondences, std::vector<int>& indices);
+# 
+#     /** \brief extracts the match indices
+#       * \param[in] correspondences list of correspondences
+#       * \param[out] indices array of extracted indices.
+#       * \note order of indices corresponds to input list of descriptor correspondences
+#       */
+#     inline void 
+#     getMatchIndices (const pcl::Correspondences& correspondences, std::vector<int>& indices);
+
+# 
+###
+
+# default_convergence_criteria.h
+# namespace pcl
+# namespace registration
+# /** \brief @b DefaultConvergenceCriteria represents an instantiation of
+#   * ConvergenceCriteria, and implements the following criteria for registration loop
+#   * evaluation:
+#   *
+#   *  * a maximum number of iterations has been reached
+#   *  * the transformation (R, t) cannot be further updated (the difference between current and previous is smaller than a threshold)
+#   *  * the Mean Squared Error (MSE) between the current set of correspondences and the previous one is smaller than some threshold (both relative and absolute tests)
+#   *
+#   * \note Convergence is considered reached if ANY of the above criteria are met.
+#   *
+#   * \author Radu B. Rusu
+#   * \ingroup registration
+#   */
+# template <typename Scalar = float>
+# class DefaultConvergenceCriteria : public ConvergenceCriteria
+# cdef extern from "pcl/registration/default_convergence_criteria.h" namespace "pcl::registration" nogil:
+#     cdef cppclass DefaultConvergenceCriteria(ConvergenceCriteria):
+        # DefaultConvergenceCriteria()
+        # public:
+        # typedef boost::shared_ptr<DefaultConvergenceCriteria<Scalar> > Ptr;
+        # typedef boost::shared_ptr<const DefaultConvergenceCriteria<Scalar> > ConstPtr;
+        # typedef Eigen::Matrix<Scalar, 4, 4> Matrix4;
+        # 
+        # enum ConvergenceState
+        # {
+        #   CONVERGENCE_CRITERIA_NOT_CONVERGED,
+        #   CONVERGENCE_CRITERIA_ITERATIONS,
+        #   CONVERGENCE_CRITERIA_TRANSFORM,
+        #   CONVERGENCE_CRITERIA_ABS_MSE,
+        #   CONVERGENCE_CRITERIA_REL_MSE,
+        #   CONVERGENCE_CRITERIA_NO_CORRESPONDENCES
+        # };
+        # 
+        # /** \brief Empty constructor.
+        #   * Sets:
+        #   *  * the maximum number of iterations to 1000
+        #   *  * the rotation threshold to 0.256 degrees (0.99999)
+        #   *  * the translation threshold to 0.0003 meters (3e-4^2)
+        #   *  * the MSE relative / absolute thresholds to 0.001% and 1e-12
+        #   *
+        #   * \param[in] iterations a reference to the number of iterations the loop has ran so far
+        #   * \param[in] transform a reference to the current transformation obtained by the transformation evaluation
+        #   * \param[in] correspondences a reference to the current set of point correspondences between source and target
+        #   */
+        # DefaultConvergenceCriteria (const int &iterations, const Matrix4 &transform, const pcl::Correspondences &correspondences)
+        #   : iterations_ (iterations)
+        #   , transformation_ (transform)
+        #   , correspondences_ (correspondences)
+        #   , correspondences_prev_mse_ (std::numeric_limits<double>::max ())
+        #   , correspondences_cur_mse_ (std::numeric_limits<double>::max ())
+        #   , max_iterations_ (100)                 // 100 iterations
+        #   , failure_after_max_iter_ (false)
+        #   , rotation_threshold_ (0.99999)         // 0.256 degrees
+        #   , translation_threshold_ (3e-4 * 3e-4)  // 0.0003 meters
+        #   , mse_threshold_relative_ (0.00001)     // 0.001% of the previous MSE (relative error)
+        #   , mse_threshold_absolute_ (1e-12)       // MSE (absolute error)
+        #   , iterations_similar_transforms_ (0)
+        #   , max_iterations_similar_transforms_ (0)
+        #   , convergence_state_ (CONVERGENCE_CRITERIA_NOT_CONVERGED)
+        # {
+        # }
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~DefaultConvergenceCriteria () {}
+        # 
+        # /** \brief Set the maximum number of iterations that the internal rotation, 
+        #   * translation, and MSE differences are allowed to be similar. 
+        #   * \param[in] nr_iterations the maximum number of iterations 
+        #   */
+        # inline void setMaximumIterationsSimilarTransforms (const int nr_iterations) { max_iterations_similar_transforms_ = nr_iterations; }
+        # 
+        # /** \brief Get the maximum number of iterations that the internal rotation, 
+        #   * translation, and MSE differences are allowed to be similar, as set by the user.
+        #   */
+        # inline int getMaximumIterationsSimilarTransforms () const { return (max_iterations_similar_transforms_); }
+        # 
+        # /** \brief Set the maximum number of iterations the internal optimization should run for.
+        #   * \param[in] nr_iterations the maximum number of iterations the internal optimization should run for
+        #   */
+        # inline void setMaximumIterations (const int nr_iterations) { max_iterations_ = nr_iterations; }
+        # 
+        # /** \brief Get the maximum number of iterations the internal optimization should run for, as set by the user. */
+        # inline int getMaximumIterations () const { return (max_iterations_); }
+        # 
+        # /** \brief Specifies if the registration fails or converges when the maximum number of iterations is reached.
+        #   * \param[in] failure_after_max_iter If true, the registration fails. If false, the registration is assumed to have converged.
+        #   */
+        # inline void setFailureAfterMaximumIterations (const bool failure_after_max_iter) { failure_after_max_iter_ = failure_after_max_iter; }
+        # 
+        # /** \brief Get whether the registration will fail or converge when the maximum number of iterations is reached. */
+        # inline bool getFailureAfterMaximumIterations () const { return (failure_after_max_iter_); }
+        # 
+        # /** \brief Set the rotation threshold cosine angle (maximum allowable difference between two consecutive transformations) in order for an optimization to be considered as having converged to the final solution.
+        #   * \param[in] threshold the rotation threshold in order for an optimization to be considered as having converged to the final solution.
+        #   */
+        # inline void setRotationThreshold (const double threshold) { rotation_threshold_ = threshold; }
+        # 
+        # /** \brief Get the rotation threshold cosine angle (maximum allowable difference between two consecutive transformations) as set by the user.
+        #   */
+        # inline double getRotationThreshold () const { return (rotation_threshold_); }
+        # 
+        # /** \brief Set the translation threshold (maximum allowable difference between two consecutive transformations) in order for an optimization to be considered as having converged to the final solution.
+        #   * \param[in] threshold the translation threshold in order for an optimization to be considered as having converged to the final solution.
+        #   */
+        # inline void setTranslationThreshold (const double threshold) { translation_threshold_ = threshold; }
+        # 
+        # /** \brief Get the rotation threshold cosine angle (maximum allowable difference between two consecutive transformations) as set by the user.
+        #   */
+        # inline double getTranslationThreshold () const { return (translation_threshold_); }
+        # 
+        # /** \brief Set the relative MSE between two consecutive sets of correspondences.
+        #   * \param[in] mse_relative the relative MSE threshold
+        #   */
+        # inline void setRelativeMSE (const double mse_relative) { mse_threshold_relative_ = mse_relative; }
+        # 
+        # /** \brief Get the relative MSE between two consecutive sets of correspondences. */
+        # inline double getRelativeMSE () const { return (mse_threshold_relative_); }
+        # 
+        # /** \brief Set the absolute MSE between two consecutive sets of correspondences.
+        #   * \param[in] mse_absolute the relative MSE threshold
+        #   */
+        # inline void setAbsoluteMSE (const double mse_absolute) { mse_threshold_absolute_ = mse_absolute; }
+        # 
+        # /** \brief Get the absolute MSE between two consecutive sets of correspondences. */
+        # inline double getAbsoluteMSE () const { return (mse_threshold_absolute_); }
+        # 
+        # /** \brief Check if convergence has been reached. */
+        # virtual bool hasConverged ();
+        # 
+        # /** \brief Return the convergence state after hasConverged () */
+        # ConvergenceState getConvergenceState ()
+        # 
+        # /** \brief Sets the convergence state externally (for example, when ICP does not find
+        #  * enough correspondences to estimate a transformation, the function is called setting
+        #  * the convergence state to ConvergenceState::CONVERGENCE_CRITERIA_NO_CORRESPONDENCES)
+        #  * \param[in] c the convergence state
+        #  */
+        # inline void setConvergenceState(ConvergenceState c)
+
+
+###
+
+# distances.h
+#     /** \brief Compute the median value from a set of doubles
+#       * \param[in] fvec the set of doubles
+#       * \param[in] m the number of doubles in the set
+#       */
+#     inline double 
+#     computeMedian (double *fvec, int m)
+#     {
+#       // Copy the values to vectors for faster sorting
+#       std::vector<double> data (m);
+#       memcpy (&data[0], fvec, sizeof (double) * m);
+#       
+#       std::nth_element(data.begin(), data.begin() + (data.size () >> 1), data.end());
+#       return (data[data.size () >> 1]);
+#     }
+# 
+#     /** \brief Use a Huber kernel to estimate the distance between two vectors
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       * \param[in] sigma the sigma value
+#       */
+#     inline double
+#     huber (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt, double sigma) 
+#     {
+#       Eigen::Array4f diff = (p_tgt.array () - p_src.array ()).abs ();
+#       double norm = 0.0;
+#       for (int i = 0; i < 3; ++i)
+#       {
+#         if (diff[i] < sigma)
+#           norm += diff[i] * diff[i];
+#         else
+#           norm += 2.0 * sigma * diff[i] - sigma * sigma;
+#       }
+#       return (norm);
+#     }
+# 
+#     /** \brief Use a Huber kernel to estimate the distance between two vectors
+#       * \param[in] diff the norm difference between two vectors
+#       * \param[in] sigma the sigma value
+#       */
+#     inline double
+#     huber (double diff, double sigma) 
+#     {
+#       double norm = 0.0;
+#       if (diff < sigma)
+#         norm += diff * diff;
+#       else
+#         norm += 2.0 * sigma * diff - sigma * sigma;
+#       return (norm);
+#     }
+# 
+#     /** \brief Use a Gedikli kernel to estimate the distance between two vectors
+#       * (for more information, see 
+#       * \param[in] val the norm difference between two vectors
+#       * \param[in] clipping the clipping value
+#       * \param[in] slope the slope. Default: 4
+#       */
+#     inline double
+#     gedikli (double val, double clipping, double slope = 4) 
+#     {
+#       return (1.0 / (1.0 + pow (fabs(val) / clipping, slope)));
+#     }
+# 
+#     /** \brief Compute the Manhattan distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l1 (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src.array () - p_tgt.array ()).abs ().sum ());
+#     }
+# 
+#     /** \brief Compute the Euclidean distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l2 (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src - p_tgt).norm ());
+#     }
+# 
+#     /** \brief Compute the squared Euclidean distance between two eigen vectors.
+#       * \param[in] p_src the first eigen vector
+#       * \param[in] p_tgt the second eigen vector
+#       */
+#     inline double
+#     l2Sqr (const Eigen::Vector4f &p_src, const Eigen::Vector4f &p_tgt) 
+#     {
+#       return ((p_src - p_tgt).squaredNorm ());
+#     }
+
+
+###
+
+# eigen.h
+# # 
+# #include <Eigen/Core>
+# #include <Eigen/Geometry>
+# #include <unsupported/Eigen/Polynomials>
+# #include <Eigen/Dense>
+###
+
+# elch.h
+# template <typename PointT>
+# class ELCH : public PCLBase<PointT>
+cdef extern from "pcl/registration/elch.h" namespace "pcl::registration" nogil:
+    cdef cppclass ELCH[T](cpp.PCLBase[T]):
+        ELCH()
+#       public:
+#       typedef boost::shared_ptr< ELCH<PointT> > Ptr;
+#       typedef boost::shared_ptr< const ELCH<PointT> > ConstPtr;
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       struct Vertex
+#       {
+#         Vertex () : cloud () {}
+#         PointCloudPtr cloud;
+#       };
+# 
+#       /** \brief graph structure to hold the SLAM graph */
+#       typedef boost::adjacency_list<
+#         boost::listS, boost::vecS, boost::undirectedS,
+#         Vertex,
+#         boost::no_property>
+#       LoopGraph;
+#       typedef boost::shared_ptr< LoopGraph > LoopGraphPtr;
+#       typedef typename pcl::Registration<PointT, PointT> Registration;
+#       typedef typename Registration::Ptr RegistrationPtr;
+#       typedef typename Registration::ConstPtr RegistrationConstPtr;
+#
+#       /** \brief Add a new point cloud to the internal graph.
+#        * \param[in] cloud the new point cloud
+#        */
+#       inline void
+#       addPointCloud (PointCloudPtr cloud)
+# 
+#       /** \brief Getter for the internal graph. */
+#       inline LoopGraphPtr
+#       getLoopGraph ()
+# 
+#       /** \brief Setter for a new internal graph.
+#        * \param[in] loop_graph the new graph
+#        */
+#       inline void
+#       setLoopGraph (LoopGraphPtr loop_graph)
+# 
+#       /** \brief Getter for the first scan of a loop. */
+#       inline typename boost::graph_traits<LoopGraph>::vertex_descriptor
+#       getLoopStart ()
+#
+#       /** \brief Setter for the first scan of a loop.
+#        * \param[in] loop_start the scan that starts the loop
+#        */
+#       inline void
+#       setLoopStart (const typename boost::graph_traits<LoopGraph>::vertex_descriptor &loop_start)
+#
+#       /** \brief Getter for the last scan of a loop. */
+#       inline typename boost::graph_traits<LoopGraph>::vertex_descriptor
+#       getLoopEnd ()
+# 
+#       /** \brief Setter for the last scan of a loop.
+#        * \param[in] loop_end the scan that ends the loop
+#        */
+#       inline void
+#       setLoopEnd (const typename boost::graph_traits<LoopGraph>::vertex_descriptor &loop_end)
+# 
+#       /** \brief Getter for the registration algorithm. */
+#       inline RegistrationPtr
+#       getReg ()
+# 
+#       /** \brief Setter for the registration algorithm.
+#        * \param[in] reg the registration algorithm used to compute the transformation between the start and the end of the loop
+#        */
+#       inline void setReg (RegistrationPtr reg)
+# 
+#       /** \brief Getter for the transformation between the first and the last scan. */
+#       inline Eigen::Matrix4f getLoopTransform ()
+# 
+#       /** \brief Setter for the transformation between the first and the last scan.
+#        * \param[in] loop_transform the transformation between the first and the last scan
+#        */
+#       inline void setLoopTransform (const Eigen::Matrix4f &loop_transform)
+# 
+#       /** \brief Computes now poses for all point clouds by closing the loop
+#        * between start and end point cloud. This will transform all given point
+#        * clouds for now!
+#        */
+#       void compute ();
+
+
+###
+
+# exceptions.h
+# pcl/exceptions
+#  /** \class SolverDidntConvergeException
+#     * \brief An exception that is thrown when the non linear solver didn't converge
+#     */
+#   class PCL_EXPORTS SolverDidntConvergeException : public PCLException
+#   {
+#     public:
+#     
+#     SolverDidntConvergeException (const std::string& error_description,
+#                                   const std::string& file_name = "",
+#                                   const std::string& function_name = "" ,
+#                                   unsigned line_number = 0) throw ()
+#       : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+#   } ;
+# 
+#  /** \class NotEnoughPointsException
+#     * \brief An exception that is thrown when the number of correspondants is not equal
+#     * to the minimum required
+#     */
+#   class PCL_EXPORTS NotEnoughPointsException : public PCLException
+#   {
+#     public:
+#     
+#     NotEnoughPointsException (const std::string& error_description,
+#                               const std::string& file_name = "",
+#                               const std::string& function_name = "" ,
+#                               unsigned line_number = 0) throw ()
+#       : pcl::PCLException (error_description, file_name, function_name, line_number) { }
+#   } ;
+# 
+###
+
+# gicp6d.h
+# namespace pcl
+#   struct EIGEN_ALIGN16 _PointXYZLAB
+#   {
+#     PCL_ADD_POINT4D; // this adds the members x,y,z
+#     union
+#     {
+#       struct
+#       {
+#         float L;
+#         float a;
+#         float b;
+#       };
+#       float data_lab[4];
+#     };
+#     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+#   /** \brief A custom point type for position and CIELAB color value */
+#   struct PointXYZLAB : public _PointXYZLAB
+#   {
+#     inline PointXYZLAB ()
+#     {
+#       x = y = z = 0.0f; data[3]     = 1.0f;  // important for homogeneous coordinates
+#       L = a = b = 0.0f; data_lab[3] = 0.0f;
+#     }
+#   };
+# }
+# 
+# // register the custom point type in PCL
+# POINT_CLOUD_REGISTER_POINT_STRUCT(pcl::_PointXYZLAB,
+#     (float, x, x)
+#     (float, y, y)
+#     (float, z, z)
+#     (float, L, L)
+#     (float, a, a)
+#     (float, b, b)
+# )
+# POINT_CLOUD_REGISTER_POINT_WRAPPER(pcl::PointXYZLAB, pcl::_PointXYZLAB)
+# 
+# namespace pcl
+# {
+# /** \brief GeneralizedIterativeClosestPoint6D integrates L*a*b* color space information into the
+#  * Generalized Iterative Closest Point (GICP) algorithm.
+#  *
+#  * The suggested input is PointXYZRGBA.
+#  *
+#  * \note If you use this code in any academic work, please cite:
+#  *
+#  * - M. Korn, M. Holzkothen, J. Pauli
+#  * Color Supported Generalized-ICP.
+#  * In Proceedings of VISAPP 2014 - International Conference on Computer Vision Theory and Applications,
+#  * Lisbon, Portugal, January 2014.
+#  *
+#  * \author Martin Holzkothen, Michael Korn
+#  * \ingroup registration
+#  */
+# class PCL_EXPORTS GeneralizedIterativeClosestPoint6D : public GeneralizedIterativeClosestPoint<PointXYZRGBA, PointXYZRGBA>
+# {
+#       typedef PointXYZRGBA PointSource;
+#       typedef PointXYZRGBA PointTarget;
+#       public:
+#       
+#       /** \brief constructor.
+#        *
+#        * \param[in] lab_weight the color weight
+#        */
+#       GeneralizedIterativeClosestPoint6D (float lab_weight = 0.032f);
+# 
+#       /** \brief Provide a pointer to the input source
+#        * (e.g., the point cloud that we want to align to the target)
+#        *
+#        * \param[in] cloud the input point cloud source
+#        */
+#       void
+#       setInputSource (const PointCloudSourceConstPtr& cloud);
+# 
+#       /** \brief Provide a pointer to the input target
+#        * (e.g., the point cloud that we want to align the input source to)
+#        *
+#        * \param[in] cloud the input point cloud target
+#        */
+#       void
+#       setInputTarget (const PointCloudTargetConstPtr& target);
+
+
+###
+
+# ia_ransac.h
+# template <typename PointSource, typename PointTarget, typename FeatureT>
+# class SampleConsensusInitialAlignment : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ia_ransac.h" namespace "pcl" nogil:
+    cdef cppclass SampleConsensusInitialAlignment[Source, Target, Feature](Registration[Source, Target, float]):
+        SampleConsensusInitialAlignment() except +
+        # public:
+        # using Registration<PointSource, PointTarget>::reg_name_;
+        # using Registration<PointSource, PointTarget>::input_;
+        # using Registration<PointSource, PointTarget>::indices_;
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # using Registration<PointSource, PointTarget>::corr_dist_threshold_;
+        # using Registration<PointSource, PointTarget>::min_number_correspondences_;
+        # using Registration<PointSource, PointTarget>::max_iterations_;
+        # using Registration<PointSource, PointTarget>::tree_;
+        # using Registration<PointSource, PointTarget>::transformation_estimation_;
+        # using Registration<PointSource, PointTarget>::getClassName;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # ctypedef pcl::PointCloud<FeatureT> FeatureCloud;
+        # ctypedef typename FeatureCloud::Ptr FeatureCloudPtr;
+        # ctypedef typename FeatureCloud::ConstPtr FeatureCloudConstPtr;
+        # cdef cppclass ErrorFunctor
+        # {
+        #   public:
+        #     virtual ~ErrorFunctor () {}
+        #     virtual float operator () (float d) const = 0;
+        # };
+        # 
+        # class HuberPenalty : public ErrorFunctor
+        # cdef cppclass HuberPenalty(ErrorFunctor)
+        #     HuberPenalty ()
+        #   public:
+        #     HuberPenalty (float threshold)
+        #     virtual float operator () (float e) const
+        #     { 
+        #       if (e <= threshold_)
+        #         return (0.5 * e*e); 
+        #       else
+        #         return (0.5 * threshold_ * (2.0 * fabs (e) - threshold_));
+        #     }
+        #   protected:
+        #     float threshold_;
+        # };
+        # 
+        # class TruncatedError : public ErrorFunctor
+        # cdef cppclass TruncatedError(ErrorFunctor)
+        #     TruncatedError ()
+        #   public:
+        #     virtual ~TruncatedError () {}
+        #     TruncatedError (float threshold) : threshold_ (threshold) {}
+        #     virtual float operator () (float e) const
+        #     { 
+        #       if (e <= threshold_)
+        #         return (e / threshold_);
+        #       else
+        #         return (1.0);
+        #     }
+        #   protected:
+        #     float threshold_;
+        # };
+        # 
+        # typedef typename KdTreeFLANN<FeatureT>::Ptr FeatureKdTreePtr; 
+        # 
+        # /** \brief Provide a boost shared pointer to the source point cloud's feature descriptors
+        #   * \param features the source point cloud's features
+        #   */
+        # void setSourceFeatures (const FeatureCloudConstPtr &features);
+        # 
+        # /** \brief Get a pointer to the source point cloud's features */
+        # inline FeatureCloudConstPtr const getSourceFeatures () { return (input_features_); }
+        # 
+        # /** \brief Provide a boost shared pointer to the target point cloud's feature descriptors
+        #   * \param features the target point cloud's features
+        #   */
+        # void setTargetFeatures (const FeatureCloudConstPtr &features);
+        # 
+        # /** \brief Get a pointer to the target point cloud's features */
+        # inline FeatureCloudConstPtr const getTargetFeatures () { return (target_features_); }
+        # 
+        # /** \brief Set the minimum distances between samples
+        #   * \param min_sample_distance the minimum distances between samples
+        #   */
+        # void setMinSampleDistance (float min_sample_distance) { min_sample_distance_ = min_sample_distance; }
+        # 
+        # /** \brief Get the minimum distances between samples, as set by the user */
+        # float getMinSampleDistance () { return (min_sample_distance_); }
+        # 
+        # /** \brief Set the number of samples to use during each iteration
+        #   * \param nr_samples the number of samples to use during each iteration
+        #   */
+        # void setNumberOfSamples (int nr_samples) { nr_samples_ = nr_samples; }
+        # 
+        # /** \brief Get the number of samples to use during each iteration, as set by the user */
+        # int getNumberOfSamples () { return (nr_samples_); }
+        # 
+        # /** \brief Set the number of neighbors to use when selecting a random feature correspondence.  A higher value will
+        #   * add more randomness to the feature matching.
+        #   * \param k the number of neighbors to use when selecting a random feature correspondence.
+        #   */
+        # void setCorrespondenceRandomness (int k) { k_correspondences_ = k; }
+        # 
+        # /** \brief Get the number of neighbors used when selecting a random feature correspondence, as set by the user */
+        # int getCorrespondenceRandomness () { return (k_correspondences_); }
+        # 
+        # /** \brief Specify the error function to minimize
+        #  * \note This call is optional.  TruncatedError will be used by default
+        #  * \param[in] error_functor a shared pointer to a subclass of SampleConsensusInitialAlignment::ErrorFunctor
+        #  */
+        # void setErrorFunction (const boost::shared_ptr<ErrorFunctor> & error_functor) { error_functor_ = error_functor; }
+        # 
+        # /** \brief Get a shared pointer to the ErrorFunctor that is to be minimized  
+        #  * \return A shared pointer to a subclass of SampleConsensusInitialAlignment::ErrorFunctor
+        #  */
+        # boost::shared_ptr<ErrorFunctor> getErrorFunction () { return (error_functor_); }
+
+
+###
+
+# pcl 1.7.2 error(linux pcl package)
+# joint_icp.h
+# /** \brief @b JointIterativeClosestPoint extends ICP to multiple frames which
+#   *  share the same transform. This is particularly useful when solving for 
+#   *  camera extrinsics using multiple observations. When given a single pair of 
+#   *  clouds, this reduces to vanilla ICP.
+#   * \author Stephen Miller
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class JointIterativeClosestPoint : public IterativeClosestPoint<PointSource, PointTarget, Scalar>
+# cdef extern from "pcl/registration/joint_icp.h" namespace "pcl" nogil:
+#     cdef cppclass JointIterativeClosestPoint[Source, Target, float](IterativeClosestPoint[Source, Target, float]):
+#         JointIterativeClosestPoint() except +
+        # public:
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::PointCloudTarget PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef pcl::search::KdTree<PointTarget> KdTree;
+        # typedef typename pcl::search::KdTree<PointTarget>::Ptr KdTreePtr;
+        # typedef pcl::search::KdTree<PointSource> KdTreeReciprocal;
+        # typedef typename KdTree::Ptr KdTreeReciprocalPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # typedef boost::shared_ptr<JointIterativeClosestPoint<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const JointIterativeClosestPoint<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename pcl::registration::CorrespondenceEstimationBase<PointSource, PointTarget, Scalar> CorrespondenceEstimation;
+        # typedef typename CorrespondenceEstimation::Ptr CorrespondenceEstimationPtr;
+        # typedef typename CorrespondenceEstimation::ConstPtr CorrespondenceEstimationConstPtr;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::reg_name_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::getClassName;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::setInputSource;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::input_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::indices_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::target_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::nr_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::max_iterations_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::previous_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::final_transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_epsilon_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::converged_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::corr_dist_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::inlier_threshold_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::min_number_correspondences_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::update_visualizer_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::euclidean_fitness_epsilon_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondences_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::transformation_estimation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondence_estimation_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::correspondence_rejectors_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::use_reciprocal_correspondence_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::convergence_criteria_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::source_has_normals_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::target_has_normals_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::need_source_blob_;
+        # using IterativeClosestPoint<PointSource, PointTarget, Scalar>::need_target_blob_;
+        # typedef typename IterativeClosestPoint<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Empty constructor. */
+        # JointIterativeClosestPoint ()
+        
+        # /** \brief Empty destructor */
+        # virtual ~JointIterativeClosestPoint () {}
+        
+        # /** \brief Provide a pointer to the input source 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   */
+        # virtual void setInputSource (const PointCloudSourceConstPtr& /*cloud*/)
+        # void setInputSource (const PointCloudSourceConstPtr& /*cloud*/)
+        
+        # /** \brief Add a source cloud to the joint solver
+        #   * \param[in] cloud source cloud
+        #   */
+        # inline void addInputSource (const PointCloudSourceConstPtr &cloud)
+        # void addInputSource (const PointCloudSourceConstPtr &cloud)
+        
+        # /** \brief Provide a pointer to the input target 
+        #   * (e.g., the point cloud that we want to align to the target)
+        #   */
+        # virtual void setInputTarget (const PointCloudTargetConstPtr& /*cloud*/)
+        # void setInputTarget (const PointCloudTargetConstPtr& /*cloud*/)
+        
+        # /** \brief Add a target cloud to the joint solver
+        #   *
+        #   * \param[in] cloud target cloud
+        #   */
+        # inline void addInputTarget (const PointCloudTargetConstPtr &cloud)
+        # void addInputTarget (const PointCloudTargetConstPtr &cloud)
+        
+        # /** \brief Add a manual correspondence estimator
+        #   * If you choose to do this, you must add one for each 
+        #   * input source / target pair. They do not need to have trees 
+        #   * or input clouds set ahead of time.
+        #   *
+        #   * \param[in] ce Correspondence estimation
+        #   */
+        # inline void addCorrespondenceEstimation (CorrespondenceEstimationPtr ce)
+        # void addCorrespondenceEstimation (CorrespondenceEstimationPtr ce)
+        
+        # /** \brief Reset my list of input sources
+        #   */
+        # inline void clearInputSources ()
+        void clearInputSources ()
+        
+        # /** \brief Reset my list of input targets
+        #   */
+        # inline void clearInputTargets ()
+        void clearInputTargets ()
+        
+        # /** \brief Reset my list of correspondence estimation methods.
+        #   */
+        # inline void clearCorrespondenceEstimations ()
+
+
+###
+
+# lum.h
+# namespace Eigen
+# {
+#   typedef Eigen::Matrix<float, 6, 1> Vector6f;
+#   typedef Eigen::Matrix<float, 6, 6> Matrix6f;
+# }
+# 
+
+# lum.h
+# namespace pcl
+# namespace registration
+# /** \brief Globally Consistent Scan Matching based on an algorithm by Lu and Milios.
+#   * \details A GraphSLAM algorithm where registration data is managed in a graph:
+#   * <ul>
+#   *  <li>Vertices represent poses and hold the point cloud data and relative transformations.</li>
+#   *  <li>Edges represent pose constraints and hold the correspondence data between two point clouds.</li>
+#   * </ul>
+#   * Computation uses the first point cloud in the SLAM graph as a reference pose and attempts to align all other point clouds to it simultaneously.
+#   * For more information:
+#   * <ul><li>
+#   * F. Lu, E. Milios,
+#   * Globally Consistent Range Scan Alignment for Environment Mapping,
+#   * Autonomous Robots 4, April 1997
+#   * </li><li>
+#   * Dorit Borrmann, Jan Elseberg, Kai Lingemann, Andreas Nuchter, and Joachim Hertzberg,
+#   * The Efficient Extension of Globally Consistent Scan Matching to 6 DoF,
+#   * In Proceedings of the 4th International Symposium on 3D Data Processing, Visualization and Transmission (3DPVT '08), June 2008
+#   * </li></ul>
+#   * Usage example:
+#   * \code
+#   * pcl::registration::LUM<pcl::PointXYZ> lum;
+#   * // Add point clouds as vertices to the SLAM graph
+#   * lum.addPointCloud (cloud_0);
+#   * lum.addPointCloud (cloud_1);
+#   * lum.addPointCloud (cloud_2);
+#   * // Use your favorite pairwise correspondence estimation algorithm(s)
+#   * corrs_0_to_1 = someAlgo (cloud_0, cloud_1);
+#   * corrs_1_to_2 = someAlgo (cloud_1, cloud_2);
+#   * corrs_2_to_0 = someAlgo (lum.getPointCloud (2), lum.getPointCloud (0));
+#   * // Add the correspondence results as edges to the SLAM graph
+#   * lum.setCorrespondences (0, 1, corrs_0_to_1);
+#   * lum.setCorrespondences (1, 2, corrs_1_to_2);
+#   * lum.setCorrespondences (2, 0, corrs_2_to_0);
+#   * // Change the computation parameters
+#   * lum.setMaxIterations (5);
+#   * lum.setConvergenceThreshold (0.0);
+#   * // Perform the actual LUM computation
+#   * lum.compute ();
+#   * // Return the concatenated point cloud result
+#   * cloud_out = lum.getConcatenatedCloud ();
+#   * // Return the separate point cloud transformations
+#   * for(int i = 0; i < lum.getNumVertices (); i++)
+#   * {
+#   *   transforms_out[i] = lum.getTransformation (i);
+#   * }
+#   * \endcode
+#   * \author Frits Florentinus, Jochen Sprickerhof
+#   * \ingroup registration
+#   */
+# template<typename PointT>
+# class LUM
+cdef extern from "pcl/registration/lum.h" namespace "pcl" nogil:
+    cdef cppclass LUM[Point]:
+        LUM()
+        # public:
+        # typedef boost::shared_ptr<LUM<PointT> > Ptr;
+        # typedef boost::shared_ptr<const LUM<PointT> > ConstPtr;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # 
+        # struct VertexProperties
+        # {
+        #   PointCloudPtr cloud_;
+        #   Eigen::Vector6f pose_;
+        #   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+        # };
+        # struct EdgeProperties
+        # {
+        #   pcl::CorrespondencesPtr corrs_;
+        #   Eigen::Matrix6f cinv_;
+        #   Eigen::Vector6f cinvd_;
+        #   EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+        # };
+        # 
+        # typedef boost::adjacency_list<boost::eigen_vecS, boost::eigen_vecS, boost::bidirectionalS, VertexProperties, EdgeProperties, boost::no_property, boost::eigen_listS> SLAMGraph;
+        # typedef boost::shared_ptr<SLAMGraph> SLAMGraphPtr;
+        # typedef typename SLAMGraph::vertex_descriptor Vertex;
+        # typedef typename SLAMGraph::edge_descriptor Edge;
+        # 
+        # /** \brief Empty constructor.
+        #   */
+        # LUM () 
+        #   : slam_graph_ (new SLAMGraph)
+        #   , max_iterations_ (5)
+        #   , convergence_threshold_ (0.0)
+        # {
+        # }
+        # 
+        # /** \brief Set the internal SLAM graph structure.
+        #   * \details All data used and produced by LUM is stored in this boost::adjacency_list.
+        #   * It is recommended to use the LUM class itself to build the graph.
+        #   * This method could otherwise be useful for managing several SLAM graphs in one instance of LUM.
+        #   * \param[in] slam_graph The new SLAM graph.
+        #   */
+        # inline void setLoopGraph (const SLAMGraphPtr &slam_graph);
+        # 
+        # /** \brief Get the internal SLAM graph structure.
+        #   * \details All data used and produced by LUM is stored in this boost::adjacency_list.
+        #   * It is recommended to use the LUM class itself to build the graph.
+        #   * This method could otherwise be useful for managing several SLAM graphs in one instance of LUM.
+        #   * \return The current SLAM graph.
+        #   */
+        # inline SLAMGraphPtr getLoopGraph () const;
+        # 
+        # /** \brief Get the number of vertices in the SLAM graph.
+        #   * \return The current number of vertices in the SLAM graph.
+        #   */
+        # typename SLAMGraph::vertices_size_type getNumVertices () const;
+        # 
+        # /** \brief Set the maximum number of iterations for the compute() method.
+        #   * \details The compute() method finishes when max_iterations are met or when the convergence criteria is met.
+        #   * \param[in] max_iterations The new maximum number of iterations (default = 5).
+        #   */
+        # void setMaxIterations (int max_iterations);
+        # 
+        # /** \brief Get the maximum number of iterations for the compute() method.
+        #   * \details The compute() method finishes when max_iterations are met or when the convergence criteria is met.
+        #   * \return The current maximum number of iterations (default = 5).
+        #   */
+        # inline int getMaxIterations () const;
+        # 
+        # /** \brief Set the convergence threshold for the compute() method.
+        #   * \details When the compute() method computes the new poses relative to the old poses, it will determine the length of the difference vector.
+        #   * When the average length of all difference vectors becomes less than the convergence_threshold the convergence is assumed to be met.
+        #   * \param[in] convergence_threshold The new convergence threshold (default = 0.0).
+        #   */
+        # void setConvergenceThreshold (float convergence_threshold);
+        # 
+        # /** \brief Get the convergence threshold for the compute() method.
+        #   * \details When the compute() method computes the new poses relative to the old poses, it will determine the length of the difference vector.
+        #   * When the average length of all difference vectors becomes less than the convergence_threshold the convergence is assumed to be met.
+        #   * \return The current convergence threshold (default = 0.0).
+        #   */
+        # inline float getConvergenceThreshold () const;
+        # 
+        # /** \brief Add a new point cloud to the SLAM graph.
+        #   * \details This method will add a new vertex to the SLAM graph and attach a point cloud to that vertex.
+        #   * Optionally you can specify a pose estimate for this point cloud.
+        #   * A vertex' pose is always relative to the first vertex in the SLAM graph, i.e. the first point cloud that was added.
+        #   * Because this first vertex is the reference, you can not set a pose estimate for this vertex.
+        #   * Providing pose estimates to the vertices in the SLAM graph will reduce overall computation time of LUM.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] cloud The new point cloud.
+        #   * \param[in] pose (optional) The pose estimate relative to the reference pose (first point cloud that was added).
+        #   * \return The vertex descriptor of the newly created vertex.
+        #   */
+        # Vertex addPointCloud (const PointCloudPtr &cloud, const Eigen::Vector6f &pose = Eigen::Vector6f::Zero ());
+        # 
+        # /** \brief Change a point cloud on one of the SLAM graph's vertices.
+        #   * \details This method will change the point cloud attached to an existing vertex and will not alter the SLAM graph structure.
+        #   * Note that the correspondences attached to this vertex will not change and may need to be updated manually.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to change the point cloud.
+        #   * \param[in] cloud The new point cloud for that vertex.
+        #   */
+        # inline void setPointCloud (const Vertex &vertex, const PointCloudPtr &cloud);
+        # 
+        # /** \brief Return a point cloud from one of the SLAM graph's vertices.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the point cloud.
+        #   * \return The current point cloud for that vertex.
+        #   */
+        # inline PointCloudPtr getPointCloud (const Vertex &vertex) const;
+        # 
+        # /** \brief Change a pose estimate on one of the SLAM graph's vertices.
+        #   * \details A vertex' pose is always relative to the first vertex in the SLAM graph, i.e. the first point cloud that was added.
+        #   * Because this first vertex is the reference, you can not set a pose estimate for this vertex.
+        #   * Providing pose estimates to the vertices in the SLAM graph will reduce overall computation time of LUM.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to set the pose estimate.
+        #   * \param[in] pose The new pose estimate for that vertex.
+        #   */
+        # inline void setPose (const Vertex &vertex, const Eigen::Vector6f &pose);
+        # 
+        # /** \brief Return a pose estimate from one of the SLAM graph's vertices.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the pose estimate.
+        #   * \return The current pose estimate of that vertex.
+        #   */
+        # inline Eigen::Vector6f getPose (const Vertex &vertex) const;
+        # 
+        # /** \brief Return a pose estimate from one of the SLAM graph's vertices as an affine transformation matrix.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the transformation matrix.
+        #   * \return The current transformation matrix of that vertex.
+        #   */
+        # inline Eigen::Affine3f getTransformation (const Vertex &vertex) const;
+        # 
+        # /** \brief Add/change a set of correspondences for one of the SLAM graph's edges.
+        #   * \details The edges in the SLAM graph are directional and point from source vertex to target vertex.
+        #   * The query indices of the correspondences, index the points at the source vertex' point cloud.
+        #   * The matching indices of the correspondences, index the points at the target vertex' point cloud.
+        #   * If no edge was present at the specified location, this method will add a new edge to the SLAM graph and attach the correspondences to that edge.
+        #   * If the edge was already present, this method will overwrite the correspondence information of that edge and will not alter the SLAM graph structure.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] source_vertex The vertex descriptor of the correspondences' source point cloud.
+        #   * \param[in] target_vertex The vertex descriptor of the correspondences' target point cloud.
+        #   * \param[in] corrs The new set of correspondences for that edge.
+        #   */
+        # void setCorrespondences (const Vertex &source_vertex, 
+        #                     const Vertex &target_vertex, 
+        #                     const pcl::CorrespondencesPtr &corrs);
+        # 
+        # /** \brief Return a set of correspondences from one of the SLAM graph's edges.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] source_vertex The vertex descriptor of the correspondences' source point cloud.
+        #   * \param[in] target_vertex The vertex descriptor of the correspondences' target point cloud.
+        #   * \return The current set of correspondences of that edge.
+        #   */
+        # inline pcl::CorrespondencesPtr getCorrespondences (const Vertex &source_vertex, const Vertex &target_vertex) const;
+        # 
+        # /** \brief Perform LUM's globally consistent scan matching.
+        #   * \details Computation uses the first point cloud in the SLAM graph as a reference pose and attempts to align all other point clouds to it simultaneously.
+        #   * <br>
+        #   * Things to keep in mind:
+        #   * <ul>
+        #   *  <li>Only those parts of the graph connected to the reference pose will properly align to it.</li>
+        #   *  <li>All sets of correspondences should span the same space and need to be sufficient to determine a rigid transformation.</li>
+        #   *  <li>The algorithm draws it strength from loops in the graph because it will distribute errors evenly amongst those loops.</li>
+        #   * </ul>
+        #   * Computation ends when either of the following conditions hold:
+        #   * <ul>
+        #   *  <li>The number of iterations reaches max_iterations. Use setMaxIterations() to change.</li>
+        #   *  <li>The convergence criteria is met. Use setConvergenceThreshold() to change.</li>
+        #   * </ul>
+        #   * Computation will change the pose estimates for the vertices of the SLAM graph, not the point clouds attached to them.
+        #   * The results can be retrieved with getPose(), getTransformation(), getTransformedCloud() or getConcatenatedCloud().
+        #   */
+        # void compute ();
+        # 
+        # /** \brief Return a point cloud from one of the SLAM graph's vertices compounded onto its current pose estimate.
+        #   * \note Vertex descriptors are typecastable to int.
+        #   * \param[in] vertex The vertex descriptor of which to return the transformed point cloud.
+        #   * \return The transformed point cloud of that vertex.
+        #   */
+        # PointCloudPtr getTransformedCloud (const Vertex &vertex) const;
+        # 
+        # /** \brief Return a concatenated point cloud of all the SLAM graph's point clouds compounded onto their current pose estimates.
+        #   * \return The concatenated transformed point clouds of the entire SLAM graph.
+        #   */
+        # PointCloudPtr getConcatenatedCloud () const;
+
+
+###
+
+# ndt.h
+# namespace pcl
+# /** \brief A 3D Normal Distribution Transform registration implementation for point cloud data.
+#   * \note For more information please see
+#   * <b>Magnusson, M. (2009). The Three-Dimensional Normal-Distributions Transform  
+#   * an Ef
珣ient Representation for Registration, Surface Analysis, and Loop Detection.
+#   * PhD thesis, Orebro University. Orebro Studies in Technology 36.</b>,
+#   * <b>More, J., and Thuente, D. (1994). Line Search Algorithm with Guaranteed Sufficient Decrease
+#   * In ACM Transactions on Mathematical Software.</b> and
+#   * Sun, W. and Yuan, Y, (2006) Optimization Theory and Methods: Nonlinear Programming. 89-100
+#   * \note Math refactored by Todor Stoyanov.
+#   * \author Brian Okorn (Space and Naval Warfare Systems Center Pacific)
+#   */
+# template<typename PointSource, typename PointTarget>
+# class NormalDistributionsTransform : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ndt.h" namespace "pcl" nogil:
+    cdef cppclass NormalDistributionsTransform[Source, Target](Registration[Source, Target, float]):
+        NormalDistributionsTransform()
+        # protected:
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # typedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # typedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # /** \brief Typename of searchable voxel grid containing mean and covariance. */
+        # typedef VoxelGridCovariance<PointTarget> TargetGrid;
+        # /** \brief Typename of pointer to searchable voxel grid. */
+        # typedef TargetGrid* TargetGridPtr;
+        # /** \brief Typename of const pointer to searchable voxel grid. */
+        # typedef const TargetGrid* TargetGridConstPtr;
+        # /** \brief Typename of const pointer to searchable voxel grid leaf. */
+        # typedef typename TargetGrid::LeafConstPtr TargetGridLeafConstPtr;
+        # 
+        # public:
+        # typedef boost::shared_ptr< NormalDistributionsTransform<PointSource, PointTarget> > Ptr;
+        # typedef boost::shared_ptr< const NormalDistributionsTransform<PointSource, PointTarget> > ConstPtr;
+        # /** \brief Constructor.
+        #   * Sets \ref outlier_ratio_ to 0.35, \ref step_size_ to 0.05 and \ref resolution_ to 1.0
+        #   */
+        # NormalDistributionsTransform ();
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~NormalDistributionsTransform () {}
+        # 
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to).
+        #   * \param[in] cloud the input point cloud target
+        #   */
+        # inline void setInputTarget (const PointCloudTargetConstPtr &cloud)
+        # void setInputTarget (const Registration[Source, Target, float] &cloud)
+        
+        # 
+        # /** \brief Set/change the voxel grid resolution.
+        #   * \param[in] resolution side length of voxels
+        #   */
+        # inline void setResolution (float resolution)
+        void setResolution (float resolution)
+        
+        # /** \brief Get voxel grid resolution.
+        #   * \return side length of voxels
+        #   */
+        # inline float getResolution () const
+        float getResolution ()
+        
+        # /** \brief Get the newton line search maximum step length.
+        #   * \return maximum step length
+        #   */
+        # inline double getStepSize () const
+        double getStepSize ()
+        
+        # /** \brief Set/change the newton line search maximum step length.
+        #   * \param[in] step_size maximum step length
+        #   */
+        # inline void setStepSize (double step_size)
+        void setStepSize (double step_size)
+        
+        # /** \brief Get the point cloud outlier ratio.
+        #   * \return outlier ratio
+        #   */
+        # inline double getOulierRatio () const
+        double getOulierRatio ()
+        
+        # /** \brief Set/change the point cloud outlier ratio.
+        #   * \param[in] outlier_ratio outlier ratio
+        #   */
+        # inline void setOulierRatio (double outlier_ratio)
+        void setOulierRatio (double outlier_ratio)
+        
+        # /** \brief Get the registration alignment probability.
+        #   * \return transformation probability
+        #   */
+        # inline double getTransformationProbability () const
+        double getTransformationProbability ()
+        
+        # /** \brief Get the number of iterations required to calculate alignment.
+        #   * \return final number of iterations
+        #   */
+        # inline int getFinalNumIteration () const
+        int getFinalNumIteration ()
+        
+        # /** \brief Convert 6 element transformation vector to affine transformation.
+        #   * \param[in] x transformation vector of the form [x, y, z, roll, pitch, yaw]
+        #   * \param[out] trans affine transform corresponding to given transfomation vector
+        #   */
+        # static void convertTransform (const Eigen::Matrix<double, 6, 1> &x, Eigen::Affine3f &trans)
+        # 
+        # /** \brief Convert 6 element transformation vector to transformation matrix.
+        #   * \param[in] x transformation vector of the form [x, y, z, roll, pitch, yaw]
+        #   * \param[out] trans 4x4 transformation matrix corresponding to given transfomation vector
+        #   */
+        # static void convertTransform (const Eigen::Matrix<double, 6, 1> &x, Eigen::Matrix4f &trans)
+
+
+ctypedef NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ] NormalDistributionsTransform_t
+ctypedef NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI] NormalDistributionsTransform_PointXYZI_t
+ctypedef NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB] NormalDistributionsTransform_PointXYZRGB_t
+ctypedef NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA] NormalDistributionsTransform_PointXYZRGBA_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZ, cpp.PointXYZ]] NormalDistributionsTransformPtr_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZI, cpp.PointXYZI]] NormalDistributionsTransform_PointXYZI_Ptr_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGB, cpp.PointXYZRGB]] NormalDistributionsTransform_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[NormalDistributionsTransform[cpp.PointXYZRGBA, cpp.PointXYZRGBA]] NormalDistributionsTransform_PointXYZRGBA_Ptr_t
+###
+
+# ndt_2d.h
+# namespace pcl
+# /** \brief @b NormalDistributionsTransform2D provides an implementation of the
+#   * Normal Distributions Transform algorithm for scan matching.
+#   * This implementation is intended to match the definition:
+#   * Peter Biber and Wolfgang Straser. The normal distributions transform: A
+#   * new approach to laser scan matching. In Proceedings of the IEEE In-
+#   * ternational Conference on Intelligent Robots and Systems (IROS), pages
+#   * 2743 2748, Las Vegas, USA, October 2003.
+#   * \author James Crosby
+#   */
+# template <typename PointSource, typename PointTarget>
+# class NormalDistributionsTransform2D : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ndt_2d.h" namespace "pcl" nogil:
+    cdef cppclass NormalDistributionsTransform2D[Source, Target, float](Registration[Source, Target, float]):
+        NormalDistributionsTransform2D()
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # public:
+        # typedef boost::shared_ptr< NormalDistributionsTransform2D<PointSource, PointTarget> > Ptr;
+        # typedef boost::shared_ptr< const NormalDistributionsTransform2D<PointSource, PointTarget> > ConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # NormalDistributionsTransform2D ()
+        #   : Registration<PointSource,PointTarget> (),
+        #     grid_centre_ (0,0), grid_step_ (1,1), grid_extent_ (20,20), newton_lambda_ (1,1,1)
+        # 
+        # /** \brief Empty destructor */
+        # virtual ~NormalDistributionsTransform2D () {}
+        # 
+        # /** \brief centre of the ndt grid (target coordinate system)
+        #   * \param centre value to set
+        #   */
+        # virtual void setGridCentre (const Eigen::Vector2f& centre) { grid_centre_ = centre; }
+        # 
+        # /** \brief Grid spacing (step) of the NDT grid
+        #   * \param[in] step value to set
+        #   */
+        # virtual void setGridStep (const Eigen::Vector2f& step) { grid_step_ = step; }
+        # 
+        # /** \brief NDT Grid extent (in either direction from the grid centre)
+        #   * \param[in] extent value to set
+        #   */
+        # virtual void setGridExtent (const Eigen::Vector2f& extent) { grid_extent_ = extent; }
+        # 
+        # /** \brief NDT Newton optimisation step size parameter
+        #   * \param[in] lambda step size: 1 is simple newton optimisation, smaller values may improve convergence
+        #   */
+        #  virtual void setOptimizationStepSize (const double& lambda) { newton_lambda_ = Eigen::Vector3d (lambda, lambda, lambda); }
+        # 
+        # /** \brief NDT Newton optimisation step size parameter
+        #   * \param[in] lambda step size: (1,1,1) is simple newton optimisation,
+        #   * smaller values may improve convergence, or elements may be set to
+        #   * zero to prevent optimisation over some parameters
+        #   *
+        #   * This overload allows control of updates to the individual (x, y,
+        #   * theta) free parameters in the optimisation. If, for example, theta is
+        #   * believed to be close to the correct value a small value of lambda[2]
+        #   * should be used.
+        #   */
+        #  virtual void setOptimizationStepSize (const Eigen::Vector3d& lambda) { newton_lambda_ = lambda; }
+
+
+###
+
+# NG : PCL1.7.2 AppVeyor
+# ErrorLog
+# C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\xhash(29): error C2440: 'type cast': cannot convert from 'const pcl::PPFHashMapSearch::HashKeyStruct' to 'std::size_t'
+# C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\xhash(29): note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called
+# ppf_registration.h
+# template <typename PointSource, typename PointTarget>
+# class PPFRegistration : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/ppf_registration.h" namespace "pcl" nogil:
+    cdef cppclass PPFRegistration[Source, Target, float](Registration[Source, Target, float]):
+        PPFRegistration() except +
+        # public:
+        # cdef struct PoseWithVotes
+        #   PoseWithVotes(Eigen::Affine3f &a_pose, unsigned int &a_votes)
+        #   Eigen::Affine3f pose;
+        #   unsigned int votes;
+        # ctypedef std::vector<PoseWithVotes, Eigen::aligned_allocator<PoseWithVotes> > PoseWithVotesList;
+        # /// input_ is the model cloud
+        # using Registration<PointSource, PointTarget>::input_;
+        # /// target_ is the scene cloud
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::converged_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # ctypedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # 
+        # /** \brief Method for setting the position difference clustering parameter
+        #    * \param clustering_position_diff_threshold distance threshold below which two poses are
+        #  * considered close enough to be in the same cluster (for the clustering phase of the algorithm)
+        #  */
+        # inline void setPositionClusteringThreshold (float clustering_position_diff_threshold)
+        void setPositionClusteringThreshold (float clustering_position_diff_threshold)
+        
+        # /** \brief Returns the parameter defining the position difference clustering parameter -
+        #  * distance threshold below which two poses are considered close enough to be in the same cluster
+        #    * (for the clustering phase of the algorithm)
+        #  */
+        # inline float getPositionClusteringThreshold ()
+        float getPositionClusteringThreshold ()
+        
+        # /** \brief Method for setting the rotation clustering parameter
+        #  * \param clustering_rotation_diff_threshold rotation difference threshold below which two
+        #  * poses are considered to be in the same cluster (for the clustering phase of the algorithm)
+        #  */
+        # inline void setRotationClusteringThreshold (float clustering_rotation_diff_threshold)
+        void setRotationClusteringThreshold (float clustering_rotation_diff_threshold)
+        
+        # /** \brief Returns the parameter defining the rotation clustering threshold
+        #  */
+        # inline float getRotationClusteringThreshold ()
+        float getRotationClusteringThreshold ()
+        
+        # /** \brief Method for setting the scene reference point sampling rate
+        #  * \param scene_reference_point_sampling_rate sampling rate for the scene reference point
+        #  */
+        # inline void setSceneReferencePointSamplingRate (unsigned int scene_reference_point_sampling_rate) { scene_reference_point_sampling_rate_ = scene_reference_point_sampling_rate; }
+        void setSceneReferencePointSamplingRate (unsigned int scene_reference_point_sampling_rate)
+        
+        # /** \brief Returns the parameter for the scene reference point sampling rate of the algorithm */
+        # inline unsigned int getSceneReferencePointSamplingRate ()
+        unsigned int getSceneReferencePointSamplingRate ()
+        
+        # 
+        # /** \brief Function that sets the search method for the algorithm
+        #  * \note Right now, the only available method is the one initially proposed by
+        #  * the authors - by using a hash map with discretized feature vectors
+        #  * \param search_method smart pointer to the search method to be set
+        #  */
+        # inline void setSearchMethod (PPFHashMapSearch::Ptr search_method)
+        # void setSearchMethod (PPFHashMapSearch::Ptr search_method)
+        
+        # 
+        # /** \brief Getter function for the search method of the class */
+        # inline PPFHashMapSearch::Ptr getSearchMethod ()
+        # PPFHashMapSearch::Ptr getSearchMethod ()
+        
+        # /** \brief Provide a pointer to the input target (e.g., the point cloud that we want to align the input source to)
+        #  * \param cloud the input point cloud target
+        #  */
+        # void setInputTarget (const PointCloudTargetConstPtr &cloud);
+        # void setInputTarget (const cpp.PointCloud[Target] &cloud);
+
+
+###
+
+# pyramid_feature_matching.h
+# template <typename PointFeature>
+# class PyramidFeatureHistogram : public PCLBase<PointFeature>
+# cdef cppclass PyramidFeatureHistogram[PointFeature](PCLBase[PointFeature]):
+cdef extern from "pcl/registration/pyramid_feature_matching.h" namespace "pcl" nogil:
+    cdef cppclass PyramidFeatureHistogram[PointFeature]:
+        PyramidFeatureHistogram() except +
+        # public:
+        # using PCLBase<PointFeature>::input_;
+        # ctypedef boost::shared_ptr<PyramidFeatureHistogram<PointFeature> > Ptr;
+        # ctypedef Ptr PyramidFeatureHistogramPtr;
+        # ctypedef boost::shared_ptr<const pcl::PointRepresentation<PointFeature> > FeatureRepresentationConstPtr;
+        # /** \brief Method for setting the input dimension range parameter.
+        #  * \note Please check the PyramidHistogram class description for more details about this parameter.
+        #  */
+        # inline void setInputDimensionRange (std::vector<std::pair<float, float> > &dimension_range_input)
+        # void setInputDimensionRange (vector[pair[float, float] ] &dimension_range_input)
+        
+        # /** \brief Method for retrieving the input dimension range vector */
+        # inline std::vector<std::pair<float, float> > getInputDimensionRange () { return dimension_range_input_; }
+        # vector[pair[float, float] ] getInputDimensionRange ()
+        
+        # /** \brief Method to set the target dimension range parameter.
+        #  * \note Please check the PyramidHistogram class description for more details about this parameter.
+        #  */
+        # inline void setTargetDimensionRange (std::vector<std::pair<float, float> > &dimension_range_target)
+        void setTargetDimensionRange (vector[pair[float, float] ] &dimension_range_target)
+        
+        # /** \brief Method for retrieving the target dimension range vector */
+        # inline std::vector<std::pair<float, float> > getTargetDimensionRange () { return dimension_range_target_; }
+        vector[pair[float, float] ] getTargetDimensionRange ()
+        
+        # /** \brief Provide a pointer to the feature representation to use to convert features to k-D vectors.
+        #  * \param feature_representation the const boost shared pointer to a PointRepresentation
+        #  */
+        # inline void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation) { feature_representation_ = feature_representation; }
+        # void setPointRepresentation (const FeatureRepresentationConstPtr& feature_representation)
+        
+        # /** \brief Get a pointer to the feature representation used when converting features into k-D vectors. */
+        # inline FeatureRepresentationConstPtr const getPointRepresentation () { return feature_representation_; }
+        # FeatureRepresentationConstPtr const getPointRepresentation ()
+        
+        # /** \brief The central method for inserting the feature set inside the pyramid and obtaining the complete pyramid */
+        # void compute ();
+        void compute ()
+        
+        # /** \brief Checks whether the pyramid histogram has been computed */
+        # inline bool isComputed () { return is_computed_; }
+        bool isComputed ()
+        
+        # /** \brief Static method for comparing two pyramid histograms that returns a floating point value between 0 and 1,
+        #  * representing the similiarity between the feature sets on which the two pyramid histograms are based.
+        #  * \param pyramid_a Pointer to the first pyramid to be compared (needs to be computed already).
+        #  * \param pyramid_b Pointer to the second pyramid to be compared (needs to be computed already).
+        #  */
+        # static float comparePyramidFeatureHistograms (const PyramidFeatureHistogramPtr &pyramid_a, const PyramidFeatureHistogramPtr &pyramid_b);
+
+
+###
+
+# sample_consensus_prerejective.h
+# namespace pcl
+# /** \brief Pose estimation and alignment class using a prerejective RANSAC routine.
+#  * This class inserts a simple, yet effective "prerejection" step into the standard
+#  * RANSAC pose estimation loop in order to avoid verification of pose hypotheses
+#  * that are likely to be wrong. This is achieved by local pose-invariant geometric
+#  * constraints, as also implemented in the class
+#  * \ref registration::CorrespondenceRejectorPoly "CorrespondenceRejectorPoly".
+#  * In order to robustly align partial/occluded models, this routine performs
+#  * fit error evaluation using only inliers, i.e. points closer than a
+#  * Euclidean threshold, which is specifiable using \ref setInlierFraction().
+#  * The amount of prerejection or "greedyness" of the algorithm can be specified
+#  * using \ref setSimilarityThreshold() in [0,1[, where a value of 0 means disabled,
+#  * and 1 is maximally rejective.
+#  * If you use this in academic work, please cite:
+#  * A. G. Buch, D. Kraft, J.-K. Kamarainen, H. G. Petersen and N. Kruger.
+#  * Pose Estimation using Local Structure-Specific Shape and Appearance Context.
+#  * International Conference on Robotics and Automation (ICRA), 2013.
+#  * \author Anders Glent Buch (andersgb1@gmail.com)
+#  * \ingroup registration
+#  */
+# template <typename PointSource, typename PointTarget, typename FeatureT>
+# class SampleConsensusPrerejective : public Registration<PointSource, PointTarget>
+cdef extern from "pcl/registration/sample_consensus_prerejective.h" namespace "pcl" nogil:
+    cdef cppclass SampleConsensusPrerejective[Source, Target, Feature](Registration[Source, Target, float]):
+        SampleConsensusPrerejective()
+        # public:
+        # typedef typename Registration<PointSource, PointTarget>::Matrix4 Matrix4;
+        # using Registration<PointSource, PointTarget>::reg_name_;
+        # using Registration<PointSource, PointTarget>::getClassName;
+        # using Registration<PointSource, PointTarget>::input_;
+        # using Registration<PointSource, PointTarget>::target_;
+        # using Registration<PointSource, PointTarget>::tree_;
+        # using Registration<PointSource, PointTarget>::max_iterations_;
+        # using Registration<PointSource, PointTarget>::corr_dist_threshold_;
+        # using Registration<PointSource, PointTarget>::transformation_;
+        # using Registration<PointSource, PointTarget>::final_transformation_;
+        # using Registration<PointSource, PointTarget>::transformation_estimation_;
+        # using Registration<PointSource, PointTarget>::getFitnessScore;
+        # using Registration<PointSource, PointTarget>::converged_;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudSource PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef typename Registration<PointSource, PointTarget>::PointCloudTarget PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # typedef pcl::PointCloud<FeatureT> FeatureCloud;
+        # typedef typename FeatureCloud::Ptr FeatureCloudPtr;
+        # typedef typename FeatureCloud::ConstPtr FeatureCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusPrerejective<PointSource, PointTarget, FeatureT> > Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusPrerejective<PointSource, PointTarget, FeatureT> > ConstPtr;
+        # typedef typename KdTreeFLANN<FeatureT>::Ptr FeatureKdTreePtr;
+        # typedef pcl::registration::CorrespondenceRejectorPoly<PointSource, PointTarget> CorrespondenceRejectorPoly;
+        # typedef typename CorrespondenceRejectorPoly::Ptr CorrespondenceRejectorPolyPtr;
+        # typedef typename CorrespondenceRejectorPoly::ConstPtr CorrespondenceRejectorPolyConstPtr;
+        # 
+        # /** \brief Constructor */
+        # SampleConsensusPrerejective ()
+        #   : input_features_ ()
+        #   , target_features_ ()
+        #   , nr_samples_(3)
+        #   , k_correspondences_ (2)
+        #   , feature_tree_ (new pcl::KdTreeFLANN<FeatureT>)
+        #   , correspondence_rejector_poly_ (new CorrespondenceRejectorPoly)
+        #   , inlier_fraction_ (0.0f)
+        # 
+        # /** \brief Destructor */
+        # virtual ~SampleConsensusPrerejective ()
+        # 
+        # /** \brief Provide a boost shared pointer to the source point cloud's feature descriptors
+        #   * \param features the source point cloud's features
+        #   */
+        # void setSourceFeatures (const FeatureCloudConstPtr &features);
+        # void setSourceFeatures (const shared_ptr[cpp.PointCloud[float]] &features);
+        
+        # /** \brief Get a pointer to the source point cloud's features */
+        # inline const FeatureCloudConstPtr getSourceFeatures () const
+        # const shared_ptr[cpp.PointCloud[float]] getSourceFeatures ()
+        
+        # /** \brief Provide a boost shared pointer to the target point cloud's feature descriptors
+        #   * \param features the target point cloud's features
+        #   */
+        # void setTargetFeatures (const FeatureCloudConstPtr &features);
+        # void setTargetFeatures (const shared_ptr[cpp.PointCloud[float]] &features)
+        
+        # 
+        # /** \brief Get a pointer to the target point cloud's features */
+        # inline const FeatureCloudConstPtr getTargetFeatures () const
+        # const shared_ptr[cpp.PointCloud[float]] getTargetFeatures ()
+        
+        # /** \brief Set the number of samples to use during each iteration
+        #   * \param nr_samples the number of samples to use during each iteration
+        #   */
+        # inline void setNumberOfSamples (int nr_samples)
+        void setNumberOfSamples (int nr_samples)
+        
+        # /** \brief Get the number of samples to use during each iteration, as set by the user */
+        # inline int  getNumberOfSamples () const
+        int  getNumberOfSamples ()
+        
+        # /** \brief Set the number of neighbors to use when selecting a random feature correspondence.  A higher value will
+        #   * add more randomness to the feature matching.
+        #   * \param k the number of neighbors to use when selecting a random feature correspondence.
+        #   */
+        # inline void setCorrespondenceRandomness (int k)
+        void setCorrespondenceRandomness (int k)
+        
+        # /** \brief Get the number of neighbors used when selecting a random feature correspondence, as set by the user */
+        # inline int getCorrespondenceRandomness () const
+        int getCorrespondenceRandomness ()
+        
+        # /** \brief Set the similarity threshold in [0,1[ between edge lengths of the underlying polygonal correspondence rejector object,
+        #  * where 1 is a perfect match
+        #  * \param similarity_threshold edge length similarity threshold
+        #  */
+        # inline void setSimilarityThreshold (float similarity_threshold)
+        void setSimilarityThreshold (float similarity_threshold)
+        
+        # /** \brief Get the similarity threshold between edge lengths of the underlying polygonal correspondence rejector object,
+        #  * \return edge length similarity threshold
+        #  */
+        # inline float getSimilarityThreshold () const
+        float getSimilarityThreshold ()
+        
+        # /** \brief Set the required inlier fraction (of the input)
+        #  * \param inlier_fraction required inlier fraction, must be in [0,1]
+        #  */
+        # inline void setInlierFraction (float inlier_fraction)
+        void setInlierFraction (float inlier_fraction)
+        
+        # /** \brief Get the required inlier fraction
+        #  * \return required inlier fraction in [0,1]
+        #  */
+        # inline float getInlierFraction () const
+        float getInlierFraction ()
+        
+        # /** \brief Get the inlier indices of the source point cloud under the final transformation
+        #  * @return inlier indices
+        #  */
+        # inline const std::vector<int>& getInliers () const
+        const vector[int]& getInliers ()
+
+
+###
+
+# transformation_estimation.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimation
+cdef extern from "pcl/registration/transformation_estimation.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimation[Source, Target, float]:
+        TransformationEstimation() except +
+        # public:
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix) = 0;
+
+
+# ctypedef shared_ptr[TransformationEstimation<PointSource, PointTarget> > Ptr;
+# ctypedef shared_ptr[const TransformationEstimation<PointSource, PointTarget> > ConstPtr;
+###
+
+# transformation_estimation_2D.h
+# namespace pcl
+# namespace registration
+# /** @b TransformationEstimation2D implements a simple 2D rigid transformation 
+#   * estimation (x, y, theta) for a given pair of datasets. 
+#   *
+#   * The two datasets should already be transformed so that the reference plane 
+#   * equals z = 0.
+#   *
+#   * \note The class is templated on the source and target point types as well as on the output scalar of the transformation matrix (i.e., float or double). Default: float.
+#   *
+#   * \author Suat Gedikli
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimation2D : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_2D.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimation2D[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimation2D() except +
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimation2D<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimation2D<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # TransformationEstimation2D () {};
+        # virtual ~TransformationEstimation2D () {};
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid transformation between a source and a target point cloud in 2D.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # virtual void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+
+
+###
+
+# transformation_estimation_dual_quaternion.h
+# namespace pcl
+# namespace registration
+# /** @b TransformationEstimationDualQuaternion implements dual quaternion based estimation of
+#   * the transformation aligning the given correspondences.
+#   *
+#   * \note The class is templated on the source and target point types as well as on the output scalar of the transformation matrix (i.e., float or double). Default: float.
+#   * \author Sergey Zagoruyko
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationDualQuaternion : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_dual_quaternion.h" namespace "pcl::registration" nogil:
+    cdef cppclass TransformationEstimationDualQuaternion[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationDualQuaternion() except +
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationDualQuaternion<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationDualQuaternion<PointSource, PointTarget, Scalar> > ConstPtr;
+        # 
+        # typedef typename TransformationEstimation<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # TransformationEstimationDualQuaternion () {};
+        # virtual ~TransformationEstimationDualQuaternion () {};
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using
+        #   * dual quaternion optimization
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+
+
+###
+
+# transformation_estimation_lm.h
+# template <typename PointSource, typename PointTarget, typename MatScalar = float>
+# class TransformationEstimationLM : public TransformationEstimation<PointSource, PointTarget, MatScalar>
+cdef extern from "pcl/registration/transformation_estimation_lm.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationLM[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationLM() except +
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationLM<PointSource, PointTarget, MatScalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationLM<PointSource, PointTarget, MatScalar> > ConstPtr;
+        # typedef Eigen::Matrix<MatScalar, Eigen::Dynamic, 1> VectorX;
+        # typedef Eigen::Matrix<MatScalar, 4, 1> Vector4;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, MatScalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Constructor. */
+        # TransformationEstimationLM ();
+        # 
+        # /** \brief Copy constructor. 
+        #   * \param[in] src the  object to copy into this 
+        #   */
+        # TransformationEstimationLM (const TransformationEstimationLM &src) : 
+        #   tmp_src_ (src.tmp_src_), 
+        #   tmp_tgt_ (src.tmp_tgt_), 
+        #   tmp_idx_src_ (src.tmp_idx_src_), 
+        #   tmp_idx_tgt_ (src.tmp_idx_tgt_), 
+        #   warp_point_ (src.warp_point_)
+        # 
+        # /** \brief Copy operator. 
+        #   * \param[in] src the TransformationEstimationLM object to copy into this 
+        #   */
+        # TransformationEstimationLM& operator = (const TransformationEstimationLM &src)
+        # 
+        #  /** \brief Destructor. */
+        # virtual ~TransformationEstimationLM () {};
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from 
+        #   * \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Set the function we use to warp points. Defaults to rigid 6D warp.
+        #   * \param[in] warp_fcn a shared pointer to an object that warps points
+        #   */
+        # void setWarpFunction (const boost::shared_ptr<WarpPointRigid<PointSource, PointTarget, MatScalar> > &warp_fcn)
+
+
+###
+
+# transformation_estimation_point_to_plane.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationPointToPlane : public TransformationEstimationLM<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlane[Source, Target, float](TransformationEstimationLM[Source, Target, float]):
+        TransformationEstimationPointToPlane ()
+        # public:
+        # ctypedef boost::shared_ptr<TransformationEstimationPointToPlane<PointSource, PointTarget> > Ptr;
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef PointIndices::Ptr PointIndicesPtr;
+        # ctypedef PointIndices::ConstPtr PointIndicesConstPtr;
+###
+
+# transformation_estimation_point_to_plane_lls.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationEstimationPointToPlaneLLS : public TransformationEstimation<PointSource, PointTarget>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane_lls.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlaneLLS[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationPointToPlaneLLS ()
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix);
+
+###
+
+# transformation_estimation_point_to_plane_lls_weighted.h
+# namespace pcl
+# namespace registration
+# /** \brief @b TransformationEstimationPointToPlaneLLSWeighted implements a Linear Least Squares (LLS) approximation
+#   * for minimizing the point-to-plane distance between two clouds of corresponding points with normals, with the
+#   * possibility of assigning weights to the correspondences.
+#   *
+#   * For additional details, see 
+#   *   "Linear Least-Squares Optimization for Point-to-Plane ICP Surface Registration", Kok-Lim Low, 2004
+#   *
+#   * \note The class is templated on the source and target point types as well as on the output scalar of the
+#   * transformation matrix (i.e., float or double). Default: float.
+#   * \author Alex Ichim
+#   * \ingroup registration
+#   */
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationPointToPlaneLLSWeighted : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane_lls_weighted.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationPointToPlaneLLSWeighted[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationPointToPlaneLLS ()
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationPointToPlaneLLSWeighted<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationPointToPlaneLLSWeighted<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # TransformationEstimationPointToPlaneLLSWeighted () { };
+        # virtual ~TransformationEstimationPointToPlaneLLSWeighted () { };
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Set the weights for the correspondences.
+        #   * \param[in] weights the weights for each correspondence
+        #   */
+        # inline void setCorrespondenceWeights (const std::vector<Scalar> &weights)
+
+
+###
+
+# transformation_estimation_point_to_plane_weighted.h
+# namespace pcl
+# namespace registration
+# template <typename PointSource, typename PointTarget, typename MatScalar = float>
+# class TransformationEstimationPointToPlaneWeighted : public TransformationEstimationPointToPlane<PointSource, PointTarget, MatScalar>
+cdef extern from "pcl/registration/transformation_estimation_point_to_plane_weighted.h" namespace "pcl::registration" nogil:
+    cdef cppclass TransformationEstimationPointToPlaneWeighted[Source, Target, float](TransformationEstimationPointToPlane[Source, Target, float]):
+        TransformationEstimationPointToPlaneWeighted ()
+        # typedef pcl::PointCloud<PointSource> PointCloudSource;
+        # typedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # typedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # typedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationPointToPlaneWeighted<PointSource, PointTarget, MatScalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationPointToPlaneWeighted<PointSource, PointTarget, MatScalar> > ConstPtr;
+        # typedef Eigen::Matrix<MatScalar, Eigen::Dynamic, 1> VectorX;
+        # typedef Eigen::Matrix<MatScalar, 4, 1> Vector4;
+        # typedef typename TransformationEstimation<PointSource, PointTarget, MatScalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Constructor. */
+        # TransformationEstimationPointToPlaneWeighted ();
+        # 
+        # /** \brief Copy constructor. 
+        #   * \param[in] src the TransformationEstimationPointToPlaneWeighted object to copy into this
+        #   */
+        # TransformationEstimationPointToPlaneWeighted (const TransformationEstimationPointToPlaneWeighted &src) :
+        #   tmp_src_ (src.tmp_src_), 
+        #   tmp_tgt_ (src.tmp_tgt_), 
+        #   tmp_idx_src_ (src.tmp_idx_src_), 
+        #   tmp_idx_tgt_ (src.tmp_idx_tgt_), 
+        #   warp_point_ (src.warp_point_),
+        #   correspondence_weights_ (src.correspondence_weights_),
+        #   use_correspondence_weights_ (src.use_correspondence_weights_)
+        # {};
+        # 
+        # /** \brief Copy operator. 
+        #   * \param[in] src the TransformationEstimationPointToPlaneWeighted object to copy into this
+        #   */
+        # TransformationEstimationPointToPlaneWeighted&
+        # operator = (const TransformationEstimationPointToPlaneWeighted &src)
+        # {
+        #   tmp_src_ = src.tmp_src_; 
+        #   tmp_tgt_ = src.tmp_tgt_; 
+        #   tmp_idx_src_ = src.tmp_idx_src_;
+        #   tmp_idx_tgt_ = src.tmp_idx_tgt_; 
+        #   warp_point_ = src.warp_point_;
+        #   correspondence_weights_ = src.correspondence_weights_;
+        #   use_correspondence_weights_ = src.use_correspondence_weights_;
+        # }
+        # 
+        #  /** \brief Destructor. */
+        # virtual ~TransformationEstimationPointToPlaneWeighted () {};
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from 
+        #   * \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Matrix4 &transformation_matrix) const;
+        # 
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using LM.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \note Uses the weights given by setWeights.
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Matrix4 &transformation_matrix) const;  
+        # 
+        # inline void setWeights (const std::vector<double> &weights)
+        # 
+        # /// use the weights given in the pcl::CorrespondencesPtr for one of the estimateTransformation (...) methods
+        # inline void setUseCorrespondenceWeights (bool use_correspondence_weights)
+        # 
+        # /** \brief Set the function we use to warp points. Defaults to rigid 6D warp.
+        #   * \param[in] warp_fcn a shared pointer to an object that warps points
+        #   */
+        # void setWarpFunction (const boost::shared_ptr<WarpPointRigid<PointSource, PointTarget, MatScalar> > &warp_fcn)
+
+
+###
+
+# transformation_estimation_svd.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationSVD : public TransformationEstimation<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_svd.h" namespace "pcl" nogil:
+    cdef cppclass TransformationEstimationSVD[Source, Target, float](TransformationEstimation[Source, Target, float]):
+        TransformationEstimationSVD ()
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] indices_src the vector of indices describing the points of interest in \a cloud_src
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] indices_tgt the vector of indices describing the correspondences of the interst points from \a indices_src
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # inline void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const std::vector<int> &indices_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const std::vector<int> &indices_tgt,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # /** \brief Estimate a rigid rotation transformation between a source and a target point cloud using SVD.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[in] correspondences the vector of correspondences between source and target point cloud
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   */
+        # void
+        # estimateRigidTransformation (
+        #     const pcl::PointCloud<PointSource> &cloud_src,
+        #     const pcl::PointCloud<PointTarget> &cloud_tgt,
+        #     const pcl::Correspondences &correspondences,
+        #     Eigen::Matrix4f &transformation_matrix);
+        # protected:
+        # /** \brief Obtain a 4x4 rigid transformation matrix from a correlation matrix H = src * tgt'
+        #   * \param[in] cloud_src_demean the input source cloud, demeaned, in Eigen format
+        #   * \param[in] centroid_src the input source centroid, in Eigen format
+        #   * \param[in] cloud_tgt_demean the input target cloud, demeaned, in Eigen format
+        #   * \param[in] centroid_tgt the input target cloud, in Eigen format
+        #   * \param[out] transformation_matrix the resultant 4x4 rigid transformation matrix
+        #   */ 
+        # void
+        # getTransformationFromCorrelation (const Eigen::MatrixXf &cloud_src_demean,
+        #                                   const Eigen::Vector4f &centroid_src,
+        #                                   const Eigen::MatrixXf &cloud_tgt_demean,
+        #                                   const Eigen::Vector4f &centroid_tgt,
+        #                                   Eigen::Matrix4f &transformation_matrix);
+###
+
+# transformation_estimation_svd_scale.h
+# namespace pcl
+# namespace registration
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationEstimationSVDScale : public TransformationEstimationSVD<PointSource, PointTarget, Scalar>
+cdef extern from "pcl/registration/transformation_estimation_svd_scale.h" namespace "pcl::registration" nogil:
+    cdef cppclass TransformationEstimationSVDScale[Source, Target, float](TransformationEstimationSVD[Source, Target, float]):
+        TransformationEstimationSVDScale ()
+        # public:
+        # typedef boost::shared_ptr<TransformationEstimationSVDScale<PointSource, PointTarget, Scalar> > Ptr;
+        # typedef boost::shared_ptr<const TransformationEstimationSVDScale<PointSource, PointTarget, Scalar> > ConstPtr;
+        # typedef typename TransformationEstimationSVD<PointSource, PointTarget, Scalar>::Matrix4 Matrix4;
+        # 
+        # /** \brief Inherits from TransformationEstimationSVD, but forces it to not use the Umeyama method */
+        # TransformationEstimationSVDScale ():
+        # TransformationEstimationSVD<PointSource, PointTarget, Scalar> (false)
+
+
+###
+
+# transformation_validation.h
+# template <typename PointSource, typename PointTarget, typename Scalar = float>
+# class TransformationValidation
+cdef extern from "pcl/registration/transformation_validation.h" namespace "pcl" nogil:
+    cdef cppclass TransformationValidation[Source, Target, float]:
+        TransformationValidation ()
+        # public:
+        # ctypedef pcl::PointCloud<PointSource> PointCloudSource;
+        # ctypedef typename PointCloudSource::Ptr PointCloudSourcePtr;
+        # ctypedef typename PointCloudSource::ConstPtr PointCloudSourceConstPtr;
+        # ctypedef pcl::PointCloud<PointTarget> PointCloudTarget;
+        # ctypedef typename PointCloudTarget::Ptr PointCloudTargetPtr;
+        # ctypedef typename PointCloudTarget::ConstPtr PointCloudTargetConstPtr;
+        # /** \brief Validate the given transformation with respect to the input cloud data, and return a score.
+        #   * \param[in] cloud_src the source point cloud dataset
+        #   * \param[in] cloud_tgt the target point cloud dataset
+        #   * \param[out] transformation_matrix the resultant transformation matrix
+        #   * \return the score or confidence measure for the given
+        #   * transformation_matrix with respect to the input data
+        #   */
+        # virtual double validateTransformation (
+        #    const cpp.PointCloudPtr_t &cloud_src,
+        #    const cpp.PointCloudPtr_t &cloud_tgt,
+        #    const Matrix4f &transformation_matrix) = 0;
+        # 
+        # ctypedef shared_ptr[TransformationValidation[PointSource, PointTarget] ] Ptr;
+        # ctypedef shared_ptr[const TransformationValidation[PointSource, PointTarget] ] ConstPtr;
+
+
+###
+
+# transformation_validation_euclidean.h
+# template <typename PointSource, typename PointTarget>
+# class TransformationValidationEuclidean
+cdef extern from "pcl/registration/transformation_validation_euclidean.h" namespace "pcl" nogil:
+    cdef cppclass TransformationValidationEuclidean[Source, Target, float]:
+        TransformationValidationEuclidean ()
+        # public:
+        # ctypedef boost::shared_ptr<TransformationValidation<PointSource, PointTarget> > Ptr;
+        # ctypedef boost::shared_ptr<const TransformationValidation<PointSource, PointTarget> > ConstPtr;
+        # ctypedef typename pcl::KdTree<PointTarget> KdTree;
+        # ctypedef typename pcl::KdTree<PointTarget>::Ptr KdTreePtr;
+        # ctypedef typename KdTree::PointRepresentationConstPtr PointRepresentationConstPtr;
+        # ctypedef typename TransformationValidation<PointSource, PointTarget>::PointCloudSourceConstPtr PointCloudSourceConstPtr;
+        # ctypedef typename TransformationValidation<PointSource, PointTarget>::PointCloudTargetConstPtr PointCloudTargetConstPtr;
+        inline void setMaxRange (double max_range)
+        # double validateTransformation (const cpp.PointCloudPtr_t &cloud_src, const cpp.PointCloudPtr_t &cloud_tgt, const Matrix4f &transformation_matrix)
+
+
+###
+
+# transforms.h
+# common/transforms.h
+###
+
+# warp_point_rigid_3d.h
+# template <class PointSourceT, class PointTargetT>
+# class WarpPointRigid3D : public WarpPointRigid<PointSourceT, PointTargetT>
+cdef extern from "pcl/registration/warp_point_rigid_3d.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid3D[Source, Target, float](WarpPointRigid[Source, Target, float]):
+        WarpPointRigid3D ()
+        # public:
+        # virtual void setParam (const Eigen::VectorXf & p)
+
+
+###
+
+# warp_point_rigid_6d.h
+# template <class PointSourceT, class PointTargetT>
+# class WarpPointRigid6D : public WarpPointRigid<PointSourceT, PointTargetT>
+cdef extern from "pcl/registration/warp_point_rigid_6d.h" namespace "pcl" nogil:
+    cdef cppclass WarpPointRigid6D[Source, Target, float](WarpPointRigid[Source, Target, float]):
+        WarpPointRigid6D ()
+        # public:
+        # virtual void setParam (const Eigen::VectorXf & p)
+
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+cdef extern from "pcl/registration/bfgs.h" namespace "pcl":
+    cdef enum Status:
+        NegativeGradientEpsilon = -3
+        NotStarted = -2
+        Running = -1
+        Success = 0
+        NoProgress = 1
+#####
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_ros.pxd b/pcl/pcl_ros.pxd
new file mode 100644
index 0000000..5ef9eac
--- /dev/null
+++ b/pcl/pcl_ros.pxd
@@ -0,0 +1,261 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+# conversions.h
+# namespace pcl
+# namespace detail
+# // For converting template point cloud to message.
+# template<typename PointT>
+# struct FieldAdder
+#     {
+#       FieldAdder (std::vector<sensor_msgs::PointField>& fields) : fields_ (fields) {};
+#       template<typename U> void operator() ()
+#       std::vector<sensor_msgs::PointField>& fields_;
+#     };
+###
+
+# conversions.h
+# namespace pcl
+# namespace detail
+# // For converting message to template point cloud.
+# template<typename PointT>
+# struct FieldMapper
+#     {
+#       FieldMapper (const std::vector<sensor_msgs::PointField>& fields, std::vector<FieldMapping>& map) : fields_ (fields), map_ (map)
+#       template<typename Tag> void operator () ()
+# 
+#       const std::vector<sensor_msgs::PointField>& fields_;
+#       std::vector<FieldMapping>& map_;
+#     };
+# 
+#     inline bool fieldOrdering (const FieldMapping& a, const FieldMapping& b)
+#     {
+#       return (a.serialized_offset < b.serialized_offset);
+#     }
+# 
+#   } //namespace detail
+
+# conversions.h
+# namespace pcl
+# template<typename PointT> void 
+# createMapping (const std::vector<sensor_msgs::PointField>& msg_fields, MsgFieldMap& field_map)
+#   {
+#     // Create initial 1-1 mapping between serialized data segments and struct fields
+#     detail::FieldMapper<PointT> mapper (msg_fields, field_map);
+#     for_each_type< typename traits::fieldList<PointT>::type > (mapper);
+# 
+#     // Coalesce adjacent fields into single memcpy's where possible
+#     if (field_map.size() > 1)
+#     {
+#       std::sort(field_map.begin(), field_map.end(), detail::fieldOrdering);
+#       MsgFieldMap::iterator i = field_map.begin(), j = i + 1;
+#       while (j != field_map.end())
+#       {
+#         // This check is designed to permit padding between adjacent fields.
+#         /// @todo One could construct a pathological case where the struct has a
+#         /// field where the serialized data has padding
+#         if (j->serialized_offset - i->serialized_offset == j->struct_offset - i->struct_offset)
+#         {
+#           i->size += (j->struct_offset + j->size) - (i->struct_offset + i->size);
+#           j = field_map.erase(j);
+#         }
+#         else
+#         {
+#           ++i;
+#           ++j;
+#         }
+#       }
+#     }
+#   }
+###
+
+# conversions.h
+# namespace pcl
+# /** \brief Convert a PointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.
+#   * \param[in] msg the PointCloud2 binary blob
+#   * \param[out] cloud the resultant pcl::PointCloud<T>
+#   * \param[in] field_map a MsgFieldMap object
+#   *
+#   * \note Use fromROSMsg (PointCloud2, PointCloud<T>) directly or create you
+#   * own MsgFieldMap using:
+#   *
+#   * \code
+#   * MsgFieldMap field_map;
+#   * createMapping<PointT> (msg.fields, field_map);
+#   * \endcode
+#   */
+# template <typename PointT> void 
+# fromROSMsg (const sensor_msgs::PointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)
+# {
+# }
+###
+
+# conversions.h
+# namespace pcl
+# /** \brief Convert a PointCloud2 binary data blob into a pcl::PointCloud<T> object.
+#   * \param[in] msg the PointCloud2 binary blob
+#   * \param[out] cloud the resultant pcl::PointCloud<T>
+#   */
+# template<typename PointT> void 
+# fromROSMsg (const sensor_msgs::PointCloud2& msg, pcl::PointCloud<PointT>& cloud)
+###
+
+# conversions.h
+# namespace pcl
+# /** \brief Convert a pcl::PointCloud<T> object to a PointCloud2 binary data blob.
+#   * \param[in] cloud the input pcl::PointCloud<T>
+#   * \param[out] msg the resultant PointCloud2 binary blob
+#   */
+# template<typename PointT> void 
+# toROSMsg (const pcl::PointCloud<PointT>& cloud, sensor_msgs::PointCloud2& msg)
+###
+
+# conversions.h
+# namespace pcl
+# /** \brief Copy the RGB fields of a PointCloud into sensor_msgs::Image format
+#   * \param[in] cloud the point cloud message
+#   * \param[out] msg the resultant sensor_msgs::Image
+#   * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>
+#   * \note will throw std::runtime_error if there is a problem
+#   */
+# template<typename CloudT> void
+# toROSMsg (const CloudT& cloud, sensor_msgs::Image& msg)
+###
+
+# conversions.h
+# namespace pcl
+# /** \brief Copy the RGB fields of a PointCloud2 msg into sensor_msgs::Image format
+#   * \param cloud the point cloud message
+#   * \param msg the resultant sensor_msgs::Image
+#   * will throw std::runtime_error if there is a problem
+#   */
+# inline void toROSMsg (const sensor_msgs::PointCloud2& cloud, sensor_msgs::Image& msg)
+###
+
+
+# register_point_struct.h
+# #include <pcl/register_point_struct.h>
+# // Must be used in global namespace with name fully qualified
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT(name, fseq)               \
+#   POINT_CLOUD_REGISTER_POINT_STRUCT_I(name,                         \
+#     BOOST_PP_CAT(POINT_CLOUD_REGISTER_POINT_STRUCT_X fseq, 0))      \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_POINT_WRAPPER(wrapper, pod)    \
+#   BOOST_MPL_ASSERT_MSG(sizeof(wrapper) == sizeof(pod), POINT_WRAPPER_AND_POD_TYPES_HAVE_DIFFERENT_SIZES, (wrapper&, pod&)); \
+#   namespace pcl {                                           \
+#     namespace traits {                                      \
+#       template<> struct POD<wrapper> { typedef pod type; }; \
+#     }                                                       \
+#   }                                                         \
+#   /***/
+# 
+# // These macros help transform the unusual data structure (type, name, tag)(type, name, tag)...
+# // into a proper preprocessor sequence of 3-tuples ((type, name, tag))((type, name, tag))...
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_X(type, name, tag)            \
+#   ((type, name, tag)) POINT_CLOUD_REGISTER_POINT_STRUCT_Y
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_Y(type, name, tag)            \
+#   ((type, name, tag)) POINT_CLOUD_REGISTER_POINT_STRUCT_X
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_X0
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_Y0
+# 
+# // Construct type traits given full sequence of (type, name, tag) triples
+# //  BOOST_MPL_ASSERT_MSG(boost::is_pod<name>::value,                    
+# //                       REGISTERED_POINT_TYPE_MUST_BE_PLAIN_OLD_DATA, (name)); 
+# #define POINT_CLOUD_REGISTER_POINT_STRUCT_I(name, seq)                           \
+#   namespace pcl                                                                  \
+#   {                                                                              \
+#     namespace fields                                                             \
+#     {                                                                            \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_TAG, name, seq)           \
+#     }                                                                            \
+#     namespace traits                                                             \
+#     {                                                                            \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_NAME, name, seq)          \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_OFFSET, name, seq)        \
+#       BOOST_PP_SEQ_FOR_EACH(POINT_CLOUD_REGISTER_FIELD_DATATYPE, name, seq)      \
+#       POINT_CLOUD_REGISTER_POINT_FIELD_LIST(name, POINT_CLOUD_EXTRACT_TAGS(seq)) \
+#     }                                                                            \
+#   }                                                                              \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_TAG(r, name, elem)   \
+#   struct BOOST_PP_TUPLE_ELEM(3, 2, elem);               \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_NAME(r, point, elem)                 \
+#   template<int dummy>                                                   \
+#   struct name<point, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem), dummy> \
+#   {                                                                     \
+#     static const char value[];                                          \
+#   };                                                                    \
+#                                                                         \
+#   template<int dummy>                                                   \
+#   const char name<point,                                                \
+#                   pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem),         \
+#                   dummy>::value[] =                                     \
+#     BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(3, 2, elem));                \
+#   /***/
+# 
+# #define POINT_CLOUD_REGISTER_FIELD_OFFSET(r, name, elem)                \
+#   template<> struct offset<name, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)> \
+#   {                                                                     \
+#     static const size_t value = offsetof(name, BOOST_PP_TUPLE_ELEM(3, 1, elem)); \
+#   };                                                                    \
+#   /***/
+# 
+# // \note: the mpl::identity weirdness is to support array types without requiring the
+# // user to wrap them. The basic problem is:
+# // typedef float[81] type; // SYNTAX ERROR!
+# // typedef float type[81]; // OK, can now use "type" as a synonym for float[81]
+# #define POINT_CLOUD_REGISTER_FIELD_DATATYPE(r, name, elem)              \
+#   template<> struct datatype<name, pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)> \
+#   {                                                                     \
+#     typedef boost::mpl::identity<BOOST_PP_TUPLE_ELEM(3, 0, elem)>::type type; \
+#     typedef decomposeArray<type> decomposed;                            \
+#     static const uint8_t value = asEnum<decomposed::type>::value;       \
+#     static const uint32_t size = decomposed::value;                     \
+#   };                                                                    \
+#   /***/
+# 
+# #define POINT_CLOUD_TAG_OP(s, data, elem) pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem)
+# 
+# #define POINT_CLOUD_EXTRACT_TAGS(seq) BOOST_PP_SEQ_TRANSFORM(POINT_CLOUD_TAG_OP, _, seq)
+# 
+# #define POINT_CLOUD_REGISTER_POINT_FIELD_LIST(name, seq)        \
+#   template<> struct fieldList<name>                             \
+#   {                                                             \
+#     typedef boost::mpl::vector<BOOST_PP_SEQ_ENUM(seq)> type;    \
+#   };                                                            \
+#   /***/
+# 
+# // Disabling barely-used Fusion registration of point types for now.
+# #if 0
+# #define POINT_CLOUD_EXPAND_TAG_OP(s, data, elem)                \
+#   (boost::mpl::identity<BOOST_PP_TUPLE_ELEM(3, 0, elem)>::type, \
+#    BOOST_PP_TUPLE_ELEM(3, 1, elem),                             \
+#    pcl::fields::BOOST_PP_TUPLE_ELEM(3, 2, elem))                \
+#   /***/
+# 
+# #define POINT_CLOUD_EXPAND_TAGS(seq) BOOST_PP_SEQ_TRANSFORM(POINT_CLOUD_EXPAND_TAG_OP, _, seq)
+# 
+# #define POINT_CLOUD_REGISTER_WITH_FUSION(name, seq)                     \
+#   BOOST_FUSION_ADAPT_ASSOC_STRUCT_I(name, POINT_CLOUD_EXPAND_TAGS(seq)) \
+#   /***/
+# #endif
+# 
+# 
+###
diff --git a/pcl/pcl_ros_172.pxd b/pcl/pcl_ros_172.pxd
new file mode 100644
index 0000000..81a5456
--- /dev/null
+++ b/pcl/pcl_ros_172.pxd
@@ -0,0 +1,81 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+# common\include\pcl\ros\conversions.h
+# namespace pcl
+# {
+    # /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.
+    #   * \param[in] msg the PCLPointCloud2 binary blob
+    #   * \param[out] cloud the resultant pcl::PointCloud<T>
+    #   * \param[in] field_map a MsgFieldMap object
+    #   *
+    #   * \note Use fromROSMsg (PCLPointCloud2, PointCloud<T>) directly or create you
+    #   * own MsgFieldMap using:
+    #   *
+    #   * \code
+    #   * MsgFieldMap field_map;
+    #   * createMapping<PointT> (msg.fields, field_map);
+    #   * \endcode
+    # */
+    # template <typename PointT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void fromROSMsg (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)
+    # 
+    # /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object.
+    #     * \param[in] msg the PCLPointCloud2 binary blob
+    #   * \param[out] cloud the resultant pcl::PointCloud<T>
+    # */
+    # template<typename PointT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void fromROSMsg (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud)
+    # 
+    # /** \brief Convert a pcl::PointCloud<T> object to a PCLPointCloud2 binary data blob.
+    #   * \param[in] cloud the input pcl::PointCloud<T>
+    #   * \param[out] msg the resultant PCLPointCloud2 binary blob
+    # */
+    # template<typename PointT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void toROSMsg (const pcl::PointCloud<PointT>& cloud, pcl::PCLPointCloud2& msg)
+    # 
+    # /** \brief Copy the RGB fields of a PointCloud into pcl::PCLImage format
+    #   * \param[in] cloud the point cloud message
+    #   * \param[out] msg the resultant pcl::PCLImage
+    #   * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>
+    #   * \note will throw std::runtime_error if there is a problem
+    #  */
+    # template<typename CloudT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void toROSMsg (const CloudT& cloud, pcl::PCLImage& msg)
+    # 
+    # /** \brief Copy the RGB fields of a PCLPointCloud2 msg into pcl::PCLImage format
+    #   * \param cloud the point cloud message
+    #   * \param msg the resultant pcl::PCLImage
+    #   * will throw std::runtime_error if there is a problem
+    # */
+    # inline void
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # toROSMsg (const pcl::PCLPointCloud2& cloud, pcl::PCLImage& msg)
+
+
+###
+
+
+# common\include\pcl\ros\register_point_struct.h
+# changed pcl/register_point_struct.h
+# include <pcl/register_point_struct.h>
+###
+
+
diff --git a/pcl/pcl_ros_180.pxd b/pcl/pcl_ros_180.pxd
new file mode 100644
index 0000000..81a5456
--- /dev/null
+++ b/pcl/pcl_ros_180.pxd
@@ -0,0 +1,81 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+# common\include\pcl\ros\conversions.h
+# namespace pcl
+# {
+    # /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object using a field_map.
+    #   * \param[in] msg the PCLPointCloud2 binary blob
+    #   * \param[out] cloud the resultant pcl::PointCloud<T>
+    #   * \param[in] field_map a MsgFieldMap object
+    #   *
+    #   * \note Use fromROSMsg (PCLPointCloud2, PointCloud<T>) directly or create you
+    #   * own MsgFieldMap using:
+    #   *
+    #   * \code
+    #   * MsgFieldMap field_map;
+    #   * createMapping<PointT> (msg.fields, field_map);
+    #   * \endcode
+    # */
+    # template <typename PointT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void fromROSMsg (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud, const MsgFieldMap& field_map)
+    # 
+    # /** \brief Convert a PCLPointCloud2 binary data blob into a pcl::PointCloud<T> object.
+    #     * \param[in] msg the PCLPointCloud2 binary blob
+    #   * \param[out] cloud the resultant pcl::PointCloud<T>
+    # */
+    # template<typename PointT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void fromROSMsg (const pcl::PCLPointCloud2& msg, pcl::PointCloud<PointT>& cloud)
+    # 
+    # /** \brief Convert a pcl::PointCloud<T> object to a PCLPointCloud2 binary data blob.
+    #   * \param[in] cloud the input pcl::PointCloud<T>
+    #   * \param[out] msg the resultant PCLPointCloud2 binary blob
+    # */
+    # template<typename PointT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void toROSMsg (const pcl::PointCloud<PointT>& cloud, pcl::PCLPointCloud2& msg)
+    # 
+    # /** \brief Copy the RGB fields of a PointCloud into pcl::PCLImage format
+    #   * \param[in] cloud the point cloud message
+    #   * \param[out] msg the resultant pcl::PCLImage
+    #   * CloudT cloud type, CloudT should be akin to pcl::PointCloud<pcl::PointXYZRGBA>
+    #   * \note will throw std::runtime_error if there is a problem
+    #  */
+    # template<typename CloudT>
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # void toROSMsg (const CloudT& cloud, pcl::PCLImage& msg)
+    # 
+    # /** \brief Copy the RGB fields of a PCLPointCloud2 msg into pcl::PCLImage format
+    #   * \param cloud the point cloud message
+    #   * \param msg the resultant pcl::PCLImage
+    #   * will throw std::runtime_error if there is a problem
+    # */
+    # inline void
+    # PCL_DEPRECATED ("pcl::fromROSMsg is deprecated, please use fromPCLPointCloud2 instead.")
+    # toROSMsg (const pcl::PCLPointCloud2& cloud, pcl::PCLImage& msg)
+
+
+###
+
+
+# common\include\pcl\ros\register_point_struct.h
+# changed pcl/register_point_struct.h
+# include <pcl/register_point_struct.h>
+###
+
+
diff --git a/pcl/pcl_sample_consensus.pxd b/pcl/pcl_sample_consensus.pxd
new file mode 100644
index 0000000..d51445b
--- /dev/null
+++ b/pcl/pcl_sample_consensus.pxd
@@ -0,0 +1,2298 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# import
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# sac_model.h
+# namespace pcl
+# template<class T> class ProgressiveSampleConsensus;
+
+# sac_model.h
+# namespace pcl
+# template <typename PointT>
+# class SampleConsensusModel
+cdef extern from "pcl/sample_consensus/sac_model.h" namespace "pcl":
+    cdef cppclass SampleConsensusModel[T]:
+        SampleConsensusModel()
+        # SampleConsensusModel (bool random = false) 
+        # SampleConsensusModel (const PointCloudConstPtr &cloud, bool random = false)
+        # SampleConsensusModel (const PointCloudConstPtr &cloud, const std::vector<int> &indices, bool random = false)
+        # public:
+        # typedef typename pcl::PointCloud<PointT> PointCloud;
+        # typedef typename pcl::PointCloud<PointT>::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointT>::Ptr PointCloudPtr;
+        # typedef typename pcl::search::Search<PointT>::Ptr SearchPtr;
+        # typedef boost::shared_ptr<SampleConsensusModel> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusModel> ConstPtr;
+        # public:
+        # /** \brief Get a set of random data samples and return them as point
+        # * indices. Pure virtual.  
+        # * \param[out] iterations the internal number of iterations used by SAC methods
+        # * \param[out] samples the resultant model samples
+        # */
+        # void getSamples (int &iterations, std::vector<int> &samples)
+        void getSamples (int &iterations, vector[int] &samples)
+        
+        # /** \brief Check whether the given index samples can form a valid model,
+        # * compute the model coefficients from these samples and store them
+        # * in model_coefficients. Pure virtual.
+        # * \param[in] samples the point indices found as possible good candidates
+        # * for creating a valid model 
+        # * \param[out] model_coefficients the computed model coefficients
+        # */
+        # virtual bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients) = 0;
+        
+        # /** \brief Recompute the model coefficients using the given inlier set
+        # * and return them to the user. Pure virtual.
+        # * @note: these are the coefficients of the model after refinement
+        # * (e.g., after a least-squares optimization)
+        # * \param[in] inliers the data inliers supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # virtual void optimizeModelCoefficients (const std::vector<int> &inliers,  const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients) = 0;
+        
+        # /** \brief Compute all distances from the cloud data to a given model. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to 
+        # * \param[out] distances the resultant estimated distances
+        # virtual void  getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances) = 0;
+        # /** \brief Select all the points which respect the given model
+        # * coefficients as inliers. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from 
+        # * the outliers
+        # * \param[out] inliers the resultant model inliers
+        # virtual void selectWithinDistance (const Eigen::VectorXf &model_coefficients,  const double threshold, std::vector<int> &inliers) = 0;
+        
+        # /** \brief Count all the points which respect the given model
+        # * coefficients as inliers. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to
+        # * compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for
+        # * determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold) = 0;
+        
+        # /** \brief Create a new point cloud with inliers projected onto the model. Pure virtual.
+        # * \param[in] inliers the data inliers that we want to project on the model
+        # * \param[in] model_coefficients the coefficients of a model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true (default) if we want the \a
+        # * projected_points cloud to be an exact copy of the input dataset minus
+        # * the point projections on the plane model
+        # virtual void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients,
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true) = 0;
+        
+        # /** \brief Verify whether a subset of indices verifies a given set of
+        # * model coefficients. Pure virtual.
+        # * \param[in] indices the data indices that need to be tested against the model
+        # * \param[in] model_coefficients the set of model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for
+        # * determining the inliers from the outliers
+        # virtual bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold) = 0;
+        
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # inline virtual void setInputCloud (const PointCloudConstPtr &cloud)
+        
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # inline PointCloudConstPtr getInputCloud () const
+        
+        # /** \brief Provide a pointer to the vector of indices that represents the input data.
+        # * \param[in] indices a pointer to the vector of indices that represents the input data.
+        # inline void setIndices (const boost::shared_ptr <std::vector<int> > &indices) 
+        
+        # /** \brief Provide the vector of indices that represents the input data.
+        # * \param[out] indices the vector of indices that represents the input data.
+        # inline void setIndices (const std::vector<int> &indices) 
+        
+        # /** \brief Get a pointer to the vector of indices used. */
+        # inline boost::shared_ptr <std::vector<int> > getIndices () const
+        
+        # /** \brief Return an unique id for each type of model employed. */
+        # virtual SacModel getModelType () const = 0;
+        
+        # /** \brief Return the size of a sample from which a model is computed */
+        # inline unsigned int getSampleSize () const 
+        
+        # /** \brief Set the minimum and maximum allowable radius limits for the
+        # * model (applicable to models that estimate a radius)
+        # * \param[in] min_radius the minimum radius model
+        # * \param[in] max_radius the maximum radius model
+        # * \todo change this to set limits on the entire model
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        
+        # /** \brief Get the minimum and maximum allowable radius limits for the
+        # * model as set by the user.
+        # * \param[out] min_radius the resultant minimum radius model
+        # * \param[out] max_radius the resultant maximum radius model
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        
+        # /** \brief Set the maximum distance allowed when drawing random samples
+        # * \param[in] radius the maximum distance (L2 norm)
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        
+        # /** \brief Get maximum distance allowed when drawing random samples
+        # * \param[out] radius the maximum distance (L2 norm)
+        # inline void getSamplesMaxDist (double &radius)
+
+
+ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t
+ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model.h
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelFromNormals
+cdef extern from "pcl/sample_consensus/sac_model.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelFromNormals[T, NT]:
+        SampleConsensusModelFromNormals ()
+        # public:
+        # typedef typename pcl::PointCloud<PointNT>::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudNPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelFromNormals> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusModelFromNormals> ConstPtr;
+        # /** \brief Set the normal angular distance weight.
+        # * \param[in] w the relative weight (between 0 and 1) to give to the angular
+        # * distance (0 to pi/2) between point normals and the plane normal.
+        # * (The Euclidean distance will have weight 1-w.)
+        # */
+        # inline void setNormalDistanceWeight (const double w) 
+        void setNormalDistanceWeight (const double w) 
+        
+        # /** \brief Get the normal angular distance weight. */
+        # inline double getNormalDistanceWeight ()
+        double getNormalDistanceWeight ()
+        
+        # /** \brief Provide a pointer to the input dataset that contains the point
+        # * normals of the XYZ dataset.
+        # * \param[in] normals the const boost shared pointer to a PointCloud message
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) 
+        void setInputNormals (shared_ptr[cpp.PointCloud[NT]] normals) 
+        
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals ()
+        shared_ptr[cpp.PointCloud[NT]] getInputNormals () 
+
+
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal] SampleConsensusModelFromNormals_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal] SampleConsensusModelFromNormals_PointXYZI_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGB_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t
+###
+
+# sac.h
+# namespace pcl
+# template <typename T>
+# class SampleConsensus
+cdef extern from "pcl/sample_consensus/sac.h" namespace "pcl":
+    cdef cppclass SampleConsensus[T]:
+        # SampleConsensus (const SampleConsensusModelPtr &model, bool random = false)
+        # SampleConsensus (const SampleConsensusModelPtr &model, double threshold, bool random = false) : 
+        # \brief Constructor for base SAC.
+        # \param[in] model a Sample Consensus model
+        # \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
+        SampleConsensus (const SampleConsensusModelPtr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZI_Ptr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZRGB_Ptr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZRGBA_Ptr_t &model)
+        
+        # public:
+        # typedef boost::shared_ptr<SampleConsensus> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensus> ConstPtr;
+        # \brief Set the distance to model threshold.
+        # \param[in] threshold distance to model threshold
+        # inline void setDistanceThreshold (double threshold)
+        void setDistanceThreshold (double threshold)
+        
+        # /** \brief Get the distance to model threshold, as set by the user. */
+        # inline double getDistanceThreshold ()
+        double getDistanceThreshold ()
+        
+        # /** \brief Set the maximum number of iterations.
+        # * \param[in] max_iterations maximum number of iterations
+        # inline void setMaxIterations (int max_iterations)
+        void setMaxIterations (int max_iterations)
+        
+        # /** \brief Get the maximum number of iterations, as set by the user. */
+        # inline int getMaxIterations ()
+        int getMaxIterations ()
+        
+        # /** \brief Set the desired probability of choosing at least one sample free from outliers.
+        # * \param[in] probability the desired probability of choosing at least one sample free from outliers
+        # * \note internally, the probability is set to 99% (0.99) by default.
+        # inline void setProbability (double probability)
+        void setProbability (double probability)
+        
+        # /** \brief Obtain the probability of choosing at least one sample free from outliers, as set by the user. */
+        # inline double getProbability ()
+        double getProbability ()
+        
+        # /** \brief Compute the actual model. Pure virtual. */
+        # virtual bool computeModel (int debug_verbosity_level = 0) = 0;
+        
+        # /** \brief Get a set of randomly selected indices.
+        # * \param[in] indices the input indices vector
+        # * \param[in] nr_samples the desired number of point indices to randomly select
+        # * \param[out] indices_subset the resultant output set of randomly selected indices
+        # inline void getRandomSamples (const boost::shared_ptr <std::vector<int> > &indices,  size_t nr_samples, std::set<int> &indices_subset)
+        # void getRandomSamples (shared_ptr [vector[int]] &indices,  size_t nr_samples, set[int] &indices_subset)
+        
+        # /** \brief Return the best model found so far. 
+        # * \param[out] model the resultant model
+        # inline void getModel (std::vector<int> &model)
+        void getModel (vector[int] &model)
+        
+        # /** \brief Return the best set of inliers found so far for this model. 
+        # * \param[out] inliers the resultant set of inliers
+        # inline void getInliers (std::vector<int> &inliers)
+        void getInliers (vector[int] &inliers)
+        
+        # /** \brief Return the model coefficients of the best model found so far. 
+        # * \param[out] model_coefficients the resultant model coefficients
+        # inline void  getModelCoefficients (Eigen::VectorXf &model_coefficients)
+
+
+ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t
+ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+
+# template<typename _Scalar, int NX=Eigen::Dynamic, int NY=Eigen::Dynamic>
+# struct Functor
+cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+    cdef cppclass Functor[_Scalar]:
+        Functor ()
+        # Functor (int m_data_points)
+        # typedef _Scalar Scalar;
+        # enum 
+        # {
+        #   InputsAtCompileTime = NX,
+        #   ValuesAtCompileTime = NY
+        # };
+        # typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,1> ValueType;
+        # typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> InputType;
+        # typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,InputsAtCompileTime> JacobianType;
+        # /** \brief Get the number of values. */ 
+        # int values () const
+
+
+###
+
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Project a point on a planar model given by a set of normalized coefficients
+#   * \param[in] p the input point to project
+#   * \param[in] model_coefficients the coefficients of the plane (a, b, c, d) that satisfy ax+by+cz+d=0
+#   * \param[out] q the resultant projected point
+#   */
+# template <typename Point> inline void
+# projectPoint (const Point &p, const Eigen::Vector4f &model_coefficients, Point &q)
+# {
+#   // Calculate the distance from the point to the plane
+#   Eigen::Vector4f pp (p.x, p.y, p.z, 1);
+#   // use normalized coefficients to calculate the scalar projection 
+#   float distance_to_plane = pp.dot(model_coefficients);
+#  
+#   //TODO: Why doesn't getVector4Map work here?
+#   //Eigen::Vector4f q_e = q.getVector4fMap ();
+#   //q_e = pp - model_coefficients * distance_to_plane;
+#   
+#   Eigen::Vector4f q_e = pp - distance_to_plane * model_coefficients;
+#   q.x = q_e[0];
+#   q.y = q_e[1];
+#   q.z = q_e[2];
+# }
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param a the normalized <i>a</i> coefficient of a plane
+#   * \param b the normalized <i>b</i> coefficient of a plane
+#   * \param c the normalized <i>c</i> coefficient of a plane
+#   * \param d the normalized <i>d</i> coefficient of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistanceSigned (const Point &p, double a, double b, double c, double d)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param plane_coefficients the normalized coefficients (a, b, c, d) of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistanceSigned (const Point &p, const Eigen::Vector4f &plane_coefficients)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param a the normalized <i>a</i> coefficient of a plane
+#   * \param b the normalized <i>b</i> coefficient of a plane
+#   * \param c the normalized <i>c</i> coefficient of a plane
+#   * \param d the normalized <i>d</i> coefficient of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistance (const Point &p, double a, double b, double c, double d)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param plane_coefficients the normalized coefficients (a, b, c, d) of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistance (const Point &p, const Eigen::Vector4f &plane_coefficients)
+###
+
+# sac_model_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelPlane defines a model for 3D plane segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelPlane : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelPlane[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelPlane()
+        SampleConsensusModelPlane(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # public:
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelPlane (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        
+        # /** \brief Check whether the given index samples can form a valid plane model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The plane coefficients are:
+        # * a, b, c, d (ax+by+cz+d=0)
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the plane coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the plane model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the plane model.
+        # * \param[in] inliers the data inliers that we want to project on the plane model
+        # * \param[in] model_coefficients the *normalized* coefficients of a plane model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given plane model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the plane model
+        # * \param[in] model_coefficients the plane model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PLANE); }
+
+
+ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_sphere.h
+# namespace pcl
+# /** \brief SampleConsensusModelSphere defines a model for 3D sphere segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b center.x : the X coordinate of the sphere's center
+#   *   - \b center.y : the Y coordinate of the sphere's center
+#   *   - \b center.z : the Z coordinate of the sphere's center
+#   *   - \b radius   : the sphere's radius
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelSphere : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_sphere.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelSphere[PointT](SampleConsensusModel[PointT]):
+        # SampleConsensusModelSphere()
+        SampleConsensusModelSphere(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # public:
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelSphere> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelSphere (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud), tmp_inliers_ ()
+        # 
+        # /** \brief Constructor for base SampleConsensusModelSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelSphere (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModel<PointT> (cloud, indices), tmp_inliers_ ()
+        # 
+        # /** \brief Copy constructor.
+        # * \param[in] source the model to copy into this
+        # */
+        # SampleConsensusModelSphere (const SampleConsensusModelSphere &source) :
+        # SampleConsensusModel<PointT> (), tmp_inliers_ () 
+        # 
+        # /** \brief Copy constructor.
+        # * \param[in] source the model to copy into this
+        # */
+        # inline SampleConsensusModelSphere& operator = (const SampleConsensusModelSphere &source)
+        # 
+        # /** \brief Check whether the given index samples can form a valid sphere model, compute the model 
+        # * coefficients from these samples and store them internally in model_coefficients. 
+        # * The sphere coefficients are: x, y, z, R.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given sphere model.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the sphere coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the sphere model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the sphere model.
+        # * \param[in] inliers the data inliers that we want to project on the sphere model
+        # * \param[in] model_coefficients the coefficients of a sphere model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # * \todo implement this.
+        # */
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given sphere model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the sphere model
+        # * \param[in] model_coefficients the sphere model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_SPHERE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_SPHERE); }
+
+
+ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t
+###
+
+### Inheritance class ###
+
+# lmeds.h
+# namespace pcl
+# template <typename PointT>
+# class LeastMedianSquares : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/lmeds.h" namespace "pcl":
+    cdef cppclass LeastMedianSquares[T](SampleConsensus[T]):
+        # LeastMedianSquares ()
+        LeastMedianSquares (shared_ptr[SampleConsensusModel[T]] model)
+        # LeastMedianSquares (const SampleConsensusModelPtr &model)
+        # LeastMedianSquares (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        #   * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        #   */
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level = 0)
+
+
+###
+
+# mlesac.h
+# namespace pcl
+# template <typename PointT>
+# class MaximumLikelihoodSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/mlesac.h" namespace "pcl":
+    cdef cppclass MaximumLikelihoodSampleConsensus[T](SampleConsensus[T]):
+        MaximumLikelihoodSampleConsensus ()
+        MaximumLikelihoodSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # \brief MLESAC (Maximum Likelihood Estimator SAmple Consensus) main constructor
+        # \param[in] model a Sample Consensus model
+        # MaximumLikelihoodSampleConsensus (const SampleConsensusModelPtr &model)
+        # MaximumLikelihoodSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr; 
+        # public:
+        # \brief Compute the actual model and find the inliers
+        # \param[in] debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        
+        # /** \brief Set the number of EM iterations.
+        # * \param[in] iterations the number of EM iterations
+        # inline void setEMIterations (int iterations)
+        
+        # /** \brief Get the number of EM iterations. */
+        # inline int getEMIterations () const { return (iterations_EM_); }
+
+
+###
+
+# msac.h
+# namespace pcl
+#   template <typename PointT>
+#   class MEstimatorSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/msac.h" namespace "pcl":
+    cdef cppclass MEstimatorSampleConsensus[T](SampleConsensus[T]):
+        MEstimatorSampleConsensus ()
+        MEstimatorSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # MEstimatorSampleConsensus (const SampleConsensusModelPtr &model)
+        # MEstimatorSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # \brief Compute the actual model and find the inliers
+        # \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+
+
+###
+
+# prosac.h
+# namespace pcl
+# template<typename PointT>
+# class ProgressiveSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/prosac.h" namespace "pcl":
+    cdef cppclass ProgressiveSampleConsensus[T](SampleConsensus[T]):
+        ProgressiveSampleConsensus ()
+        # ProgressiveSampleConsensus (const SampleConsensusModelPtr &model) 
+        # ProgressiveSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level)
+
+
+###
+
+# ransac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/ransac.h" namespace "pcl":
+    cdef cppclass RandomSampleConsensus[T](SampleConsensus[T]):
+        # RandomSampleConsensus ()
+        RandomSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        
+        # RandomSampleConsensus (shared_ptr[SampleConsensus[T]] model)
+        # RandomSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+
+
+ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t
+ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# rmsac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomizedMEstimatorSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/rmsac.h" namespace "pcl":
+    cdef cppclass RandomizedMEstimatorSampleConsensus[T](SampleConsensus[T]):
+        RandomizedMEstimatorSampleConsensus ()
+        # RandomizedMEstimatorSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomizedMEstimatorSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        RandomizedMEstimatorSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # */
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+        
+        # /** \brief Set the percentage of points to pre-test.
+        # * \param nr_pretest percentage of points to pre-test
+        # */
+        # inline void setFractionNrPretest (double nr_pretest)
+        void setFractionNrPretest (double nr_pretest)
+        
+        # /** \brief Get the percentage of points to pre-test. */
+        # inline double getFractionNrPretest ()
+        double getFractionNrPretest ()
+
+
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# rransac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomizedRandomSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+    cdef cppclass RandomizedRandomSampleConsensus[T](SampleConsensus[T]):
+        RandomizedRandomSampleConsensus ()
+        RandomizedRandomSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # RandomizedRandomSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomizedRandomSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief RRANSAC (RAndom SAmple Consensus) main constructor
+        # * \param model a Sample Consensus model
+        # * \param threshold distance to model threshold
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # */
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level)
+        
+        # \brief Set the percentage of points to pre-test.
+        # \param nr_pretest percentage of points to pre-test
+        # inline void setFractionNrPretest (double nr_pretest)
+        void setFractionNrPretest (double nr_pretest)
+        
+        # /** \brief Get the percentage of points to pre-test. */
+        # inline double getFractionNrPretest ()
+        double getFractionNrPretest ()
+
+
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_circle.h
+# namespace pcl
+# template <typename PointT>
+# class SampleConsensusModelCircle2D : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_circle.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelCircle2D[T](SampleConsensusModel[T]):
+        SampleConsensusModelCircle2D ()
+        # SampleConsensusModelCircle2D (const PointCloudConstPtr &cloud)
+        # SampleConsensusModelCircle2D (const PointCloudConstPtr &cloud, const std::vector<int> &indices)
+        # SampleConsensusModelCircle2D (const SampleConsensusModelCircle2D &source) :
+        # inline SampleConsensusModelCircle2D& operator = (const SampleConsensusModelCircle2D &source)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCircle2D> Ptr;
+        # /** \brief Check whether the given index samples can form a valid 2D circle model, compute the model coefficients
+        # * from these samples and store them in model_coefficients. The circle coefficients are: x, y, R.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # /** \brief Compute all distances from the cloud data to a given 2D circle model.
+        # * \param[in] model_coefficients the coefficients of a 2D circle model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # /** \brief Compute all distances from the cloud data to a given 2D circle model.
+        # * \param[in] model_coefficients the coefficients of a 2D circle model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold, 
+        #                     std::vector<int> &inliers);
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                    const double threshold);
+        # /** \brief Recompute the 2d circle coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the 2d circle model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # /** \brief Create a new point cloud with inliers projected onto the 2d circle model.
+        # * \param[in] inliers the data inliers that we want to project on the 2d circle model
+        # * \param[in] model_coefficients the coefficients of a 2d circle model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # /** \brief Verify whether a subset of indices verifies the given 2d circle model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the 2d circle model
+        # * \param[in] model_coefficients the 2d circle model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # /** \brief Return an unique id for this model (SACMODEL_CIRCLE2D). */
+        # inline pcl::SacModel getModelType () const
+
+
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t
+###
+
+# namespace pcl
+# struct OptimizationFunctor : pcl::Functor<float>
+#         OptimizationFunctor (int m_data_points, pcl::SampleConsensusModelCircle2D<PointT> *model) : 
+# 
+#         /** Cost function to be minimized
+#           * \param[in] x the variables array
+#           * \param[out] fvec the resultant functions evaluations
+#           * \return 0
+#           */
+#         int operator() (const Eigen::VectorXf &x, Eigen::VectorXf &fvec) const
+#         pcl::SampleConsensusModelCircle2D<PointT> *model_;
+###
+
+# sac_model_cone.h
+# namespace pcl
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelCone : public SampleConsensusModel<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_cone.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelCone[T, NT](SampleConsensusModel[T])(SampleConsensusModelFromNormals[T, NT]):
+    cdef cppclass SampleConsensusModelCone[T, NT]:
+        SampleConsensusModelCone ()
+        # Nothing
+        # SampleConsensusModelCone ()
+        # Use
+        # SampleConsensusModelCone (const PointCloudConstPtr &cloud)
+        # SampleConsensusModelCone (const PointCloudConstPtr &cloud, const std::vector<int> &indices)
+        # SampleConsensusModelCone (const SampleConsensusModelCone &source)
+        # inline SampleConsensusModelCone& operator = (const SampleConsensusModelCone &source)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCone> Ptr;
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the cone's axis and the given axis.
+        # inline void setEpsAngle (double ea)
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () const
+        # /** \brief Set the axis along which we need to search for a cone direction.
+        # * \param[in] ax the axis along which we need to search for a cone direction
+        # inline void setAxis (const Eigen::Vector3f &ax)
+        # /** \brief Get the axis along which we need to search for a cone direction. */
+        # inline Eigen::Vector3f getAxis () const
+        # /** \brief Set the minimum and maximum allowable opening angle for a cone model
+        # * given from a user.
+        # * \param[in] min_angle the minimum allwoable opening angle of a cone model
+        # * \param[in] max_angle the maximum allwoable opening angle of a cone model
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        # /** \brief Get the opening angle which we need minumum to validate a cone model.
+        # * \param[out] min_angle the minimum allwoable opening angle of a cone model
+        # * \param[out] max_angle the maximum allwoable opening angle of a cone model
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle) const
+        # /** \brief Check whether the given index samples can form a valid cone model, compute the model coefficients
+        # * from these samples and store them in model_coefficients. The cone coefficients are: apex,
+        # * axis_direction, opening_angle.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # /** \brief Compute all distances from the cloud data to a given cone model.
+        # * \param[in] model_coefficients the coefficients of a cone model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients,  std::vector<double> &distances);
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a cone model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold, std::vector<int> &inliers);
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # /** \brief Recompute the cone coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the cone model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # /** \brief Create a new point cloud with inliers projected onto the cone model.
+        # * \param[in] inliers the data inliers that we want to project on the cone model
+        # * \param[in] model_coefficients the coefficients of a cone model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, bool copy_data_fields = true);
+        # /** \brief Verify whether a subset of indices verifies the given cone model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the cone model
+        # * \param[in] model_coefficients the cone model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, const double threshold);
+        # /** \brief Return an unique id for this model (SACMODEL_CONE). */
+        # inline pcl::SacModel getModelType () const
+        # protected:
+        # /** \brief Get the distance from a point to a line (represented by a point and a direction)
+        # * \param[in] pt a point
+        # * \param[in] model_coefficients the line coefficients (a point on the line, line direction)
+        # double pointToAxisDistance (const Eigen::Vector4f &pt, const Eigen::VectorXf &model_coefficients);
+        # /** \brief Get a string representation of the name of this class. */
+        # std::string getName () const { return ("SampleConsensusModelCone"); }
+        # protected:
+        # /** \brief Check whether a model is valid given the user constraints.
+        # * \param[in] model_coefficients the set of model coefficients
+        # bool isModelValid (const Eigen::VectorXf &model_coefficients);
+        # /** \brief Check if a sample of indices results in a good sample of points
+        # * indices. Pure virtual.
+        # * \param[in] samples the resultant index samples
+        # bool isSampleGood (const std::vector<int> &samples) const;
+
+
+ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t
+###
+
+# namespace pcl
+# /** \brief Functor for the optimization function */
+# struct OptimizationFunctor : pcl::Functor<float>
+# cdef extern from "pcl/sample_consensus/sac_model_cone.h" namespace "pcl":
+#     cdef cppclass OptimizationFunctor(Functor[float]):
+#         OptimizationFunctor (int m_data_points, pcl::SampleConsensusModelCone<PointT, PointNT> *model) : 
+#         int operator() (const Eigen::VectorXf &x, Eigen::VectorXf &fvec) const
+#         pcl::SampleConsensusModelCone<PointT, PointNT> *model_;
+###
+
+
+# sac_model_cylinder.h
+# namespace pcl
+# \brief @b SampleConsensusModelCylinder defines a model for 3D cylinder segmentation.
+# The model coefficients are defined as:
+# \b point_on_axis.x  : the X coordinate of a point located on the cylinder axis
+# \b point_on_axis.y  : the Y coordinate of a point located on the cylinder axis
+# \b point_on_axis.z  : the Z coordinate of a point located on the cylinder axis
+# \b axis_direction.x : the X coordinate of the cylinder's axis direction
+# \b axis_direction.y : the Y coordinate of the cylinder's axis direction
+# \b axis_direction.z : the Z coordinate of the cylinder's axis direction
+# \b radius           : the cylinder's radius
+# \author Radu Bogdan Rusu
+# \ingroup sample_consensus
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelCylinder : public SampleConsensusModel<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+# Multi Inheritance NG
+# cdef cppclass SampleConsensusModelCylinder[PointT](SampleConsensusModel[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+cdef extern from "pcl/sample_consensus/sac_model_cylinder.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelCylinder[PointT, PointNT]:
+        SampleConsensusModelCylinder()
+        SampleConsensusModelCylinder(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCylinder> Ptr;
+        # 
+        # \brief Constructor for base SampleConsensusModelCylinder.
+        # \param[in] cloud the input point cloud dataset
+        # SampleConsensusModelCylinder (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Constructor for base SampleConsensusModelCylinder.
+        # \param[in] cloud the input point cloud dataset
+        # \param[in] indices a vector of point indices to be used from \a cloud
+        # SampleConsensusModelCylinder (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModel<PointT> (cloud, indices), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Copy constructor.
+        # \param[in] source the model to copy into this
+        # SampleConsensusModelCylinder (const SampleConsensusModelCylinder &source) :
+        # SampleConsensusModel<PointT> (),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Copy constructor.
+        # \param[in] source the model to copy into this
+        # inline SampleConsensusModelCylinder& operator = (const SampleConsensusModelCylinder &source)
+        # 
+        # \brief Set the angle epsilon (delta) threshold.
+        # \param[in] ea the maximum allowed difference between the cyilinder axis and the given axis.
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # \brief Get the angle epsilon (delta) threshold.
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # \brief Set the axis along which we need to search for a cylinder direction.
+        # \param[in] ax the axis along which we need to search for a cylinder direction
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # \brief Get the axis along which we need to search for a cylinder direction.
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # \brief Check whether the given index samples can form a valid cylinder model, compute the model coefficients
+        #  from these samples and store them in model_coefficients. The cylinder coefficients are: point_on_axis,
+        #  axis_direction, cylinder_radius_R
+        # \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # \brief Compute all distances from the cloud data to a given cylinder model.
+        # \param[in] model_coefficients the coefficients of a cylinder model that we need to compute distances to
+        # \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # \brief Select all the points which respect the given model coefficients as inliers.
+        # \param[in] model_coefficients the coefficients of a cylinder model that we need to compute distances to
+        # \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # \brief Count all the points which respect the given model coefficients as inliers. 
+        # \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # \brief Recompute the cylinder coefficients using the given inlier set and return them to the user.
+        #  @note: these are the coefficients of the cylinder model after refinement (eg. after SVD)
+        # \param[in] inliers the data inliers found as supporting the model
+        # \param[in] model_coefficients the initial guess for the optimization
+        # \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # \brief Create a new point cloud with inliers projected onto the cylinder model.
+        # \param[in] inliers the data inliers that we want to project on the cylinder model
+        # \param[in] model_coefficients the coefficients of a cylinder model
+        # \param[out] projected_points the resultant projected points
+        # \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients,  PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # \brief Verify whether a subset of indices verifies the given cylinder model coefficients.
+        # \param[in] indices the data indices that need to be tested against the cylinder model
+        # \param[in] model_coefficients the cylinder model coefficients
+        # \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_CYLINDER). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_CYLINDER); }
+
+
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_line.h
+# namespace pcl
+# /** \brief SampleConsensusModelLine defines a model for 3D line segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   *
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelLine : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_line.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelLine[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelLine()
+        SampleConsensusModelLine(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelLine> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelLine (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelLine (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        # 
+        # /** \brief Check whether the given index samples can form a valid line model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The line coefficients are represented by a
+        # * point and a line direction
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given line model.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the line coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the line model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the line model.
+        # * \param[in] inliers the data inliers that we want to project on the line model
+        # * \param[in] model_coefficients the *normalized* coefficients of a line model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given line model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the line model
+        # * \param[in] model_coefficients the line model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_LINE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_LINE); }
+
+
+ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_parallel_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelNormalParallelPlane defines a model for 3D
+#   * plane segmentation using additional surface normal constraints. Basically
+#   * this means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the plane's normal and the inlier points normals. In addition,
+#   * the plane normal must lie parallel to an user-specified axis.
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * To set the influence of the surface normals in the inlier estimation
+#   * process, set the normal weight (0.0-1.0), e.g.:
+#   * \code
+#   * SampleConsensusModelNormalPlane<pcl::PointXYZ, pcl::Normal> sac_model;
+#   * ...
+#   * sac_model.setNormalDistanceWeight (0.1);
+#   * ...
+#   * \endcode
+#   * In addition, the user can specify more constraints, such as:
+#   * 
+#   *   - an axis along which we need to search for a plane perpendicular to (\ref setAxis);
+#   *   - an angle \a tolerance threshold between the plane's normal and the above given axis (\ref setEpsAngle);
+#   *   - a distance we expect the plane to be from the origin (\ref setDistanceFromOrigin);
+#   *   - a distance \a tolerance as the maximum allowed deviation from the above given distance from the origin (\ref setEpsDist).
+#   *
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu B. Rusu and Jared Glover and Nico Blodow
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalParallelPlane : public SampleConsensusModelPlane<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_parallel_plane.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalParallelPlane[PointT](SampleConsensusModelPlane[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalParallelPlane[PointT, PointNT]:
+        SampleConsensusModelNormalParallelPlane()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalParallelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalParallelPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud),
+        # axis_ (Eigen::Vector4f::Zero ()),
+        # distance_from_origin_ (0),
+        # eps_angle_ (-1.0), cos_angle_ (-1.0), eps_dist_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalParallelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector4f::Zero ()),
+        # distance_from_origin_ (0),
+        # eps_angle_ (-1.0), cos_angle_ (-1.0), eps_dist_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_.head<3> () = ax; axis_.normalize ();}
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis () { return (axis_.head<3> ()); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed deviation from 90 degrees between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; cos_angle_ = fabs (cos (ea));}
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Set the distance we expect the plane to be from the origin
+        # * \param[in] d distance from the template plane to the origin
+        # */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        # 
+        # /** \brief Get the distance of the plane from the origin. */
+        # inline double getDistanceFromOrigin () { return (distance_from_origin_); }
+        # 
+        # /** \brief Set the distance epsilon (delta) threshold.
+        # * \param[in] delta the maximum allowed deviation from the template distance from the origin
+        # */
+        # inline void setEpsDist (const double delta) { eps_dist_ = delta; }
+        # 
+        # /** \brief Get the distance epsilon (delta) threshold. */
+        # inline double getEpsDist () { return (eps_dist_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # *
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_PARALLEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_PARALLEL_PLANE); }
+
+
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelNormalPlane defines a model for 3D plane
+#   * segmentation using additional surface normal constraints. Basically this
+#   * means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the plane's normal and the inlier points normals.
+#   *
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * To set the influence of the surface normals in the inlier estimation
+#   * process, set the normal weight (0.0-1.0), e.g.:
+#   * \code
+#   * SampleConsensusModelNormalPlane<pcl::PointXYZ, pcl::Normal> sac_model;
+#   * ...
+#   * sac_model.setNormalDistanceWeight (0.1);
+#   * ...
+#   * \endcode
+#   * \author Radu B. Rusu and Jared Glover
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalPlane : public SampleConsensusModelPlane<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_plane.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalPlane[PointT, PointNT](SampleConsensusModelPlane[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalPlane[PointT, PointNT]:
+        SampleConsensusModelNormalPlane()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalPlane (const PointCloudConstPtr &cloud) : SampleConsensusModelPlane<PointT> (cloud)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModelPlane<PointT> (cloud, indices)
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_PLANE); }
+
+
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_sphere.h
+# namespace pcl
+# /** \brief @b SampleConsensusModelNormalSphere defines a model for 3D sphere
+#   * segmentation using additional surface normal constraints. Basically this
+#   * means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the sphere's normal and the inlier points normals.
+#   * The model coefficients are defined as:
+#   * <ul>
+#   * <li><b>a</b> : the X coordinate of the plane's normal (normalized)
+#   * <li><b>b</b> : the Y coordinate of the plane's normal (normalized)
+#   * <li><b>c</b> : the Z coordinate of the plane's normal (normalized)
+#   * <li><b>d</b> : radius of the sphere
+#   * </ul>
+#   * \author Stefan Schrandt
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalSphere : public SampleConsensusModelSphere<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_sphere.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalSphere[PointT, PointNT](SampleConsensusModelSphere[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalSphere[PointT, PointNT]:
+        SampleConsensusModelNormalSphere()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalSphere> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalSphere (const PointCloudConstPtr &cloud) : SampleConsensusModelSphere<PointT> (cloud)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalSphere (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModelSphere<PointT> (cloud, indices)
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given sphere model.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_SPHERE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_SPHERE); }
+
+
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_parallel_line.h
+# namespace pcl
+# /** \brief SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular
+#   * constraints.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelParallelLine : public SampleConsensusModelLine<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_parallel_line.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelParallelLine[PointT](SampleConsensusModelLine[PointT]):
+    cdef cppclass SampleConsensusModelParallelLine[PointT]:
+        SampleConsensusModelParallelLine()
+        # public:
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelParallelLine> Ptr;
+        # /** \brief Constructor for base SampleConsensusModelParallelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelParallelLine (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelLine<PointT> (cloud),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelParallelLine (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelLine<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; axis_.normalize (); }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given line model.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PARALLEL_LINE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PARALLEL_LINE); }
+
+
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_parallel_plane.h
+# namespace pcl
+# /** \brief @b SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional
+#   * angular constraints. The plane must be parallel to a user-specified axis
+#   * (\ref setAxis) within an user-specified angle threshold (\ref setEpsAngle).
+#   * Code example for a plane model, parallel (within a 15 degrees tolerance) with the Z axis:
+#   * \code
+#   * SampleConsensusModelParallelPlane<pcl::PointXYZ> model (cloud);
+#   * model.setAxis (Eigen::Vector3f (0.0, 0.0, 1.0));
+#   * model.setEpsAngle (pcl::deg2rad (15));
+#   * \endcode
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu Bogdan Rusu, Nico Blodow
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelParallelPlane : public SampleConsensusModelPlane<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_parallel_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelParallelPlane[PointT](SampleConsensusModelPlane[PointT]):
+        SampleConsensusModelParallelLine()
+        # public:
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelParallelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelParallelPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0), sin_angle_ (-1.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelParallelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0), sin_angle_ (-1.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; sin_angle_ = fabs (sin (ea));}
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PARALLEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PARALLEL_PLANE); }
+
+
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_perpendicular_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional
+#   * angular constraints. The plane must be perpendicular to an user-specified axis (\ref setAxis), up to an user-specified angle threshold (\ref setEpsAngle).
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * Code example for a plane model, perpendicular (within a 15 degrees tolerance) with the Z axis:
+#   * \code
+#   * SampleConsensusModelPerpendicularPlane<pcl::PointXYZ> model (cloud);
+#   * model.setAxis (Eigen::Vector3f (0.0, 0.0, 1.0));
+#   * model.setEpsAngle (pcl::deg2rad (15));
+#   * \endcode
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelPerpendicularPlane : public SampleConsensusModelPlane<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_perpendicular_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelPerpendicularPlane[PointT](SampleConsensusModelPlane[PointT]):
+        SampleConsensusModelPerpendicularPlane()
+        # public:
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelPerpendicularPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPerpendicularPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelPerpendicularPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPerpendicularPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelPerpendicularPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PERPENDICULAR_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PERPENDICULAR_PLANE); }
+
+
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_registration.h
+# namespace pcl
+# /** \brief SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelRegistration : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_registration.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelRegistration[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelRegistration()
+        SampleConsensusModelRegistration(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelRegistration> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelRegistration.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelRegistration (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud),
+        # target_ (),
+        # indices_tgt_ (),
+        # correspondences_ (),
+        # sample_dist_thresh_ (0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelRegistration.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelRegistration (const PointCloudConstPtr &cloud, const std::vector<int> &indices) :
+        # SampleConsensusModel<PointT> (cloud, indices),
+        # target_ (),
+        # indices_tgt_ (),
+        # correspondences_ (),
+        # sample_dist_thresh_ (0)
+        # 
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # inline virtual void setInputCloud (const PointCloudConstPtr &cloud)
+        # 
+        # /** \brief Set the input point cloud target.
+        # * \param target the input point cloud target
+        # */
+        # inline void setInputTarget (const PointCloudConstPtr &target)
+        # 
+        # /** \brief Set the input point cloud target.
+        # * \param[in] target the input point cloud target
+        # * \param[in] indices_tgt a vector of point indices to be used from \a target
+        # */
+        # inline void setInputTarget (const PointCloudConstPtr &target, const std::vector<int> &indices_tgt)
+        # 
+        # /** \brief Compute a 4x4 rigid transformation matrix from the samples given
+        # * \param[in] samples the indices found as good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the transformed points to their correspondences
+        # * \param[in] model_coefficients the 4x4 transformation matrix
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the 4x4 transformation matrix
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the 4x4 transformation using the given inlier set
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed transformation
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # void projectPoints (const std::vector<int> &, const Eigen::VectorXf &, PointCloud &, bool = true)
+        # 
+        # bool doSamplesVerifyModel (const std::set<int> &, const Eigen::VectorXf &, const double)
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_REGISTRATION). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_REGISTRATION); }
+
+
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_stick.h
+# namespace pcl
+# /** \brief SampleConsensusModelStick defines a model for 3D stick segmentation. 
+#   * A stick is a line with an user given minimum/maximum width.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   *   - \b line_width       : the width of the line
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelStick : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_stick.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelStick[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelStick()
+        SampleConsensusModelStick(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelStick> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelStick.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelStick (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelStick.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelStick (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        # 
+        # /** \brief Check whether the given index samples can form a valid stick model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The stick coefficients are represented by a
+        # * point and a line direction
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given stick model.
+        # * \param[in] model_coefficients the coefficients of a stick model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a stick model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the stick coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the stick model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the stick model.
+        # * \param[in] inliers the data inliers that we want to project on the stick model
+        # * \param[in] model_coefficients the *normalized* coefficients of a stick model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given stick model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the plane model
+        # * \param[in] model_coefficients the plane model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_STACK). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_STICK); }
+
+
+ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# method_types.h
+cdef extern from "pcl/sample_consensus/method_types.h" namespace "pcl":
+    cdef enum:
+        SAC_RANSAC = 0
+        SAC_LMEDS = 1
+        SAC_MSAC = 2
+        SAC_RRANSAC = 3
+        SAC_RMSAC = 4
+        SAC_MLESAC = 5
+        SAC_PROSAC = 6
+###
+
+# model_types.h
+cdef extern from "pcl/sample_consensus/model_types.h" namespace "pcl":
+    cdef enum SacModel:
+        SACMODEL_PLANE
+        SACMODEL_LINE
+        SACMODEL_CIRCLE2D
+        SACMODEL_CIRCLE3D
+        SACMODEL_SPHERE
+        SACMODEL_CYLINDER
+        SACMODEL_CONE
+        SACMODEL_TORUS
+        SACMODEL_PARALLEL_LINE
+        SACMODEL_PERPENDICULAR_PLANE
+        SACMODEL_PARALLEL_LINES
+        SACMODEL_NORMAL_PLANE
+        SACMODEL_NORMAL_SPHERE        # Version 1.6
+        SACMODEL_REGISTRATION
+        SACMODEL_PARALLEL_PLANE
+        SACMODEL_NORMAL_PARALLEL_PLANE
+        SACMODEL_STICK
+###
+
+# cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+#     cdef cppclass Functor[_Scalar]:
+#         # enum 
+#         # {
+#         #   InputsAtCompileTime = NX,
+#         #   ValuesAtCompileTime = NY
+#         # };
+
+
+# // Define the number of samples in SacModel needs
+# typedef std::map<pcl::SacModel, unsigned int>::value_type SampleSizeModel;
+# const static SampleSizeModel sample_size_pairs[] = {SampleSizeModel (pcl::SACMODEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_LINE, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_CIRCLE2D, 3),
+#                                                     //SampleSizeModel (pcl::SACMODEL_CIRCLE3D, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_SPHERE, 4),
+#                                                     SampleSizeModel (pcl::SACMODEL_CYLINDER, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_CONE, 3),
+#                                                     //SampleSizeModel (pcl::SACMODEL_TORUS, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_PARALLEL_LINE, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_PERPENDICULAR_PLANE, 3),
+#                                                     //SampleSizeModel (pcl::PARALLEL_LINES, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_SPHERE, 4),
+#                                                     SampleSizeModel (pcl::SACMODEL_REGISTRATION, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_PARALLEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_PARALLEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_STICK, 2)};
+# 
+# namespace pcl
+# {
+#   const static std::map<pcl::SacModel, unsigned int> SAC_SAMPLE_SIZE (sample_size_pairs, sample_size_pairs + sizeof (sample_size_pairs) / sizeof (SampleSizeModel));
+# }
+###
+
+###############################################################################
+# Activation
+###############################################################################
+
diff --git a/pcl/pcl_sample_consensus_172.pxd b/pcl/pcl_sample_consensus_172.pxd
new file mode 100644
index 0000000..601262d
--- /dev/null
+++ b/pcl/pcl_sample_consensus_172.pxd
@@ -0,0 +1,2301 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# import
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# sac_model.h
+# namespace pcl
+# template<class T> class ProgressiveSampleConsensus;
+
+# sac_model.h
+# namespace pcl
+# template <typename PointT>
+# class SampleConsensusModel
+cdef extern from "pcl/sample_consensus/sac_model.h" namespace "pcl":
+    cdef cppclass SampleConsensusModel[T]:
+        SampleConsensusModel()
+        # SampleConsensusModel (bool random = false) 
+        # SampleConsensusModel (const PointCloudConstPtr &cloud, bool random = false)
+        # SampleConsensusModel (const PointCloudConstPtr &cloud, const std::vector<int> &indices, bool random = false)
+        # public:
+        # typedef typename pcl::PointCloud<PointT> PointCloud;
+        # typedef typename pcl::PointCloud<PointT>::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointT>::Ptr PointCloudPtr;
+        # typedef typename pcl::search::Search<PointT>::Ptr SearchPtr;
+        # typedef boost::shared_ptr<SampleConsensusModel> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusModel> ConstPtr;
+        # public:
+        # /** \brief Get a set of random data samples and return them as point
+        # * indices. Pure virtual.  
+        # * \param[out] iterations the internal number of iterations used by SAC methods
+        # * \param[out] samples the resultant model samples
+        # */
+        # void getSamples (int &iterations, std::vector<int> &samples)
+        void getSamples (int &iterations, vector[int] &samples)
+        
+        # /** \brief Check whether the given index samples can form a valid model,
+        # * compute the model coefficients from these samples and store them
+        # * in model_coefficients. Pure virtual.
+        # * \param[in] samples the point indices found as possible good candidates
+        # * for creating a valid model 
+        # * \param[out] model_coefficients the computed model coefficients
+        # */
+        # virtual bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients) = 0;
+        
+        # /** \brief Recompute the model coefficients using the given inlier set
+        # * and return them to the user. Pure virtual.
+        # * @note: these are the coefficients of the model after refinement
+        # * (e.g., after a least-squares optimization)
+        # * \param[in] inliers the data inliers supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # virtual void optimizeModelCoefficients (const std::vector<int> &inliers,  const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients) = 0;
+        
+        # /** \brief Compute all distances from the cloud data to a given model. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to 
+        # * \param[out] distances the resultant estimated distances
+        # virtual void  getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances) = 0;
+        # /** \brief Select all the points which respect the given model
+        # * coefficients as inliers. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from 
+        # * the outliers
+        # * \param[out] inliers the resultant model inliers
+        # virtual void selectWithinDistance (const Eigen::VectorXf &model_coefficients,  const double threshold, std::vector<int> &inliers) = 0;
+        
+        # /** \brief Count all the points which respect the given model
+        # * coefficients as inliers. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to
+        # * compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for
+        # * determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold) = 0;
+        
+        # /** \brief Create a new point cloud with inliers projected onto the model. Pure virtual.
+        # * \param[in] inliers the data inliers that we want to project on the model
+        # * \param[in] model_coefficients the coefficients of a model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true (default) if we want the \a
+        # * projected_points cloud to be an exact copy of the input dataset minus
+        # * the point projections on the plane model
+        # virtual void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients,
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true) = 0;
+        
+        # /** \brief Verify whether a subset of indices verifies a given set of
+        # * model coefficients. Pure virtual.
+        # * \param[in] indices the data indices that need to be tested against the model
+        # * \param[in] model_coefficients the set of model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for
+        # * determining the inliers from the outliers
+        # virtual bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold) = 0;
+        
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # inline virtual void setInputCloud (const PointCloudConstPtr &cloud)
+        
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # inline PointCloudConstPtr getInputCloud () const
+        
+        # /** \brief Provide a pointer to the vector of indices that represents the input data.
+        # * \param[in] indices a pointer to the vector of indices that represents the input data.
+        # inline void setIndices (const boost::shared_ptr <std::vector<int> > &indices) 
+        
+        # /** \brief Provide the vector of indices that represents the input data.
+        # * \param[out] indices the vector of indices that represents the input data.
+        # inline void setIndices (const std::vector<int> &indices) 
+        
+        # /** \brief Get a pointer to the vector of indices used. */
+        # inline boost::shared_ptr <std::vector<int> > getIndices () const
+        
+        # /** \brief Return an unique id for each type of model employed. */
+        # virtual SacModel getModelType () const = 0;
+        
+        # /** \brief Return the size of a sample from which a model is computed */
+        # inline unsigned int getSampleSize () const 
+        
+        # /** \brief Set the minimum and maximum allowable radius limits for the
+        # * model (applicable to models that estimate a radius)
+        # * \param[in] min_radius the minimum radius model
+        # * \param[in] max_radius the maximum radius model
+        # * \todo change this to set limits on the entire model
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        
+        # /** \brief Get the minimum and maximum allowable radius limits for the
+        # * model as set by the user.
+        # * \param[out] min_radius the resultant minimum radius model
+        # * \param[out] max_radius the resultant maximum radius model
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        
+        # /** \brief Set the maximum distance allowed when drawing random samples
+        # * \param[in] radius the maximum distance (L2 norm)
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        
+        # /** \brief Get maximum distance allowed when drawing random samples
+        # * \param[out] radius the maximum distance (L2 norm)
+        # inline void getSamplesMaxDist (double &radius)
+
+
+ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t
+ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model.h
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelFromNormals
+cdef extern from "pcl/sample_consensus/sac_model.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelFromNormals[T, NT]:
+        SampleConsensusModelFromNormals ()
+        # public:
+        # typedef typename pcl::PointCloud<PointNT>::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudNPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelFromNormals> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusModelFromNormals> ConstPtr;
+        # /** \brief Set the normal angular distance weight.
+        # * \param[in] w the relative weight (between 0 and 1) to give to the angular
+        # * distance (0 to pi/2) between point normals and the plane normal.
+        # * (The Euclidean distance will have weight 1-w.)
+        # */
+        # inline void setNormalDistanceWeight (const double w) 
+        void setNormalDistanceWeight (const double w) 
+        
+        # /** \brief Get the normal angular distance weight. */
+        # inline double getNormalDistanceWeight ()
+        double getNormalDistanceWeight ()
+        
+        # /** \brief Provide a pointer to the input dataset that contains the point
+        # * normals of the XYZ dataset.
+        # * \param[in] normals the const boost shared pointer to a PointCloud message
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) 
+        void setInputNormals (shared_ptr[cpp.PointCloud[NT]] normals) 
+        
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals ()
+        shared_ptr[cpp.PointCloud[NT]] getInputNormals () 
+
+
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal] SampleConsensusModelFromNormals_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal] SampleConsensusModelFromNormals_PointXYZI_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGB_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t
+###
+
+# sac.h
+# namespace pcl
+# template <typename T>
+# class SampleConsensus
+cdef extern from "pcl/sample_consensus/sac.h" namespace "pcl":
+    cdef cppclass SampleConsensus[T]:
+        # SampleConsensus (const SampleConsensusModelPtr &model, bool random = false)
+        # SampleConsensus (const SampleConsensusModelPtr &model, double threshold, bool random = false) : 
+        # \brief Constructor for base SAC.
+        # \param[in] model a Sample Consensus model
+        # \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
+        SampleConsensus (const SampleConsensusModelPtr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZI_Ptr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZRGB_Ptr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZRGBA_Ptr_t &model)
+        
+        # public:
+        # typedef boost::shared_ptr<SampleConsensus> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensus> ConstPtr;
+        # \brief Set the distance to model threshold.
+        # \param[in] threshold distance to model threshold
+        # inline void setDistanceThreshold (double threshold)
+        void setDistanceThreshold (double threshold)
+        
+        # /** \brief Get the distance to model threshold, as set by the user. */
+        # inline double getDistanceThreshold ()
+        double getDistanceThreshold ()
+        
+        # /** \brief Set the maximum number of iterations.
+        # * \param[in] max_iterations maximum number of iterations
+        # inline void setMaxIterations (int max_iterations)
+        void setMaxIterations (int max_iterations)
+        
+        # /** \brief Get the maximum number of iterations, as set by the user. */
+        # inline int getMaxIterations ()
+        int getMaxIterations ()
+        
+        # /** \brief Set the desired probability of choosing at least one sample free from outliers.
+        # * \param[in] probability the desired probability of choosing at least one sample free from outliers
+        # * \note internally, the probability is set to 99% (0.99) by default.
+        # inline void setProbability (double probability)
+        void setProbability (double probability)
+        
+        # /** \brief Obtain the probability of choosing at least one sample free from outliers, as set by the user. */
+        # inline double getProbability ()
+        double getProbability ()
+        
+        # /** \brief Compute the actual model. Pure virtual. */
+        # virtual bool computeModel (int debug_verbosity_level = 0) = 0;
+        
+        # /** \brief Get a set of randomly selected indices.
+        # * \param[in] indices the input indices vector
+        # * \param[in] nr_samples the desired number of point indices to randomly select
+        # * \param[out] indices_subset the resultant output set of randomly selected indices
+        # inline void getRandomSamples (const boost::shared_ptr <std::vector<int> > &indices,  size_t nr_samples, std::set<int> &indices_subset)
+        # void getRandomSamples (shared_ptr [vector[int]] &indices,  size_t nr_samples, set[int] &indices_subset)
+        
+        # /** \brief Return the best model found so far. 
+        # * \param[out] model the resultant model
+        # inline void getModel (std::vector<int> &model)
+        void getModel (vector[int] &model)
+        
+        # /** \brief Return the best set of inliers found so far for this model. 
+        # * \param[out] inliers the resultant set of inliers
+        # inline void getInliers (std::vector<int> &inliers)
+        void getInliers (vector[int] &inliers)
+        
+        # /** \brief Return the model coefficients of the best model found so far. 
+        # * \param[out] model_coefficients the resultant model coefficients
+        # inline void  getModelCoefficients (Eigen::VectorXf &model_coefficients)
+
+
+ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t
+ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+
+# template<typename _Scalar, int NX=Eigen::Dynamic, int NY=Eigen::Dynamic>
+# struct Functor
+cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+    cdef cppclass Functor[_Scalar]:
+        Functor ()
+        # Functor (int m_data_points)
+        # typedef _Scalar Scalar;
+        # enum 
+        # {
+        #   InputsAtCompileTime = NX,
+        #   ValuesAtCompileTime = NY
+        # };
+        # typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,1> ValueType;
+        # typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> InputType;
+        # typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,InputsAtCompileTime> JacobianType;
+        # /** \brief Get the number of values. */ 
+        # int values () const
+
+
+###
+
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Project a point on a planar model given by a set of normalized coefficients
+#   * \param[in] p the input point to project
+#   * \param[in] model_coefficients the coefficients of the plane (a, b, c, d) that satisfy ax+by+cz+d=0
+#   * \param[out] q the resultant projected point
+#   */
+# template <typename Point> inline void
+# projectPoint (const Point &p, const Eigen::Vector4f &model_coefficients, Point &q)
+# {
+#   // Calculate the distance from the point to the plane
+#   Eigen::Vector4f pp (p.x, p.y, p.z, 1);
+#   // use normalized coefficients to calculate the scalar projection 
+#   float distance_to_plane = pp.dot(model_coefficients);
+#  
+#   //TODO: Why doesn't getVector4Map work here?
+#   //Eigen::Vector4f q_e = q.getVector4fMap ();
+#   //q_e = pp - model_coefficients * distance_to_plane;
+#   
+#   Eigen::Vector4f q_e = pp - distance_to_plane * model_coefficients;
+#   q.x = q_e[0];
+#   q.y = q_e[1];
+#   q.z = q_e[2];
+# }
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param a the normalized <i>a</i> coefficient of a plane
+#   * \param b the normalized <i>b</i> coefficient of a plane
+#   * \param c the normalized <i>c</i> coefficient of a plane
+#   * \param d the normalized <i>d</i> coefficient of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistanceSigned (const Point &p, double a, double b, double c, double d)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param plane_coefficients the normalized coefficients (a, b, c, d) of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistanceSigned (const Point &p, const Eigen::Vector4f &plane_coefficients)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param a the normalized <i>a</i> coefficient of a plane
+#   * \param b the normalized <i>b</i> coefficient of a plane
+#   * \param c the normalized <i>c</i> coefficient of a plane
+#   * \param d the normalized <i>d</i> coefficient of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistance (const Point &p, double a, double b, double c, double d)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param plane_coefficients the normalized coefficients (a, b, c, d) of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistance (const Point &p, const Eigen::Vector4f &plane_coefficients)
+###
+
+# sac_model_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelPlane defines a model for 3D plane segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelPlane : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelPlane[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelPlane()
+        SampleConsensusModelPlane(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # public:
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelPlane (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        
+        # /** \brief Check whether the given index samples can form a valid plane model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The plane coefficients are:
+        # * a, b, c, d (ax+by+cz+d=0)
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the plane coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the plane model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the plane model.
+        # * \param[in] inliers the data inliers that we want to project on the plane model
+        # * \param[in] model_coefficients the *normalized* coefficients of a plane model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given plane model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the plane model
+        # * \param[in] model_coefficients the plane model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PLANE); }
+
+
+ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_sphere.h
+# namespace pcl
+# /** \brief SampleConsensusModelSphere defines a model for 3D sphere segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b center.x : the X coordinate of the sphere's center
+#   *   - \b center.y : the Y coordinate of the sphere's center
+#   *   - \b center.z : the Z coordinate of the sphere's center
+#   *   - \b radius   : the sphere's radius
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelSphere : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_sphere.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelSphere[PointT](SampleConsensusModel[PointT]):
+        # SampleConsensusModelSphere()
+        SampleConsensusModelSphere(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # public:
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelSphere> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelSphere (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud), tmp_inliers_ ()
+        # 
+        # /** \brief Constructor for base SampleConsensusModelSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelSphere (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModel<PointT> (cloud, indices), tmp_inliers_ ()
+        # 
+        # /** \brief Copy constructor.
+        # * \param[in] source the model to copy into this
+        # */
+        # SampleConsensusModelSphere (const SampleConsensusModelSphere &source) :
+        # SampleConsensusModel<PointT> (), tmp_inliers_ () 
+        # 
+        # /** \brief Copy constructor.
+        # * \param[in] source the model to copy into this
+        # */
+        # inline SampleConsensusModelSphere& operator = (const SampleConsensusModelSphere &source)
+        # 
+        # /** \brief Check whether the given index samples can form a valid sphere model, compute the model 
+        # * coefficients from these samples and store them internally in model_coefficients. 
+        # * The sphere coefficients are: x, y, z, R.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given sphere model.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the sphere coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the sphere model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the sphere model.
+        # * \param[in] inliers the data inliers that we want to project on the sphere model
+        # * \param[in] model_coefficients the coefficients of a sphere model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # * \todo implement this.
+        # */
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given sphere model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the sphere model
+        # * \param[in] model_coefficients the sphere model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_SPHERE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_SPHERE); }
+
+
+ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t
+###
+
+### Inheritance class ###
+
+# lmeds.h
+# namespace pcl
+# template <typename PointT>
+# class LeastMedianSquares : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/lmeds.h" namespace "pcl":
+    cdef cppclass LeastMedianSquares[T](SampleConsensus[T]):
+        # LeastMedianSquares ()
+        LeastMedianSquares (shared_ptr[SampleConsensusModel[T]] model)
+        # LeastMedianSquares (const SampleConsensusModelPtr &model)
+        # LeastMedianSquares (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        #   * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        #   */
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level = 0)
+
+
+###
+
+# mlesac.h
+# namespace pcl
+# template <typename PointT>
+# class MaximumLikelihoodSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/mlesac.h" namespace "pcl":
+    cdef cppclass MaximumLikelihoodSampleConsensus[T](SampleConsensus[T]):
+        MaximumLikelihoodSampleConsensus ()
+        MaximumLikelihoodSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # \brief MLESAC (Maximum Likelihood Estimator SAmple Consensus) main constructor
+        # \param[in] model a Sample Consensus model
+        # MaximumLikelihoodSampleConsensus (const SampleConsensusModelPtr &model)
+        # MaximumLikelihoodSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr; 
+        # public:
+        # \brief Compute the actual model and find the inliers
+        # \param[in] debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        
+        # /** \brief Set the number of EM iterations.
+        # * \param[in] iterations the number of EM iterations
+        # inline void setEMIterations (int iterations)
+        
+        # /** \brief Get the number of EM iterations. */
+        # inline int getEMIterations () const { return (iterations_EM_); }
+
+
+###
+
+# msac.h
+# namespace pcl
+#   template <typename PointT>
+#   class MEstimatorSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/msac.h" namespace "pcl":
+    cdef cppclass MEstimatorSampleConsensus[T](SampleConsensus[T]):
+        MEstimatorSampleConsensus ()
+        MEstimatorSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # MEstimatorSampleConsensus (const SampleConsensusModelPtr &model)
+        # MEstimatorSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # \brief Compute the actual model and find the inliers
+        # \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+
+
+###
+
+# prosac.h
+# namespace pcl
+# template<typename PointT>
+# class ProgressiveSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/prosac.h" namespace "pcl":
+    cdef cppclass ProgressiveSampleConsensus[T](SampleConsensus[T]):
+        ProgressiveSampleConsensus ()
+        # ProgressiveSampleConsensus (const SampleConsensusModelPtr &model) 
+        # ProgressiveSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level)
+
+
+###
+
+# ransac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/ransac.h" namespace "pcl":
+    cdef cppclass RandomSampleConsensus[T](SampleConsensus[T]):
+        # RandomSampleConsensus ()
+        RandomSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        
+        # RandomSampleConsensus (shared_ptr[SampleConsensus[T]] model)
+        # RandomSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+
+
+ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t
+ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# rmsac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomizedMEstimatorSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/rmsac.h" namespace "pcl":
+    cdef cppclass RandomizedMEstimatorSampleConsensus[T](SampleConsensus[T]):
+        RandomizedMEstimatorSampleConsensus ()
+        # RandomizedMEstimatorSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomizedMEstimatorSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        RandomizedMEstimatorSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # */
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+        
+        # /** \brief Set the percentage of points to pre-test.
+        # * \param nr_pretest percentage of points to pre-test
+        # */
+        # inline void setFractionNrPretest (double nr_pretest)
+        void setFractionNrPretest (double nr_pretest)
+        
+        # /** \brief Get the percentage of points to pre-test. */
+        # inline double getFractionNrPretest ()
+        double getFractionNrPretest ()
+
+
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# rransac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomizedRandomSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+    cdef cppclass RandomizedRandomSampleConsensus[T](SampleConsensus[T]):
+        RandomizedRandomSampleConsensus ()
+        RandomizedRandomSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # RandomizedRandomSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomizedRandomSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief RRANSAC (RAndom SAmple Consensus) main constructor
+        # * \param model a Sample Consensus model
+        # * \param threshold distance to model threshold
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # */
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level)
+        
+        # \brief Set the percentage of points to pre-test.
+        # \param nr_pretest percentage of points to pre-test
+        # inline void setFractionNrPretest (double nr_pretest)
+        void setFractionNrPretest (double nr_pretest)
+        
+        # /** \brief Get the percentage of points to pre-test. */
+        # inline double getFractionNrPretest ()
+        double getFractionNrPretest ()
+
+
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_circle.h
+# namespace pcl
+# template <typename PointT>
+# class SampleConsensusModelCircle2D : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_circle.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelCircle2D[T](SampleConsensusModel[T]):
+        SampleConsensusModelCircle2D ()
+        # SampleConsensusModelCircle2D (const PointCloudConstPtr &cloud)
+        # SampleConsensusModelCircle2D (const PointCloudConstPtr &cloud, const std::vector<int> &indices)
+        # SampleConsensusModelCircle2D (const SampleConsensusModelCircle2D &source) :
+        # inline SampleConsensusModelCircle2D& operator = (const SampleConsensusModelCircle2D &source)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCircle2D> Ptr;
+        # /** \brief Check whether the given index samples can form a valid 2D circle model, compute the model coefficients
+        # * from these samples and store them in model_coefficients. The circle coefficients are: x, y, R.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # /** \brief Compute all distances from the cloud data to a given 2D circle model.
+        # * \param[in] model_coefficients the coefficients of a 2D circle model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # /** \brief Compute all distances from the cloud data to a given 2D circle model.
+        # * \param[in] model_coefficients the coefficients of a 2D circle model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold, 
+        #                     std::vector<int> &inliers);
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                    const double threshold);
+        # /** \brief Recompute the 2d circle coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the 2d circle model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # /** \brief Create a new point cloud with inliers projected onto the 2d circle model.
+        # * \param[in] inliers the data inliers that we want to project on the 2d circle model
+        # * \param[in] model_coefficients the coefficients of a 2d circle model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # /** \brief Verify whether a subset of indices verifies the given 2d circle model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the 2d circle model
+        # * \param[in] model_coefficients the 2d circle model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # /** \brief Return an unique id for this model (SACMODEL_CIRCLE2D). */
+        # inline pcl::SacModel getModelType () const
+
+
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t
+###
+
+# namespace pcl
+# struct OptimizationFunctor : pcl::Functor<float>
+#         OptimizationFunctor (int m_data_points, pcl::SampleConsensusModelCircle2D<PointT> *model) : 
+# 
+#         /** Cost function to be minimized
+#           * \param[in] x the variables array
+#           * \param[out] fvec the resultant functions evaluations
+#           * \return 0
+#           */
+#         int operator() (const Eigen::VectorXf &x, Eigen::VectorXf &fvec) const
+#         pcl::SampleConsensusModelCircle2D<PointT> *model_;
+###
+
+# sac_model_cone.h
+# namespace pcl
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelCone : public SampleConsensusModel<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_cone.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelCone[T, NT](SampleConsensusModel[T])(SampleConsensusModelFromNormals[T, NT]):
+    cdef cppclass SampleConsensusModelCone[T, NT]:
+        SampleConsensusModelCone ()
+        # Nothing
+        # SampleConsensusModelCone ()
+        # Use
+        # SampleConsensusModelCone (const PointCloudConstPtr &cloud)
+        # SampleConsensusModelCone (const PointCloudConstPtr &cloud, const std::vector<int> &indices)
+        # SampleConsensusModelCone (const SampleConsensusModelCone &source)
+        # inline SampleConsensusModelCone& operator = (const SampleConsensusModelCone &source)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCone> Ptr;
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the cone's axis and the given axis.
+        # inline void setEpsAngle (double ea)
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () const
+        # /** \brief Set the axis along which we need to search for a cone direction.
+        # * \param[in] ax the axis along which we need to search for a cone direction
+        # inline void setAxis (const Eigen::Vector3f &ax)
+        # /** \brief Get the axis along which we need to search for a cone direction. */
+        # inline Eigen::Vector3f getAxis () const
+        # /** \brief Set the minimum and maximum allowable opening angle for a cone model
+        # * given from a user.
+        # * \param[in] min_angle the minimum allwoable opening angle of a cone model
+        # * \param[in] max_angle the maximum allwoable opening angle of a cone model
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        # /** \brief Get the opening angle which we need minumum to validate a cone model.
+        # * \param[out] min_angle the minimum allwoable opening angle of a cone model
+        # * \param[out] max_angle the maximum allwoable opening angle of a cone model
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle) const
+        # /** \brief Check whether the given index samples can form a valid cone model, compute the model coefficients
+        # * from these samples and store them in model_coefficients. The cone coefficients are: apex,
+        # * axis_direction, opening_angle.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # /** \brief Compute all distances from the cloud data to a given cone model.
+        # * \param[in] model_coefficients the coefficients of a cone model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients,  std::vector<double> &distances);
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a cone model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold, std::vector<int> &inliers);
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # /** \brief Recompute the cone coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the cone model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # /** \brief Create a new point cloud with inliers projected onto the cone model.
+        # * \param[in] inliers the data inliers that we want to project on the cone model
+        # * \param[in] model_coefficients the coefficients of a cone model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, bool copy_data_fields = true);
+        # /** \brief Verify whether a subset of indices verifies the given cone model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the cone model
+        # * \param[in] model_coefficients the cone model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, const double threshold);
+        # /** \brief Return an unique id for this model (SACMODEL_CONE). */
+        # inline pcl::SacModel getModelType () const
+        # protected:
+        # /** \brief Get the distance from a point to a line (represented by a point and a direction)
+        # * \param[in] pt a point
+        # * \param[in] model_coefficients the line coefficients (a point on the line, line direction)
+        # double pointToAxisDistance (const Eigen::Vector4f &pt, const Eigen::VectorXf &model_coefficients);
+        # /** \brief Get a string representation of the name of this class. */
+        # std::string getName () const { return ("SampleConsensusModelCone"); }
+        # protected:
+        # /** \brief Check whether a model is valid given the user constraints.
+        # * \param[in] model_coefficients the set of model coefficients
+        # bool isModelValid (const Eigen::VectorXf &model_coefficients);
+        # /** \brief Check if a sample of indices results in a good sample of points
+        # * indices. Pure virtual.
+        # * \param[in] samples the resultant index samples
+        # bool isSampleGood (const std::vector<int> &samples) const;
+
+
+ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t
+###
+
+# namespace pcl
+# /** \brief Functor for the optimization function */
+# struct OptimizationFunctor : pcl::Functor<float>
+# cdef extern from "pcl/sample_consensus/sac_model_cone.h" namespace "pcl":
+#     cdef cppclass OptimizationFunctor(Functor[float]):
+#         OptimizationFunctor (int m_data_points, pcl::SampleConsensusModelCone<PointT, PointNT> *model) : 
+#         int operator() (const Eigen::VectorXf &x, Eigen::VectorXf &fvec) const
+#         pcl::SampleConsensusModelCone<PointT, PointNT> *model_;
+###
+
+
+# sac_model_cylinder.h
+# namespace pcl
+# \brief @b SampleConsensusModelCylinder defines a model for 3D cylinder segmentation.
+# The model coefficients are defined as:
+# \b point_on_axis.x  : the X coordinate of a point located on the cylinder axis
+# \b point_on_axis.y  : the Y coordinate of a point located on the cylinder axis
+# \b point_on_axis.z  : the Z coordinate of a point located on the cylinder axis
+# \b axis_direction.x : the X coordinate of the cylinder's axis direction
+# \b axis_direction.y : the Y coordinate of the cylinder's axis direction
+# \b axis_direction.z : the Z coordinate of the cylinder's axis direction
+# \b radius           : the cylinder's radius
+# \author Radu Bogdan Rusu
+# \ingroup sample_consensus
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelCylinder : public SampleConsensusModel<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+# Multi Inheritance NG
+# cdef cppclass SampleConsensusModelCylinder[PointT](SampleConsensusModel[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+cdef extern from "pcl/sample_consensus/sac_model_cylinder.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelCylinder[PointT, PointNT]:
+        SampleConsensusModelCylinder()
+        SampleConsensusModelCylinder(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCylinder> Ptr;
+        # 
+        # \brief Constructor for base SampleConsensusModelCylinder.
+        # \param[in] cloud the input point cloud dataset
+        # SampleConsensusModelCylinder (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Constructor for base SampleConsensusModelCylinder.
+        # \param[in] cloud the input point cloud dataset
+        # \param[in] indices a vector of point indices to be used from \a cloud
+        # SampleConsensusModelCylinder (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModel<PointT> (cloud, indices), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Copy constructor.
+        # \param[in] source the model to copy into this
+        # SampleConsensusModelCylinder (const SampleConsensusModelCylinder &source) :
+        # SampleConsensusModel<PointT> (),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Copy constructor.
+        # \param[in] source the model to copy into this
+        # inline SampleConsensusModelCylinder& operator = (const SampleConsensusModelCylinder &source)
+        # 
+        # \brief Set the angle epsilon (delta) threshold.
+        # \param[in] ea the maximum allowed difference between the cyilinder axis and the given axis.
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # \brief Get the angle epsilon (delta) threshold.
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # \brief Set the axis along which we need to search for a cylinder direction.
+        # \param[in] ax the axis along which we need to search for a cylinder direction
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # \brief Get the axis along which we need to search for a cylinder direction.
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # \brief Check whether the given index samples can form a valid cylinder model, compute the model coefficients
+        #  from these samples and store them in model_coefficients. The cylinder coefficients are: point_on_axis,
+        #  axis_direction, cylinder_radius_R
+        # \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # \brief Compute all distances from the cloud data to a given cylinder model.
+        # \param[in] model_coefficients the coefficients of a cylinder model that we need to compute distances to
+        # \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # \brief Select all the points which respect the given model coefficients as inliers.
+        # \param[in] model_coefficients the coefficients of a cylinder model that we need to compute distances to
+        # \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # \brief Count all the points which respect the given model coefficients as inliers. 
+        # \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # \brief Recompute the cylinder coefficients using the given inlier set and return them to the user.
+        #  @note: these are the coefficients of the cylinder model after refinement (eg. after SVD)
+        # \param[in] inliers the data inliers found as supporting the model
+        # \param[in] model_coefficients the initial guess for the optimization
+        # \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # \brief Create a new point cloud with inliers projected onto the cylinder model.
+        # \param[in] inliers the data inliers that we want to project on the cylinder model
+        # \param[in] model_coefficients the coefficients of a cylinder model
+        # \param[out] projected_points the resultant projected points
+        # \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients,  PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # \brief Verify whether a subset of indices verifies the given cylinder model coefficients.
+        # \param[in] indices the data indices that need to be tested against the cylinder model
+        # \param[in] model_coefficients the cylinder model coefficients
+        # \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_CYLINDER). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_CYLINDER); }
+
+
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_line.h
+# namespace pcl
+# /** \brief SampleConsensusModelLine defines a model for 3D line segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   *
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelLine : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_line.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelLine[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelLine()
+        SampleConsensusModelLine(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelLine> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelLine (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelLine (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        # 
+        # /** \brief Check whether the given index samples can form a valid line model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The line coefficients are represented by a
+        # * point and a line direction
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given line model.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the line coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the line model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the line model.
+        # * \param[in] inliers the data inliers that we want to project on the line model
+        # * \param[in] model_coefficients the *normalized* coefficients of a line model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given line model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the line model
+        # * \param[in] model_coefficients the line model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_LINE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_LINE); }
+
+
+ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_parallel_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelNormalParallelPlane defines a model for 3D
+#   * plane segmentation using additional surface normal constraints. Basically
+#   * this means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the plane's normal and the inlier points normals. In addition,
+#   * the plane normal must lie parallel to an user-specified axis.
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * To set the influence of the surface normals in the inlier estimation
+#   * process, set the normal weight (0.0-1.0), e.g.:
+#   * \code
+#   * SampleConsensusModelNormalPlane<pcl::PointXYZ, pcl::Normal> sac_model;
+#   * ...
+#   * sac_model.setNormalDistanceWeight (0.1);
+#   * ...
+#   * \endcode
+#   * In addition, the user can specify more constraints, such as:
+#   * 
+#   *   - an axis along which we need to search for a plane perpendicular to (\ref setAxis);
+#   *   - an angle \a tolerance threshold between the plane's normal and the above given axis (\ref setEpsAngle);
+#   *   - a distance we expect the plane to be from the origin (\ref setDistanceFromOrigin);
+#   *   - a distance \a tolerance as the maximum allowed deviation from the above given distance from the origin (\ref setEpsDist).
+#   *
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu B. Rusu and Jared Glover and Nico Blodow
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalParallelPlane : public SampleConsensusModelPlane<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_parallel_plane.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalParallelPlane[PointT](SampleConsensusModelPlane[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalParallelPlane[PointT, PointNT]:
+        SampleConsensusModelNormalParallelPlane()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalParallelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalParallelPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud),
+        # axis_ (Eigen::Vector4f::Zero ()),
+        # distance_from_origin_ (0),
+        # eps_angle_ (-1.0), cos_angle_ (-1.0), eps_dist_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalParallelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector4f::Zero ()),
+        # distance_from_origin_ (0),
+        # eps_angle_ (-1.0), cos_angle_ (-1.0), eps_dist_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_.head<3> () = ax; axis_.normalize ();}
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis () { return (axis_.head<3> ()); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed deviation from 90 degrees between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; cos_angle_ = fabs (cos (ea));}
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Set the distance we expect the plane to be from the origin
+        # * \param[in] d distance from the template plane to the origin
+        # */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        # 
+        # /** \brief Get the distance of the plane from the origin. */
+        # inline double getDistanceFromOrigin () { return (distance_from_origin_); }
+        # 
+        # /** \brief Set the distance epsilon (delta) threshold.
+        # * \param[in] delta the maximum allowed deviation from the template distance from the origin
+        # */
+        # inline void setEpsDist (const double delta) { eps_dist_ = delta; }
+        # 
+        # /** \brief Get the distance epsilon (delta) threshold. */
+        # inline double getEpsDist () { return (eps_dist_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # *
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_PARALLEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_PARALLEL_PLANE); }
+
+
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelNormalPlane defines a model for 3D plane
+#   * segmentation using additional surface normal constraints. Basically this
+#   * means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the plane's normal and the inlier points normals.
+#   *
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * To set the influence of the surface normals in the inlier estimation
+#   * process, set the normal weight (0.0-1.0), e.g.:
+#   * \code
+#   * SampleConsensusModelNormalPlane<pcl::PointXYZ, pcl::Normal> sac_model;
+#   * ...
+#   * sac_model.setNormalDistanceWeight (0.1);
+#   * ...
+#   * \endcode
+#   * \author Radu B. Rusu and Jared Glover
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalPlane : public SampleConsensusModelPlane<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_plane.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalPlane[PointT, PointNT](SampleConsensusModelPlane[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalPlane[PointT, PointNT]:
+        SampleConsensusModelNormalPlane()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalPlane (const PointCloudConstPtr &cloud) : SampleConsensusModelPlane<PointT> (cloud)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModelPlane<PointT> (cloud, indices)
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_PLANE); }
+
+
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_sphere.h
+# namespace pcl
+# /** \brief @b SampleConsensusModelNormalSphere defines a model for 3D sphere
+#   * segmentation using additional surface normal constraints. Basically this
+#   * means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the sphere's normal and the inlier points normals.
+#   * The model coefficients are defined as:
+#   * <ul>
+#   * <li><b>a</b> : the X coordinate of the plane's normal (normalized)
+#   * <li><b>b</b> : the Y coordinate of the plane's normal (normalized)
+#   * <li><b>c</b> : the Z coordinate of the plane's normal (normalized)
+#   * <li><b>d</b> : radius of the sphere
+#   * </ul>
+#   * \author Stefan Schrandt
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalSphere : public SampleConsensusModelSphere<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_sphere.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalSphere[PointT, PointNT](SampleConsensusModelSphere[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalSphere[PointT, PointNT]:
+        SampleConsensusModelNormalSphere()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalSphere> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalSphere (const PointCloudConstPtr &cloud) : SampleConsensusModelSphere<PointT> (cloud)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalSphere (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModelSphere<PointT> (cloud, indices)
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given sphere model.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_SPHERE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_SPHERE); }
+
+
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_parallel_line.h
+# namespace pcl
+# /** \brief SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular
+#   * constraints.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelParallelLine : public SampleConsensusModelLine<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_parallel_line.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelParallelLine[PointT](SampleConsensusModelLine[PointT]):
+    cdef cppclass SampleConsensusModelParallelLine[PointT]:
+        SampleConsensusModelParallelLine()
+        # public:
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelParallelLine> Ptr;
+        # /** \brief Constructor for base SampleConsensusModelParallelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelParallelLine (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelLine<PointT> (cloud),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelParallelLine (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelLine<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; axis_.normalize (); }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given line model.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PARALLEL_LINE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PARALLEL_LINE); }
+
+
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_parallel_plane.h
+# namespace pcl
+# /** \brief @b SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional
+#   * angular constraints. The plane must be parallel to a user-specified axis
+#   * (\ref setAxis) within an user-specified angle threshold (\ref setEpsAngle).
+#   * Code example for a plane model, parallel (within a 15 degrees tolerance) with the Z axis:
+#   * \code
+#   * SampleConsensusModelParallelPlane<pcl::PointXYZ> model (cloud);
+#   * model.setAxis (Eigen::Vector3f (0.0, 0.0, 1.0));
+#   * model.setEpsAngle (pcl::deg2rad (15));
+#   * \endcode
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu Bogdan Rusu, Nico Blodow
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelParallelPlane : public SampleConsensusModelPlane<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_parallel_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelParallelPlane[PointT](SampleConsensusModelPlane[PointT]):
+        SampleConsensusModelParallelLine()
+        # public:
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelParallelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelParallelPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0), sin_angle_ (-1.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelParallelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0), sin_angle_ (-1.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; sin_angle_ = fabs (sin (ea));}
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PARALLEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PARALLEL_PLANE); }
+
+
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_perpendicular_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional
+#   * angular constraints. The plane must be perpendicular to an user-specified axis (\ref setAxis), up to an user-specified angle threshold (\ref setEpsAngle).
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * Code example for a plane model, perpendicular (within a 15 degrees tolerance) with the Z axis:
+#   * \code
+#   * SampleConsensusModelPerpendicularPlane<pcl::PointXYZ> model (cloud);
+#   * model.setAxis (Eigen::Vector3f (0.0, 0.0, 1.0));
+#   * model.setEpsAngle (pcl::deg2rad (15));
+#   * \endcode
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelPerpendicularPlane : public SampleConsensusModelPlane<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_perpendicular_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelPerpendicularPlane[PointT](SampleConsensusModelPlane[PointT]):
+        SampleConsensusModelPerpendicularPlane()
+        # public:
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelPerpendicularPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPerpendicularPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelPerpendicularPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPerpendicularPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelPerpendicularPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PERPENDICULAR_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PERPENDICULAR_PLANE); }
+
+
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_registration.h
+# namespace pcl
+# /** \brief SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelRegistration : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_registration.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelRegistration[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelRegistration()
+        SampleConsensusModelRegistration(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelRegistration> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelRegistration.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelRegistration (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud),
+        # target_ (),
+        # indices_tgt_ (),
+        # correspondences_ (),
+        # sample_dist_thresh_ (0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelRegistration.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelRegistration (const PointCloudConstPtr &cloud, const std::vector<int> &indices) :
+        # SampleConsensusModel<PointT> (cloud, indices),
+        # target_ (),
+        # indices_tgt_ (),
+        # correspondences_ (),
+        # sample_dist_thresh_ (0)
+        # 
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # inline virtual void setInputCloud (const PointCloudConstPtr &cloud)
+        # 
+        # /** \brief Set the input point cloud target.
+        # * \param target the input point cloud target
+        # */
+        # inline void setInputTarget (const PointCloudConstPtr &target)
+        # 
+        # /** \brief Set the input point cloud target.
+        # * \param[in] target the input point cloud target
+        # * \param[in] indices_tgt a vector of point indices to be used from \a target
+        # */
+        # inline void setInputTarget (const PointCloudConstPtr &target, const std::vector<int> &indices_tgt)
+        # 
+        # /** \brief Compute a 4x4 rigid transformation matrix from the samples given
+        # * \param[in] samples the indices found as good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the transformed points to their correspondences
+        # * \param[in] model_coefficients the 4x4 transformation matrix
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the 4x4 transformation matrix
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the 4x4 transformation using the given inlier set
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed transformation
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # void projectPoints (const std::vector<int> &, const Eigen::VectorXf &, PointCloud &, bool = true)
+        # 
+        # bool doSamplesVerifyModel (const std::set<int> &, const Eigen::VectorXf &, const double)
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_REGISTRATION). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_REGISTRATION); }
+
+
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_stick.h
+# namespace pcl
+# /** \brief SampleConsensusModelStick defines a model for 3D stick segmentation. 
+#   * A stick is a line with an user given minimum/maximum width.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   *   - \b line_width       : the width of the line
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelStick : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_stick.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelStick[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelStick()
+        SampleConsensusModelStick(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelStick> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelStick.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelStick (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelStick.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelStick (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        # 
+        # /** \brief Check whether the given index samples can form a valid stick model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The stick coefficients are represented by a
+        # * point and a line direction
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given stick model.
+        # * \param[in] model_coefficients the coefficients of a stick model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a stick model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the stick coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the stick model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the stick model.
+        # * \param[in] inliers the data inliers that we want to project on the stick model
+        # * \param[in] model_coefficients the *normalized* coefficients of a stick model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given stick model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the plane model
+        # * \param[in] model_coefficients the plane model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_STACK). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_STICK); }
+
+
+ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# method_types.h
+cdef extern from "pcl/sample_consensus/method_types.h" namespace "pcl":
+    cdef enum:
+        SAC_RANSAC = 0
+        SAC_LMEDS = 1
+        SAC_MSAC = 2
+        SAC_RRANSAC = 3
+        SAC_RMSAC = 4
+        SAC_MLESAC = 5
+        SAC_PROSAC = 6
+###
+
+# model_types.h
+cdef extern from "pcl/sample_consensus/model_types.h" namespace "pcl":
+    cdef enum SacModel:
+        SACMODEL_PLANE
+        SACMODEL_LINE
+        SACMODEL_CIRCLE2D
+        SACMODEL_CIRCLE3D
+        SACMODEL_SPHERE
+        SACMODEL_CYLINDER
+        SACMODEL_CONE
+        SACMODEL_TORUS
+        SACMODEL_PARALLEL_LINE
+        SACMODEL_PERPENDICULAR_PLANE
+        SACMODEL_PARALLEL_LINES
+        SACMODEL_NORMAL_PLANE
+        SACMODEL_NORMAL_SPHERE        # Version 1.6
+        SACMODEL_REGISTRATION
+        SACMODEL_PARALLEL_PLANE
+        SACMODEL_NORMAL_PARALLEL_PLANE
+        SACMODEL_STICK
+###
+
+# cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+#     cdef cppclass Functor[_Scalar]:
+#         # enum 
+#         # {
+#         #   InputsAtCompileTime = NX,
+#         #   ValuesAtCompileTime = NY
+#         # };
+
+
+# // Define the number of samples in SacModel needs
+# typedef std::map<pcl::SacModel, unsigned int>::value_type SampleSizeModel;
+# const static SampleSizeModel sample_size_pairs[] = {SampleSizeModel (pcl::SACMODEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_LINE, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_CIRCLE2D, 3),
+#                                                     //SampleSizeModel (pcl::SACMODEL_CIRCLE3D, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_SPHERE, 4),
+#                                                     SampleSizeModel (pcl::SACMODEL_CYLINDER, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_CONE, 3),
+#                                                     //SampleSizeModel (pcl::SACMODEL_TORUS, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_PARALLEL_LINE, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_PERPENDICULAR_PLANE, 3),
+#                                                     //SampleSizeModel (pcl::PARALLEL_LINES, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_SPHERE, 4),
+#                                                     SampleSizeModel (pcl::SACMODEL_REGISTRATION, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_PARALLEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_PARALLEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_STICK, 2)};
+# 
+# namespace pcl
+# {
+#   const static std::map<pcl::SacModel, unsigned int> SAC_SAMPLE_SIZE (sample_size_pairs, sample_size_pairs + sizeof (sample_size_pairs) / sizeof (SampleSizeModel));
+# }
+###
+
+###############################################################################
+# Activation
+###############################################################################
+
+
+# extend 172
+# sac_model_registration_2d.h
diff --git a/pcl/pcl_sample_consensus_180.pxd b/pcl/pcl_sample_consensus_180.pxd
new file mode 100644
index 0000000..601262d
--- /dev/null
+++ b/pcl/pcl_sample_consensus_180.pxd
@@ -0,0 +1,2301 @@
+# -*- coding: utf-8 -*-
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# import
+cimport pcl_defs as cpp
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# sac_model.h
+# namespace pcl
+# template<class T> class ProgressiveSampleConsensus;
+
+# sac_model.h
+# namespace pcl
+# template <typename PointT>
+# class SampleConsensusModel
+cdef extern from "pcl/sample_consensus/sac_model.h" namespace "pcl":
+    cdef cppclass SampleConsensusModel[T]:
+        SampleConsensusModel()
+        # SampleConsensusModel (bool random = false) 
+        # SampleConsensusModel (const PointCloudConstPtr &cloud, bool random = false)
+        # SampleConsensusModel (const PointCloudConstPtr &cloud, const std::vector<int> &indices, bool random = false)
+        # public:
+        # typedef typename pcl::PointCloud<PointT> PointCloud;
+        # typedef typename pcl::PointCloud<PointT>::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointT>::Ptr PointCloudPtr;
+        # typedef typename pcl::search::Search<PointT>::Ptr SearchPtr;
+        # typedef boost::shared_ptr<SampleConsensusModel> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusModel> ConstPtr;
+        # public:
+        # /** \brief Get a set of random data samples and return them as point
+        # * indices. Pure virtual.  
+        # * \param[out] iterations the internal number of iterations used by SAC methods
+        # * \param[out] samples the resultant model samples
+        # */
+        # void getSamples (int &iterations, std::vector<int> &samples)
+        void getSamples (int &iterations, vector[int] &samples)
+        
+        # /** \brief Check whether the given index samples can form a valid model,
+        # * compute the model coefficients from these samples and store them
+        # * in model_coefficients. Pure virtual.
+        # * \param[in] samples the point indices found as possible good candidates
+        # * for creating a valid model 
+        # * \param[out] model_coefficients the computed model coefficients
+        # */
+        # virtual bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients) = 0;
+        
+        # /** \brief Recompute the model coefficients using the given inlier set
+        # * and return them to the user. Pure virtual.
+        # * @note: these are the coefficients of the model after refinement
+        # * (e.g., after a least-squares optimization)
+        # * \param[in] inliers the data inliers supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # virtual void optimizeModelCoefficients (const std::vector<int> &inliers,  const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients) = 0;
+        
+        # /** \brief Compute all distances from the cloud data to a given model. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to 
+        # * \param[out] distances the resultant estimated distances
+        # virtual void  getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances) = 0;
+        # /** \brief Select all the points which respect the given model
+        # * coefficients as inliers. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from 
+        # * the outliers
+        # * \param[out] inliers the resultant model inliers
+        # virtual void selectWithinDistance (const Eigen::VectorXf &model_coefficients,  const double threshold, std::vector<int> &inliers) = 0;
+        
+        # /** \brief Count all the points which respect the given model
+        # * coefficients as inliers. Pure virtual.
+        # * \param[in] model_coefficients the coefficients of a model that we need to
+        # * compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for
+        # * determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold) = 0;
+        
+        # /** \brief Create a new point cloud with inliers projected onto the model. Pure virtual.
+        # * \param[in] inliers the data inliers that we want to project on the model
+        # * \param[in] model_coefficients the coefficients of a model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true (default) if we want the \a
+        # * projected_points cloud to be an exact copy of the input dataset minus
+        # * the point projections on the plane model
+        # virtual void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients,
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true) = 0;
+        
+        # /** \brief Verify whether a subset of indices verifies a given set of
+        # * model coefficients. Pure virtual.
+        # * \param[in] indices the data indices that need to be tested against the model
+        # * \param[in] model_coefficients the set of model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for
+        # * determining the inliers from the outliers
+        # virtual bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold) = 0;
+        
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # inline virtual void setInputCloud (const PointCloudConstPtr &cloud)
+        
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # inline PointCloudConstPtr getInputCloud () const
+        
+        # /** \brief Provide a pointer to the vector of indices that represents the input data.
+        # * \param[in] indices a pointer to the vector of indices that represents the input data.
+        # inline void setIndices (const boost::shared_ptr <std::vector<int> > &indices) 
+        
+        # /** \brief Provide the vector of indices that represents the input data.
+        # * \param[out] indices the vector of indices that represents the input data.
+        # inline void setIndices (const std::vector<int> &indices) 
+        
+        # /** \brief Get a pointer to the vector of indices used. */
+        # inline boost::shared_ptr <std::vector<int> > getIndices () const
+        
+        # /** \brief Return an unique id for each type of model employed. */
+        # virtual SacModel getModelType () const = 0;
+        
+        # /** \brief Return the size of a sample from which a model is computed */
+        # inline unsigned int getSampleSize () const 
+        
+        # /** \brief Set the minimum and maximum allowable radius limits for the
+        # * model (applicable to models that estimate a radius)
+        # * \param[in] min_radius the minimum radius model
+        # * \param[in] max_radius the maximum radius model
+        # * \todo change this to set limits on the entire model
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        
+        # /** \brief Get the minimum and maximum allowable radius limits for the
+        # * model as set by the user.
+        # * \param[out] min_radius the resultant minimum radius model
+        # * \param[out] max_radius the resultant maximum radius model
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        
+        # /** \brief Set the maximum distance allowed when drawing random samples
+        # * \param[in] radius the maximum distance (L2 norm)
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        
+        # /** \brief Get maximum distance allowed when drawing random samples
+        # * \param[out] radius the maximum distance (L2 norm)
+        # inline void getSamplesMaxDist (double &radius)
+
+
+ctypedef SampleConsensusModel[cpp.PointXYZ] SampleConsensusModel_t
+ctypedef SampleConsensusModel[cpp.PointXYZI] SampleConsensusModel_PointXYZI_t
+ctypedef SampleConsensusModel[cpp.PointXYZRGB] SampleConsensusModel_PointXYZRGB_t
+ctypedef SampleConsensusModel[cpp.PointXYZRGBA] SampleConsensusModel_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelPtr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZ]] SampleConsensusModelConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZI]] SampleConsensusModel_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGB]] SampleConsensusModel_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModel[cpp.PointXYZRGBA]] SampleConsensusModel_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model.h
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelFromNormals
+cdef extern from "pcl/sample_consensus/sac_model.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelFromNormals[T, NT]:
+        SampleConsensusModelFromNormals ()
+        # public:
+        # typedef typename pcl::PointCloud<PointNT>::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudNPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelFromNormals> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensusModelFromNormals> ConstPtr;
+        # /** \brief Set the normal angular distance weight.
+        # * \param[in] w the relative weight (between 0 and 1) to give to the angular
+        # * distance (0 to pi/2) between point normals and the plane normal.
+        # * (The Euclidean distance will have weight 1-w.)
+        # */
+        # inline void setNormalDistanceWeight (const double w) 
+        void setNormalDistanceWeight (const double w) 
+        
+        # /** \brief Get the normal angular distance weight. */
+        # inline double getNormalDistanceWeight ()
+        double getNormalDistanceWeight ()
+        
+        # /** \brief Provide a pointer to the input dataset that contains the point
+        # * normals of the XYZ dataset.
+        # * \param[in] normals the const boost shared pointer to a PointCloud message
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) 
+        void setInputNormals (shared_ptr[cpp.PointCloud[NT]] normals) 
+        
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals ()
+        shared_ptr[cpp.PointCloud[NT]] getInputNormals () 
+
+
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal] SampleConsensusModelFromNormals_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal] SampleConsensusModelFromNormals_PointXYZI_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGB_t
+# ctypedef SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelFromNormals_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsPtr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelFromNormalsConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelFromNormals[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelFromNormals_PointXYZRGBA_ConstPtr_t
+###
+
+# sac.h
+# namespace pcl
+# template <typename T>
+# class SampleConsensus
+cdef extern from "pcl/sample_consensus/sac.h" namespace "pcl":
+    cdef cppclass SampleConsensus[T]:
+        # SampleConsensus (const SampleConsensusModelPtr &model, bool random = false)
+        # SampleConsensus (const SampleConsensusModelPtr &model, double threshold, bool random = false) : 
+        # \brief Constructor for base SAC.
+        # \param[in] model a Sample Consensus model
+        # \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
+        SampleConsensus (const SampleConsensusModelPtr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZI_Ptr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZRGB_Ptr_t &model)
+        SampleConsensus (const SampleConsensusModel_PointXYZRGBA_Ptr_t &model)
+        
+        # public:
+        # typedef boost::shared_ptr<SampleConsensus> Ptr;
+        # typedef boost::shared_ptr<const SampleConsensus> ConstPtr;
+        # \brief Set the distance to model threshold.
+        # \param[in] threshold distance to model threshold
+        # inline void setDistanceThreshold (double threshold)
+        void setDistanceThreshold (double threshold)
+        
+        # /** \brief Get the distance to model threshold, as set by the user. */
+        # inline double getDistanceThreshold ()
+        double getDistanceThreshold ()
+        
+        # /** \brief Set the maximum number of iterations.
+        # * \param[in] max_iterations maximum number of iterations
+        # inline void setMaxIterations (int max_iterations)
+        void setMaxIterations (int max_iterations)
+        
+        # /** \brief Get the maximum number of iterations, as set by the user. */
+        # inline int getMaxIterations ()
+        int getMaxIterations ()
+        
+        # /** \brief Set the desired probability of choosing at least one sample free from outliers.
+        # * \param[in] probability the desired probability of choosing at least one sample free from outliers
+        # * \note internally, the probability is set to 99% (0.99) by default.
+        # inline void setProbability (double probability)
+        void setProbability (double probability)
+        
+        # /** \brief Obtain the probability of choosing at least one sample free from outliers, as set by the user. */
+        # inline double getProbability ()
+        double getProbability ()
+        
+        # /** \brief Compute the actual model. Pure virtual. */
+        # virtual bool computeModel (int debug_verbosity_level = 0) = 0;
+        
+        # /** \brief Get a set of randomly selected indices.
+        # * \param[in] indices the input indices vector
+        # * \param[in] nr_samples the desired number of point indices to randomly select
+        # * \param[out] indices_subset the resultant output set of randomly selected indices
+        # inline void getRandomSamples (const boost::shared_ptr <std::vector<int> > &indices,  size_t nr_samples, std::set<int> &indices_subset)
+        # void getRandomSamples (shared_ptr [vector[int]] &indices,  size_t nr_samples, set[int] &indices_subset)
+        
+        # /** \brief Return the best model found so far. 
+        # * \param[out] model the resultant model
+        # inline void getModel (std::vector<int> &model)
+        void getModel (vector[int] &model)
+        
+        # /** \brief Return the best set of inliers found so far for this model. 
+        # * \param[out] inliers the resultant set of inliers
+        # inline void getInliers (std::vector<int> &inliers)
+        void getInliers (vector[int] &inliers)
+        
+        # /** \brief Return the model coefficients of the best model found so far. 
+        # * \param[out] model_coefficients the resultant model coefficients
+        # inline void  getModelCoefficients (Eigen::VectorXf &model_coefficients)
+
+
+ctypedef SampleConsensus[cpp.PointXYZ] SampleConsensus_t
+ctypedef SampleConsensus[cpp.PointXYZI] SampleConsensus_PointXYZI_t
+ctypedef SampleConsensus[cpp.PointXYZRGB] SampleConsensus_PointXYZRGB_t
+ctypedef SampleConsensus[cpp.PointXYZRGBA] SampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZ]] SampleConsensusPtr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZ]] SampleConsensusConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZI]] SampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGB]] SampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensus[cpp.PointXYZRGBA]] SampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+
+# template<typename _Scalar, int NX=Eigen::Dynamic, int NY=Eigen::Dynamic>
+# struct Functor
+cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+    cdef cppclass Functor[_Scalar]:
+        Functor ()
+        # Functor (int m_data_points)
+        # typedef _Scalar Scalar;
+        # enum 
+        # {
+        #   InputsAtCompileTime = NX,
+        #   ValuesAtCompileTime = NY
+        # };
+        # typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,1> ValueType;
+        # typedef Eigen::Matrix<Scalar,InputsAtCompileTime,1> InputType;
+        # typedef Eigen::Matrix<Scalar,ValuesAtCompileTime,InputsAtCompileTime> JacobianType;
+        # /** \brief Get the number of values. */ 
+        # int values () const
+
+
+###
+
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Project a point on a planar model given by a set of normalized coefficients
+#   * \param[in] p the input point to project
+#   * \param[in] model_coefficients the coefficients of the plane (a, b, c, d) that satisfy ax+by+cz+d=0
+#   * \param[out] q the resultant projected point
+#   */
+# template <typename Point> inline void
+# projectPoint (const Point &p, const Eigen::Vector4f &model_coefficients, Point &q)
+# {
+#   // Calculate the distance from the point to the plane
+#   Eigen::Vector4f pp (p.x, p.y, p.z, 1);
+#   // use normalized coefficients to calculate the scalar projection 
+#   float distance_to_plane = pp.dot(model_coefficients);
+#  
+#   //TODO: Why doesn't getVector4Map work here?
+#   //Eigen::Vector4f q_e = q.getVector4fMap ();
+#   //q_e = pp - model_coefficients * distance_to_plane;
+#   
+#   Eigen::Vector4f q_e = pp - distance_to_plane * model_coefficients;
+#   q.x = q_e[0];
+#   q.y = q_e[1];
+#   q.z = q_e[2];
+# }
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param a the normalized <i>a</i> coefficient of a plane
+#   * \param b the normalized <i>b</i> coefficient of a plane
+#   * \param c the normalized <i>c</i> coefficient of a plane
+#   * \param d the normalized <i>d</i> coefficient of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistanceSigned (const Point &p, double a, double b, double c, double d)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (signed) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param plane_coefficients the normalized coefficients (a, b, c, d) of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistanceSigned (const Point &p, const Eigen::Vector4f &plane_coefficients)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param a the normalized <i>a</i> coefficient of a plane
+#   * \param b the normalized <i>b</i> coefficient of a plane
+#   * \param c the normalized <i>c</i> coefficient of a plane
+#   * \param d the normalized <i>d</i> coefficient of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistance (const Point &p, double a, double b, double c, double d)
+# 
+# sac_model_plane.h
+# namespace pcl
+# /** \brief Get the distance from a point to a plane (unsigned) defined by ax+by+cz+d=0
+#   * \param p a point
+#   * \param plane_coefficients the normalized coefficients (a, b, c, d) of a plane
+#   * \ingroup sample_consensus
+#   */
+# template <typename Point> inline double
+# pointToPlaneDistance (const Point &p, const Eigen::Vector4f &plane_coefficients)
+###
+
+# sac_model_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelPlane defines a model for 3D plane segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelPlane : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelPlane[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelPlane()
+        SampleConsensusModelPlane(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # public:
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelPlane (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        
+        # /** \brief Check whether the given index samples can form a valid plane model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The plane coefficients are:
+        # * a, b, c, d (ax+by+cz+d=0)
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the plane coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the plane model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the plane model.
+        # * \param[in] inliers the data inliers that we want to project on the plane model
+        # * \param[in] model_coefficients the *normalized* coefficients of a plane model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given plane model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the plane model
+        # * \param[in] model_coefficients the plane model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PLANE); }
+
+
+ctypedef SampleConsensusModelPlane[cpp.PointXYZ] SampleConsensusModelPlane_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZI] SampleConsensusModelPlane_PointXYZI_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZRGB] SampleConsensusModelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelPlane[cpp.PointXYZRGBA] SampleConsensusModelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZ]] SampleConsensusModelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZI]] SampleConsensusModelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGB]] SampleConsensusModelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPlane[cpp.PointXYZRGBA]] SampleConsensusModelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_sphere.h
+# namespace pcl
+# /** \brief SampleConsensusModelSphere defines a model for 3D sphere segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b center.x : the X coordinate of the sphere's center
+#   *   - \b center.y : the Y coordinate of the sphere's center
+#   *   - \b center.z : the Z coordinate of the sphere's center
+#   *   - \b radius   : the sphere's radius
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelSphere : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_sphere.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelSphere[PointT](SampleConsensusModel[PointT]):
+        # SampleConsensusModelSphere()
+        SampleConsensusModelSphere(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # public:
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelSphere> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelSphere (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud), tmp_inliers_ ()
+        # 
+        # /** \brief Constructor for base SampleConsensusModelSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelSphere (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModel<PointT> (cloud, indices), tmp_inliers_ ()
+        # 
+        # /** \brief Copy constructor.
+        # * \param[in] source the model to copy into this
+        # */
+        # SampleConsensusModelSphere (const SampleConsensusModelSphere &source) :
+        # SampleConsensusModel<PointT> (), tmp_inliers_ () 
+        # 
+        # /** \brief Copy constructor.
+        # * \param[in] source the model to copy into this
+        # */
+        # inline SampleConsensusModelSphere& operator = (const SampleConsensusModelSphere &source)
+        # 
+        # /** \brief Check whether the given index samples can form a valid sphere model, compute the model 
+        # * coefficients from these samples and store them internally in model_coefficients. 
+        # * The sphere coefficients are: x, y, z, R.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given sphere model.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the sphere coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the sphere model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the sphere model.
+        # * \param[in] inliers the data inliers that we want to project on the sphere model
+        # * \param[in] model_coefficients the coefficients of a sphere model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # * \todo implement this.
+        # */
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given sphere model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the sphere model
+        # * \param[in] model_coefficients the sphere model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_SPHERE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_SPHERE); }
+
+
+ctypedef SampleConsensusModelSphere[cpp.PointXYZ] SampleConsensusModelSphere_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZI] SampleConsensusModelSphere_PointXYZI_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZRGB] SampleConsensusModelSphere_PointXYZRGB_t
+ctypedef SampleConsensusModelSphere[cpp.PointXYZRGBA] SampleConsensusModelSphere_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSpherePtr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZ]] SampleConsensusModelSphereConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZI]] SampleConsensusModelSphere_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGB]] SampleConsensusModelSphere_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelSphere[cpp.PointXYZRGBA]] SampleConsensusModelSphere_PointXYZRGBA_ConstPtr_t
+###
+
+### Inheritance class ###
+
+# lmeds.h
+# namespace pcl
+# template <typename PointT>
+# class LeastMedianSquares : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/lmeds.h" namespace "pcl":
+    cdef cppclass LeastMedianSquares[T](SampleConsensus[T]):
+        # LeastMedianSquares ()
+        LeastMedianSquares (shared_ptr[SampleConsensusModel[T]] model)
+        # LeastMedianSquares (const SampleConsensusModelPtr &model)
+        # LeastMedianSquares (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        #   * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        #   */
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level = 0)
+
+
+###
+
+# mlesac.h
+# namespace pcl
+# template <typename PointT>
+# class MaximumLikelihoodSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/mlesac.h" namespace "pcl":
+    cdef cppclass MaximumLikelihoodSampleConsensus[T](SampleConsensus[T]):
+        MaximumLikelihoodSampleConsensus ()
+        MaximumLikelihoodSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # \brief MLESAC (Maximum Likelihood Estimator SAmple Consensus) main constructor
+        # \param[in] model a Sample Consensus model
+        # MaximumLikelihoodSampleConsensus (const SampleConsensusModelPtr &model)
+        # MaximumLikelihoodSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr; 
+        # public:
+        # \brief Compute the actual model and find the inliers
+        # \param[in] debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        
+        # /** \brief Set the number of EM iterations.
+        # * \param[in] iterations the number of EM iterations
+        # inline void setEMIterations (int iterations)
+        
+        # /** \brief Get the number of EM iterations. */
+        # inline int getEMIterations () const { return (iterations_EM_); }
+
+
+###
+
+# msac.h
+# namespace pcl
+#   template <typename PointT>
+#   class MEstimatorSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/msac.h" namespace "pcl":
+    cdef cppclass MEstimatorSampleConsensus[T](SampleConsensus[T]):
+        MEstimatorSampleConsensus ()
+        MEstimatorSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # MEstimatorSampleConsensus (const SampleConsensusModelPtr &model)
+        # MEstimatorSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # \brief Compute the actual model and find the inliers
+        # \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+
+
+###
+
+# prosac.h
+# namespace pcl
+# template<typename PointT>
+# class ProgressiveSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/prosac.h" namespace "pcl":
+    cdef cppclass ProgressiveSampleConsensus[T](SampleConsensus[T]):
+        ProgressiveSampleConsensus ()
+        # ProgressiveSampleConsensus (const SampleConsensusModelPtr &model) 
+        # ProgressiveSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level)
+
+
+###
+
+# ransac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/ransac.h" namespace "pcl":
+    cdef cppclass RandomSampleConsensus[T](SampleConsensus[T]):
+        # RandomSampleConsensus ()
+        RandomSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        
+        # RandomSampleConsensus (shared_ptr[SampleConsensus[T]] model)
+        # RandomSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+
+
+ctypedef RandomSampleConsensus[cpp.PointXYZ] RandomSampleConsensus_t
+ctypedef RandomSampleConsensus[cpp.PointXYZI] RandomSampleConsensus_PointXYZI_t
+ctypedef RandomSampleConsensus[cpp.PointXYZRGB] RandomSampleConsensus_PointXYZRGB_t
+ctypedef RandomSampleConsensus[cpp.PointXYZRGBA] RandomSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusPtr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZ]] RandomSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZI]] RandomSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGB]] RandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomSampleConsensus[cpp.PointXYZRGBA]] RandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# rmsac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomizedMEstimatorSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/rmsac.h" namespace "pcl":
+    cdef cppclass RandomizedMEstimatorSampleConsensus[T](SampleConsensus[T]):
+        RandomizedMEstimatorSampleConsensus ()
+        # RandomizedMEstimatorSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomizedMEstimatorSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        RandomizedMEstimatorSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # */
+        # bool computeModel (int debug_verbosity_level = 0);
+        bool computeModel (int debug_verbosity_level)
+        
+        # /** \brief Set the percentage of points to pre-test.
+        # * \param nr_pretest percentage of points to pre-test
+        # */
+        # inline void setFractionNrPretest (double nr_pretest)
+        void setFractionNrPretest (double nr_pretest)
+        
+        # /** \brief Get the percentage of points to pre-test. */
+        # inline double getFractionNrPretest ()
+        double getFractionNrPretest ()
+
+
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZ] RandomizedMEstimatorSampleConsensus_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZI] RandomizedMEstimatorSampleConsensus_PointXYZI_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB] RandomizedMEstimatorSampleConsensus_PointXYZRGB_t
+ctypedef RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusPtr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZ]] RandomizedMEstimatorSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZI]] RandomizedMEstimatorSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGB]] RandomizedMEstimatorSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomizedMEstimatorSampleConsensus[cpp.PointXYZRGBA]] RandomizedMEstimatorSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# rransac.h
+# namespace pcl
+# template <typename PointT>
+# class RandomizedRandomSampleConsensus : public SampleConsensus<PointT>
+cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+    cdef cppclass RandomizedRandomSampleConsensus[T](SampleConsensus[T]):
+        RandomizedRandomSampleConsensus ()
+        RandomizedRandomSampleConsensus (shared_ptr[SampleConsensusModel[T]] model)
+        # RandomizedRandomSampleConsensus (const SampleConsensusModelPtr &model)
+        # RandomizedRandomSampleConsensus (const SampleConsensusModelPtr &model, double threshold)
+        # using SampleConsensus<PointT>::max_iterations_;
+        # using SampleConsensus<PointT>::threshold_;
+        # using SampleConsensus<PointT>::iterations_;
+        # using SampleConsensus<PointT>::sac_model_;
+        # using SampleConsensus<PointT>::model_;
+        # using SampleConsensus<PointT>::model_coefficients_;
+        # using SampleConsensus<PointT>::inliers_;
+        # using SampleConsensus<PointT>::probability_;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # public:
+        # /** \brief RRANSAC (RAndom SAmple Consensus) main constructor
+        # * \param model a Sample Consensus model
+        # * \param threshold distance to model threshold
+        # /** \brief Compute the actual model and find the inliers
+        # * \param debug_verbosity_level enable/disable on-screen debug information and set the verbosity level
+        # */
+        # bool computeModel (int debug_verbosity_level = 0)
+        bool computeModel (int debug_verbosity_level)
+        
+        # \brief Set the percentage of points to pre-test.
+        # \param nr_pretest percentage of points to pre-test
+        # inline void setFractionNrPretest (double nr_pretest)
+        void setFractionNrPretest (double nr_pretest)
+        
+        # /** \brief Get the percentage of points to pre-test. */
+        # inline double getFractionNrPretest ()
+        double getFractionNrPretest ()
+
+
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZ] RandomizedRandomSampleConsensus_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZI] RandomizedRandomSampleConsensus_PointXYZI_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGB] RandomizedRandomSampleConsensus_PointXYZRGB_t
+ctypedef RandomizedRandomSampleConsensus[cpp.PointXYZRGBA] RandomizedRandomSampleConsensus_PointXYZRGBA_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusPtr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_Ptr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZ]] RandomizedRandomSampleConsensusConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZI]] RandomizedRandomSampleConsensus_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGB]] RandomizedRandomSampleConsensus_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const RandomizedRandomSampleConsensus[cpp.PointXYZRGBA]] RandomizedRandomSampleConsensus_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_circle.h
+# namespace pcl
+# template <typename PointT>
+# class SampleConsensusModelCircle2D : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_circle.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelCircle2D[T](SampleConsensusModel[T]):
+        SampleConsensusModelCircle2D ()
+        # SampleConsensusModelCircle2D (const PointCloudConstPtr &cloud)
+        # SampleConsensusModelCircle2D (const PointCloudConstPtr &cloud, const std::vector<int> &indices)
+        # SampleConsensusModelCircle2D (const SampleConsensusModelCircle2D &source) :
+        # inline SampleConsensusModelCircle2D& operator = (const SampleConsensusModelCircle2D &source)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCircle2D> Ptr;
+        # /** \brief Check whether the given index samples can form a valid 2D circle model, compute the model coefficients
+        # * from these samples and store them in model_coefficients. The circle coefficients are: x, y, R.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # /** \brief Compute all distances from the cloud data to a given 2D circle model.
+        # * \param[in] model_coefficients the coefficients of a 2D circle model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # /** \brief Compute all distances from the cloud data to a given 2D circle model.
+        # * \param[in] model_coefficients the coefficients of a 2D circle model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold, 
+        #                     std::vector<int> &inliers);
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                    const double threshold);
+        # /** \brief Recompute the 2d circle coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the 2d circle model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # /** \brief Create a new point cloud with inliers projected onto the 2d circle model.
+        # * \param[in] inliers the data inliers that we want to project on the 2d circle model
+        # * \param[in] model_coefficients the coefficients of a 2d circle model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # /** \brief Verify whether a subset of indices verifies the given 2d circle model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the 2d circle model
+        # * \param[in] model_coefficients the 2d circle model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # /** \brief Return an unique id for this model (SACMODEL_CIRCLE2D). */
+        # inline pcl::SacModel getModelType () const
+
+
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZ] SampleConsensusModelCircle2D_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZI] SampleConsensusModelCircle2D_PointXYZI_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGB] SampleConsensusModelCircle2D_PointXYZRGB_t
+ctypedef SampleConsensusModelCircle2D[cpp.PointXYZRGBA] SampleConsensusModelCircle2D_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DPtr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZ]] SampleConsensusModelCircle2DConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZI]] SampleConsensusModelCircle2D_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGB]] SampleConsensusModelCircle2D_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCircle2D[cpp.PointXYZRGBA]] SampleConsensusModelCircle2D_PointXYZRGBA_ConstPtr_t
+###
+
+# namespace pcl
+# struct OptimizationFunctor : pcl::Functor<float>
+#         OptimizationFunctor (int m_data_points, pcl::SampleConsensusModelCircle2D<PointT> *model) : 
+# 
+#         /** Cost function to be minimized
+#           * \param[in] x the variables array
+#           * \param[out] fvec the resultant functions evaluations
+#           * \return 0
+#           */
+#         int operator() (const Eigen::VectorXf &x, Eigen::VectorXf &fvec) const
+#         pcl::SampleConsensusModelCircle2D<PointT> *model_;
+###
+
+# sac_model_cone.h
+# namespace pcl
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelCone : public SampleConsensusModel<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_cone.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelCone[T, NT](SampleConsensusModel[T])(SampleConsensusModelFromNormals[T, NT]):
+    cdef cppclass SampleConsensusModelCone[T, NT]:
+        SampleConsensusModelCone ()
+        # Nothing
+        # SampleConsensusModelCone ()
+        # Use
+        # SampleConsensusModelCone (const PointCloudConstPtr &cloud)
+        # SampleConsensusModelCone (const PointCloudConstPtr &cloud, const std::vector<int> &indices)
+        # SampleConsensusModelCone (const SampleConsensusModelCone &source)
+        # inline SampleConsensusModelCone& operator = (const SampleConsensusModelCone &source)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCone> Ptr;
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the cone's axis and the given axis.
+        # inline void setEpsAngle (double ea)
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () const
+        # /** \brief Set the axis along which we need to search for a cone direction.
+        # * \param[in] ax the axis along which we need to search for a cone direction
+        # inline void setAxis (const Eigen::Vector3f &ax)
+        # /** \brief Get the axis along which we need to search for a cone direction. */
+        # inline Eigen::Vector3f getAxis () const
+        # /** \brief Set the minimum and maximum allowable opening angle for a cone model
+        # * given from a user.
+        # * \param[in] min_angle the minimum allwoable opening angle of a cone model
+        # * \param[in] max_angle the maximum allwoable opening angle of a cone model
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        # /** \brief Get the opening angle which we need minumum to validate a cone model.
+        # * \param[out] min_angle the minimum allwoable opening angle of a cone model
+        # * \param[out] max_angle the maximum allwoable opening angle of a cone model
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle) const
+        # /** \brief Check whether the given index samples can form a valid cone model, compute the model coefficients
+        # * from these samples and store them in model_coefficients. The cone coefficients are: apex,
+        # * axis_direction, opening_angle.
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # /** \brief Compute all distances from the cloud data to a given cone model.
+        # * \param[in] model_coefficients the coefficients of a cone model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients,  std::vector<double> &distances);
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a cone model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold, std::vector<int> &inliers);
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # /** \brief Recompute the cone coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the cone model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # /** \brief Create a new point cloud with inliers projected onto the cone model.
+        # * \param[in] inliers the data inliers that we want to project on the cone model
+        # * \param[in] model_coefficients the coefficients of a cone model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, bool copy_data_fields = true);
+        # /** \brief Verify whether a subset of indices verifies the given cone model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the cone model
+        # * \param[in] model_coefficients the cone model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, const double threshold);
+        # /** \brief Return an unique id for this model (SACMODEL_CONE). */
+        # inline pcl::SacModel getModelType () const
+        # protected:
+        # /** \brief Get the distance from a point to a line (represented by a point and a direction)
+        # * \param[in] pt a point
+        # * \param[in] model_coefficients the line coefficients (a point on the line, line direction)
+        # double pointToAxisDistance (const Eigen::Vector4f &pt, const Eigen::VectorXf &model_coefficients);
+        # /** \brief Get a string representation of the name of this class. */
+        # std::string getName () const { return ("SampleConsensusModelCone"); }
+        # protected:
+        # /** \brief Check whether a model is valid given the user constraints.
+        # * \param[in] model_coefficients the set of model coefficients
+        # bool isModelValid (const Eigen::VectorXf &model_coefficients);
+        # /** \brief Check if a sample of indices results in a good sample of points
+        # * indices. Pure virtual.
+        # * \param[in] samples the resultant index samples
+        # bool isSampleGood (const std::vector<int> &samples) const;
+
+
+ctypedef SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCone_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCone_PointXYZI_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCone_PointXYZRGB_t
+ctypedef SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCone_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelConePtr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCone_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCone_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCone[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCone_PointXYZRGBA_Ptr_t
+###
+
+# namespace pcl
+# /** \brief Functor for the optimization function */
+# struct OptimizationFunctor : pcl::Functor<float>
+# cdef extern from "pcl/sample_consensus/sac_model_cone.h" namespace "pcl":
+#     cdef cppclass OptimizationFunctor(Functor[float]):
+#         OptimizationFunctor (int m_data_points, pcl::SampleConsensusModelCone<PointT, PointNT> *model) : 
+#         int operator() (const Eigen::VectorXf &x, Eigen::VectorXf &fvec) const
+#         pcl::SampleConsensusModelCone<PointT, PointNT> *model_;
+###
+
+
+# sac_model_cylinder.h
+# namespace pcl
+# \brief @b SampleConsensusModelCylinder defines a model for 3D cylinder segmentation.
+# The model coefficients are defined as:
+# \b point_on_axis.x  : the X coordinate of a point located on the cylinder axis
+# \b point_on_axis.y  : the Y coordinate of a point located on the cylinder axis
+# \b point_on_axis.z  : the Z coordinate of a point located on the cylinder axis
+# \b axis_direction.x : the X coordinate of the cylinder's axis direction
+# \b axis_direction.y : the Y coordinate of the cylinder's axis direction
+# \b axis_direction.z : the Z coordinate of the cylinder's axis direction
+# \b radius           : the cylinder's radius
+# \author Radu Bogdan Rusu
+# \ingroup sample_consensus
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelCylinder : public SampleConsensusModel<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+# Multi Inheritance NG
+# cdef cppclass SampleConsensusModelCylinder[PointT](SampleConsensusModel[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+cdef extern from "pcl/sample_consensus/sac_model_cylinder.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelCylinder[PointT, PointNT]:
+        SampleConsensusModelCylinder()
+        SampleConsensusModelCylinder(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelCylinder> Ptr;
+        # 
+        # \brief Constructor for base SampleConsensusModelCylinder.
+        # \param[in] cloud the input point cloud dataset
+        # SampleConsensusModelCylinder (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Constructor for base SampleConsensusModelCylinder.
+        # \param[in] cloud the input point cloud dataset
+        # \param[in] indices a vector of point indices to be used from \a cloud
+        # SampleConsensusModelCylinder (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModel<PointT> (cloud, indices), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Copy constructor.
+        # \param[in] source the model to copy into this
+        # SampleConsensusModelCylinder (const SampleConsensusModelCylinder &source) :
+        # SampleConsensusModel<PointT> (),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0),
+        # tmp_inliers_ ()
+        # 
+        # \brief Copy constructor.
+        # \param[in] source the model to copy into this
+        # inline SampleConsensusModelCylinder& operator = (const SampleConsensusModelCylinder &source)
+        # 
+        # \brief Set the angle epsilon (delta) threshold.
+        # \param[in] ea the maximum allowed difference between the cyilinder axis and the given axis.
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # \brief Get the angle epsilon (delta) threshold.
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # \brief Set the axis along which we need to search for a cylinder direction.
+        # \param[in] ax the axis along which we need to search for a cylinder direction
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # \brief Get the axis along which we need to search for a cylinder direction.
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # \brief Check whether the given index samples can form a valid cylinder model, compute the model coefficients
+        #  from these samples and store them in model_coefficients. The cylinder coefficients are: point_on_axis,
+        #  axis_direction, cylinder_radius_R
+        # \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # \param[out] model_coefficients the resultant model coefficients
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # \brief Compute all distances from the cloud data to a given cylinder model.
+        # \param[in] model_coefficients the coefficients of a cylinder model that we need to compute distances to
+        # \param[out] distances the resultant estimated distances
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # \brief Select all the points which respect the given model coefficients as inliers.
+        # \param[in] model_coefficients the coefficients of a cylinder model that we need to compute distances to
+        # \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # \param[out] inliers the resultant model inliers
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # \brief Count all the points which respect the given model coefficients as inliers. 
+        # \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # \return the resultant number of inliers
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # \brief Recompute the cylinder coefficients using the given inlier set and return them to the user.
+        #  @note: these are the coefficients of the cylinder model after refinement (eg. after SVD)
+        # \param[in] inliers the data inliers found as supporting the model
+        # \param[in] model_coefficients the initial guess for the optimization
+        # \param[out] optimized_coefficients the resultant recomputed coefficients after non-linear optimization
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # \brief Create a new point cloud with inliers projected onto the cylinder model.
+        # \param[in] inliers the data inliers that we want to project on the cylinder model
+        # \param[in] model_coefficients the coefficients of a cylinder model
+        # \param[out] projected_points the resultant projected points
+        # \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients,  PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # \brief Verify whether a subset of indices verifies the given cylinder model coefficients.
+        # \param[in] indices the data indices that need to be tested against the cylinder model
+        # \param[in] model_coefficients the cylinder model coefficients
+        # \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # bool doSamplesVerifyModel (const std::set<int> &indices, const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_CYLINDER). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_CYLINDER); }
+
+
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal] SampleConsensusModelCylinder_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal] SampleConsensusModelCylinder_PointXYZI_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGB_t
+ctypedef SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelCylinder_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderPtr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelCylinderConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelCylinder_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelCylinder[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelCylinder_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_line.h
+# namespace pcl
+# /** \brief SampleConsensusModelLine defines a model for 3D line segmentation.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   *
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelLine : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_line.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelLine[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelLine()
+        SampleConsensusModelLine(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelLine> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelLine (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelLine (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        # 
+        # /** \brief Check whether the given index samples can form a valid line model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The line coefficients are represented by a
+        # * point and a line direction
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given line model.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the line coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the line model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, 
+        #                          const Eigen::VectorXf &model_coefficients, 
+        #                          Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the line model.
+        # * \param[in] inliers the data inliers that we want to project on the line model
+        # * \param[in] model_coefficients the *normalized* coefficients of a line model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, 
+        #              const Eigen::VectorXf &model_coefficients, 
+        #              PointCloud &projected_points, 
+        #              bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given line model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the line model
+        # * \param[in] model_coefficients the line model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, 
+        #                     const Eigen::VectorXf &model_coefficients, 
+        #                     const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_LINE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_LINE); }
+
+
+ctypedef SampleConsensusModelLine[cpp.PointXYZ] SampleConsensusModelLine_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZI] SampleConsensusModelLine_PointXYZI_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZRGB] SampleConsensusModelLine_PointXYZRGB_t
+ctypedef SampleConsensusModelLine[cpp.PointXYZRGBA] SampleConsensusModelLine_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLinePtr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZ]] SampleConsensusModelLineConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZI]] SampleConsensusModelLine_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGB]] SampleConsensusModelLine_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelLine[cpp.PointXYZRGBA]] SampleConsensusModelLine_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_parallel_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelNormalParallelPlane defines a model for 3D
+#   * plane segmentation using additional surface normal constraints. Basically
+#   * this means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the plane's normal and the inlier points normals. In addition,
+#   * the plane normal must lie parallel to an user-specified axis.
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * To set the influence of the surface normals in the inlier estimation
+#   * process, set the normal weight (0.0-1.0), e.g.:
+#   * \code
+#   * SampleConsensusModelNormalPlane<pcl::PointXYZ, pcl::Normal> sac_model;
+#   * ...
+#   * sac_model.setNormalDistanceWeight (0.1);
+#   * ...
+#   * \endcode
+#   * In addition, the user can specify more constraints, such as:
+#   * 
+#   *   - an axis along which we need to search for a plane perpendicular to (\ref setAxis);
+#   *   - an angle \a tolerance threshold between the plane's normal and the above given axis (\ref setEpsAngle);
+#   *   - a distance we expect the plane to be from the origin (\ref setDistanceFromOrigin);
+#   *   - a distance \a tolerance as the maximum allowed deviation from the above given distance from the origin (\ref setEpsDist).
+#   *
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu B. Rusu and Jared Glover and Nico Blodow
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalParallelPlane : public SampleConsensusModelPlane<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_parallel_plane.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalParallelPlane[PointT](SampleConsensusModelPlane[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalParallelPlane[PointT, PointNT]:
+        SampleConsensusModelNormalParallelPlane()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalParallelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalParallelPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud),
+        # axis_ (Eigen::Vector4f::Zero ()),
+        # distance_from_origin_ (0),
+        # eps_angle_ (-1.0), cos_angle_ (-1.0), eps_dist_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalParallelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector4f::Zero ()),
+        # distance_from_origin_ (0),
+        # eps_angle_ (-1.0), cos_angle_ (-1.0), eps_dist_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_.head<3> () = ax; axis_.normalize ();}
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis () { return (axis_.head<3> ()); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed deviation from 90 degrees between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; cos_angle_ = fabs (cos (ea));}
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Set the distance we expect the plane to be from the origin
+        # * \param[in] d distance from the template plane to the origin
+        # */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        # 
+        # /** \brief Get the distance of the plane from the origin. */
+        # inline double getDistanceFromOrigin () { return (distance_from_origin_); }
+        # 
+        # /** \brief Set the distance epsilon (delta) threshold.
+        # * \param[in] delta the maximum allowed deviation from the template distance from the origin
+        # */
+        # inline void setEpsDist (const double delta) { eps_dist_ = delta; }
+        # 
+        # /** \brief Get the distance epsilon (delta) threshold. */
+        # inline double getEpsDist () { return (eps_dist_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # *
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_PARALLEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_PARALLEL_PLANE); }
+
+
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalParallelPlane_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZI_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalParallelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalParallelPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalParallelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelNormalPlane defines a model for 3D plane
+#   * segmentation using additional surface normal constraints. Basically this
+#   * means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the plane's normal and the inlier points normals.
+#   *
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * To set the influence of the surface normals in the inlier estimation
+#   * process, set the normal weight (0.0-1.0), e.g.:
+#   * \code
+#   * SampleConsensusModelNormalPlane<pcl::PointXYZ, pcl::Normal> sac_model;
+#   * ...
+#   * sac_model.setNormalDistanceWeight (0.1);
+#   * ...
+#   * \endcode
+#   * \author Radu B. Rusu and Jared Glover
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalPlane : public SampleConsensusModelPlane<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_plane.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalPlane[PointT, PointNT](SampleConsensusModelPlane[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalPlane[PointT, PointNT]:
+        SampleConsensusModelNormalPlane()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalPlane (const PointCloudConstPtr &cloud) : SampleConsensusModelPlane<PointT> (cloud)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModelPlane<PointT> (cloud, indices)
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_PLANE); }
+
+
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalPlane_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZI_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalPlane[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_normal_sphere.h
+# namespace pcl
+# /** \brief @b SampleConsensusModelNormalSphere defines a model for 3D sphere
+#   * segmentation using additional surface normal constraints. Basically this
+#   * means that checking for inliers will not only involve a "distance to
+#   * model" criterion, but also an additional "maximum angular deviation"
+#   * between the sphere's normal and the inlier points normals.
+#   * The model coefficients are defined as:
+#   * <ul>
+#   * <li><b>a</b> : the X coordinate of the plane's normal (normalized)
+#   * <li><b>b</b> : the Y coordinate of the plane's normal (normalized)
+#   * <li><b>c</b> : the Z coordinate of the plane's normal (normalized)
+#   * <li><b>d</b> : radius of the sphere
+#   * </ul>
+#   * \author Stefan Schrandt
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT, typename PointNT>
+# class SampleConsensusModelNormalSphere : public SampleConsensusModelSphere<PointT>, public SampleConsensusModelFromNormals<PointT, PointNT>
+cdef extern from "pcl/sample_consensus/sac_model_normal_sphere.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelNormalSphere[PointT, PointNT](SampleConsensusModelSphere[PointT])(SampleConsensusModelFromNormals[PointT, PointNT]):
+    cdef cppclass SampleConsensusModelNormalSphere[PointT, PointNT]:
+        SampleConsensusModelNormalSphere()
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normals_;
+        # using SampleConsensusModelFromNormals<PointT, PointNT>::normal_distance_weight_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNPtr PointCloudNPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::PointCloudNConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelNormalSphere> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelNormalSphere (const PointCloudConstPtr &cloud) : SampleConsensusModelSphere<PointT> (cloud)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelNormalSphere.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelNormalSphere (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModelSphere<PointT> (cloud, indices)
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given sphere model.
+        # * \param[in] model_coefficients the coefficients of a sphere model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_NORMAL_SPHERE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_NORMAL_SPHERE); }
+
+
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal] SampleConsensusModelNormalSphere_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZI_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGB_t
+ctypedef SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal] SampleConsensusModelNormalSphere_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSpherePtr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZ, cpp.Normal]] SampleConsensusModelNormalSphereConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZI, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGB, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelNormalSphere[cpp.PointXYZRGBA, cpp.Normal]] SampleConsensusModelNormalSphere_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_parallel_line.h
+# namespace pcl
+# /** \brief SampleConsensusModelParallelLine defines a model for 3D line segmentation using additional angular
+#   * constraints.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelParallelLine : public SampleConsensusModelLine<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_parallel_line.h" namespace "pcl":
+    # cdef cppclass SampleConsensusModelParallelLine[PointT](SampleConsensusModelLine[PointT]):
+    cdef cppclass SampleConsensusModelParallelLine[PointT]:
+        SampleConsensusModelParallelLine()
+        # public:
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelLine<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelParallelLine> Ptr;
+        # /** \brief Constructor for base SampleConsensusModelParallelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelParallelLine (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelLine<PointT> (cloud),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelLine.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelParallelLine (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelLine<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; axis_.normalize (); }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given line model.
+        # * \param[in] model_coefficients the coefficients of a line model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PARALLEL_LINE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PARALLEL_LINE); }
+
+
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZ] SampleConsensusModelParallelLine_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZI] SampleConsensusModelParallelLine_PointXYZI_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGB] SampleConsensusModelParallelLine_PointXYZRGB_t
+ctypedef SampleConsensusModelParallelLine[cpp.PointXYZRGBA] SampleConsensusModelParallelLine_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLinePtr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZ]] SampleConsensusModelParallelLineConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZI]] SampleConsensusModelParallelLine_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGB]] SampleConsensusModelParallelLine_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelLine[cpp.PointXYZRGBA]] SampleConsensusModelParallelLine_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_parallel_plane.h
+# namespace pcl
+# /** \brief @b SampleConsensusModelParallelPlane defines a model for 3D plane segmentation using additional
+#   * angular constraints. The plane must be parallel to a user-specified axis
+#   * (\ref setAxis) within an user-specified angle threshold (\ref setEpsAngle).
+#   * Code example for a plane model, parallel (within a 15 degrees tolerance) with the Z axis:
+#   * \code
+#   * SampleConsensusModelParallelPlane<pcl::PointXYZ> model (cloud);
+#   * model.setAxis (Eigen::Vector3f (0.0, 0.0, 1.0));
+#   * model.setEpsAngle (pcl::deg2rad (15));
+#   * \endcode
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu Bogdan Rusu, Nico Blodow
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelParallelPlane : public SampleConsensusModelPlane<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_parallel_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelParallelPlane[PointT](SampleConsensusModelPlane[PointT]):
+        SampleConsensusModelParallelLine()
+        # public:
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelParallelPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelParallelPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0), sin_angle_ (-1.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelParallelPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelParallelPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices),
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0), sin_angle_ (-1.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; sin_angle_ = fabs (sin (ea));}
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PARALLEL_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PARALLEL_PLANE); }
+
+
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZ] SampleConsensusModelParallelPlane_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZI] SampleConsensusModelParallelPlane_PointXYZI_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGB] SampleConsensusModelParallelPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelParallelPlane[cpp.PointXYZRGBA] SampleConsensusModelParallelPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZ]] SampleConsensusModelParallelPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZI]] SampleConsensusModelParallelPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGB]] SampleConsensusModelParallelPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelParallelPlane[cpp.PointXYZRGBA]] SampleConsensusModelParallelPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_perpendicular_plane.h
+# namespace pcl
+# /** \brief SampleConsensusModelPerpendicularPlane defines a model for 3D plane segmentation using additional
+#   * angular constraints. The plane must be perpendicular to an user-specified axis (\ref setAxis), up to an user-specified angle threshold (\ref setEpsAngle).
+#   * The model coefficients are defined as:
+#   *   - \b a : the X coordinate of the plane's normal (normalized)
+#   *   - \b b : the Y coordinate of the plane's normal (normalized)
+#   *   - \b c : the Z coordinate of the plane's normal (normalized)
+#   *   - \b d : the fourth <a href="http://mathworld.wolfram.com/HessianNormalForm.html">Hessian component</a> of the plane's equation
+#   * Code example for a plane model, perpendicular (within a 15 degrees tolerance) with the Z axis:
+#   * \code
+#   * SampleConsensusModelPerpendicularPlane<pcl::PointXYZ> model (cloud);
+#   * model.setAxis (Eigen::Vector3f (0.0, 0.0, 1.0));
+#   * model.setEpsAngle (pcl::deg2rad (15));
+#   * \endcode
+#   * \note Please remember that you need to specify an angle > 0 in order to activate the axis-angle constraint!
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelPerpendicularPlane : public SampleConsensusModelPlane<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_perpendicular_plane.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelPerpendicularPlane[PointT](SampleConsensusModelPlane[PointT]):
+        SampleConsensusModelPerpendicularPlane()
+        # public:
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModelPlane<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelPerpendicularPlane> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPerpendicularPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelPerpendicularPlane (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModelPlane<PointT> (cloud), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelPerpendicularPlane.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelPerpendicularPlane (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : 
+        # SampleConsensusModelPlane<PointT> (cloud, indices), 
+        # axis_ (Eigen::Vector3f::Zero ()),
+        # eps_angle_ (0.0)
+        # 
+        # /** \brief Set the axis along which we need to search for a plane perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a plane perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a plane perpendicular to. */
+        # inline Eigen::Vector3f getAxis ()  { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the plane normal and the given axis.
+        # * \note You need to specify an angle > 0 in order to activate the axis-angle constraint!
+        # */
+        # inline void setEpsAngle (const double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the angle epsilon (delta) threshold. */
+        # inline double getEpsAngle () { return (eps_angle_); }
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Compute all distances from the cloud data to a given plane model.
+        # * \param[in] model_coefficients the coefficients of a plane model that we need to compute distances to
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_PERPENDICULAR_PLANE). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_PERPENDICULAR_PLANE); }
+
+
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZ] SampleConsensusModelPerpendicularPlane_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZI] SampleConsensusModelPerpendicularPlane_PointXYZI_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB] SampleConsensusModelPerpendicularPlane_PointXYZRGB_t
+ctypedef SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlanePtr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZ]] SampleConsensusModelPerpendicularPlaneConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZI]] SampleConsensusModelPerpendicularPlane_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGB]] SampleConsensusModelPerpendicularPlane_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelPerpendicularPlane[cpp.PointXYZRGBA]] SampleConsensusModelPerpendicularPlane_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_registration.h
+# namespace pcl
+# /** \brief SampleConsensusModelRegistration defines a model for Point-To-Point registration outlier rejection.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelRegistration : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_registration.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelRegistration[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelRegistration()
+        SampleConsensusModelRegistration(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelRegistration> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelRegistration.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelRegistration (const PointCloudConstPtr &cloud) : 
+        # SampleConsensusModel<PointT> (cloud),
+        # target_ (),
+        # indices_tgt_ (),
+        # correspondences_ (),
+        # sample_dist_thresh_ (0)
+        # 
+        # /** \brief Constructor for base SampleConsensusModelRegistration.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelRegistration (const PointCloudConstPtr &cloud, const std::vector<int> &indices) :
+        # SampleConsensusModel<PointT> (cloud, indices),
+        # target_ (),
+        # indices_tgt_ (),
+        # correspondences_ (),
+        # sample_dist_thresh_ (0)
+        # 
+        # /** \brief Provide a pointer to the input dataset
+        # * \param[in] cloud the const boost shared pointer to a PointCloud message
+        # */
+        # inline virtual void setInputCloud (const PointCloudConstPtr &cloud)
+        # 
+        # /** \brief Set the input point cloud target.
+        # * \param target the input point cloud target
+        # */
+        # inline void setInputTarget (const PointCloudConstPtr &target)
+        # 
+        # /** \brief Set the input point cloud target.
+        # * \param[in] target the input point cloud target
+        # * \param[in] indices_tgt a vector of point indices to be used from \a target
+        # */
+        # inline void setInputTarget (const PointCloudConstPtr &target, const std::vector<int> &indices_tgt)
+        # 
+        # /** \brief Compute a 4x4 rigid transformation matrix from the samples given
+        # * \param[in] samples the indices found as good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all distances from the transformed points to their correspondences
+        # * \param[in] model_coefficients the 4x4 transformation matrix
+        # * \param[out] distances the resultant estimated distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the 4x4 transformation matrix
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the 4x4 transformation using the given inlier set
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the optimization
+        # * \param[out] optimized_coefficients the resultant recomputed transformation
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # void projectPoints (const std::vector<int> &, const Eigen::VectorXf &, PointCloud &, bool = true)
+        # 
+        # bool doSamplesVerifyModel (const std::set<int> &, const Eigen::VectorXf &, const double)
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_REGISTRATION). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_REGISTRATION); }
+
+
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZ] SampleConsensusModelRegistration_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZI] SampleConsensusModelRegistration_PointXYZI_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGB] SampleConsensusModelRegistration_PointXYZRGB_t
+ctypedef SampleConsensusModelRegistration[cpp.PointXYZRGBA] SampleConsensusModelRegistration_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationPtr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZ]] SampleConsensusModelRegistrationConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZI]] SampleConsensusModelRegistration_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGB]] SampleConsensusModelRegistration_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelRegistration[cpp.PointXYZRGBA]] SampleConsensusModelRegistration_PointXYZRGBA_ConstPtr_t
+###
+
+# sac_model_stick.h
+# namespace pcl
+# /** \brief SampleConsensusModelStick defines a model for 3D stick segmentation. 
+#   * A stick is a line with an user given minimum/maximum width.
+#   * The model coefficients are defined as:
+#   *   - \b point_on_line.x  : the X coordinate of a point on the line
+#   *   - \b point_on_line.y  : the Y coordinate of a point on the line
+#   *   - \b point_on_line.z  : the Z coordinate of a point on the line
+#   *   - \b line_direction.x : the X coordinate of a line's direction
+#   *   - \b line_direction.y : the Y coordinate of a line's direction
+#   *   - \b line_direction.z : the Z coordinate of a line's direction
+#   *   - \b line_width       : the width of the line
+#   * \author Radu B. Rusu
+#   * \ingroup sample_consensus
+#   */
+# template <typename PointT>
+# class SampleConsensusModelStick : public SampleConsensusModel<PointT>
+cdef extern from "pcl/sample_consensus/sac_model_stick.h" namespace "pcl":
+    cdef cppclass SampleConsensusModelStick[PointT](SampleConsensusModel[PointT]):
+        SampleConsensusModelStick()
+        SampleConsensusModelStick(shared_ptr[cpp.PointCloud[PointT]] cloud)
+        # using SampleConsensusModel<PointT>::input_;
+        # using SampleConsensusModel<PointT>::indices_;
+        # using SampleConsensusModel<PointT>::radius_min_;
+        # using SampleConsensusModel<PointT>::radius_max_;
+        # public:
+        # typedef typename SampleConsensusModel<PointT>::PointCloud PointCloud;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudPtr PointCloudPtr;
+        # typedef typename SampleConsensusModel<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<SampleConsensusModelStick> Ptr;
+        # 
+        # /** \brief Constructor for base SampleConsensusModelStick.
+        # * \param[in] cloud the input point cloud dataset
+        # */
+        # SampleConsensusModelStick (const PointCloudConstPtr &cloud) : SampleConsensusModel<PointT> (cloud) {};
+        # 
+        # /** \brief Constructor for base SampleConsensusModelStick.
+        # * \param[in] cloud the input point cloud dataset
+        # * \param[in] indices a vector of point indices to be used from \a cloud
+        # */
+        # SampleConsensusModelStick (const PointCloudConstPtr &cloud, const std::vector<int> &indices) : SampleConsensusModel<PointT> (cloud, indices) {};
+        # 
+        # /** \brief Check whether the given index samples can form a valid stick model, compute the model coefficients from
+        # * these samples and store them internally in model_coefficients_. The stick coefficients are represented by a
+        # * point and a line direction
+        # * \param[in] samples the point indices found as possible good candidates for creating a valid model
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # bool computeModelCoefficients (const std::vector<int> &samples, Eigen::VectorXf &model_coefficients);
+        # 
+        # /** \brief Compute all squared distances from the cloud data to a given stick model.
+        # * \param[in] model_coefficients the coefficients of a stick model that we need to compute distances to
+        # * \param[out] distances the resultant estimated squared distances
+        # */
+        # void getDistancesToModel (const Eigen::VectorXf &model_coefficients, std::vector<double> &distances);
+        # 
+        # /** \brief Select all the points which respect the given model coefficients as inliers.
+        # * \param[in] model_coefficients the coefficients of a stick model that we need to compute distances to
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # * \param[out] inliers the resultant model inliers
+        # */
+        # void selectWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold, std::vector<int> &inliers);
+        # 
+        # /** \brief Count all the points which respect the given model coefficients as inliers. 
+        # * 
+        # * \param[in] model_coefficients the coefficients of a model that we need to compute distances to
+        # * \param[in] threshold maximum admissible distance threshold for determining the inliers from the outliers
+        # * \return the resultant number of inliers
+        # */
+        # virtual int countWithinDistance (const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Recompute the stick coefficients using the given inlier set and return them to the user.
+        # * @note: these are the coefficients of the stick model after refinement (eg. after SVD)
+        # * \param[in] inliers the data inliers found as supporting the model
+        # * \param[in] model_coefficients the initial guess for the model coefficients
+        # * \param[out] optimized_coefficients the resultant recomputed coefficients after optimization
+        # */
+        # void optimizeModelCoefficients (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, Eigen::VectorXf &optimized_coefficients);
+        # 
+        # /** \brief Create a new point cloud with inliers projected onto the stick model.
+        # * \param[in] inliers the data inliers that we want to project on the stick model
+        # * \param[in] model_coefficients the *normalized* coefficients of a stick model
+        # * \param[out] projected_points the resultant projected points
+        # * \param[in] copy_data_fields set to true if we need to copy the other data fields
+        # */
+        # void projectPoints (const std::vector<int> &inliers, const Eigen::VectorXf &model_coefficients, PointCloud &projected_points, bool copy_data_fields = true);
+        # 
+        # /** \brief Verify whether a subset of indices verifies the given stick model coefficients.
+        # * \param[in] indices the data indices that need to be tested against the plane model
+        # * \param[in] model_coefficients the plane model coefficients
+        # * \param[in] threshold a maximum admissible distance threshold for determining the inliers from the outliers
+        # */
+        # bool doSamplesVerifyModel (const std::set<int> &indices, const Eigen::VectorXf &model_coefficients, const double threshold);
+        # 
+        # /** \brief Return an unique id for this model (SACMODEL_STACK). */
+        # inline pcl::SacModel getModelType () const { return (SACMODEL_STICK); }
+
+
+ctypedef SampleConsensusModelStick[cpp.PointXYZ] SampleConsensusModelStick_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZI] SampleConsensusModelStick_PointXYZI_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZRGB] SampleConsensusModelStick_PointXYZRGB_t
+ctypedef SampleConsensusModelStick[cpp.PointXYZRGBA] SampleConsensusModelStick_PointXYZRGBA_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickPtr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_Ptr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZ]] SampleConsensusModelStickConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZI]] SampleConsensusModelStick_PointXYZI_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGB]] SampleConsensusModelStick_PointXYZRGB_ConstPtr_t
+ctypedef shared_ptr[const SampleConsensusModelStick[cpp.PointXYZRGBA]] SampleConsensusModelStick_PointXYZRGBA_ConstPtr_t
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# method_types.h
+cdef extern from "pcl/sample_consensus/method_types.h" namespace "pcl":
+    cdef enum:
+        SAC_RANSAC = 0
+        SAC_LMEDS = 1
+        SAC_MSAC = 2
+        SAC_RRANSAC = 3
+        SAC_RMSAC = 4
+        SAC_MLESAC = 5
+        SAC_PROSAC = 6
+###
+
+# model_types.h
+cdef extern from "pcl/sample_consensus/model_types.h" namespace "pcl":
+    cdef enum SacModel:
+        SACMODEL_PLANE
+        SACMODEL_LINE
+        SACMODEL_CIRCLE2D
+        SACMODEL_CIRCLE3D
+        SACMODEL_SPHERE
+        SACMODEL_CYLINDER
+        SACMODEL_CONE
+        SACMODEL_TORUS
+        SACMODEL_PARALLEL_LINE
+        SACMODEL_PERPENDICULAR_PLANE
+        SACMODEL_PARALLEL_LINES
+        SACMODEL_NORMAL_PLANE
+        SACMODEL_NORMAL_SPHERE        # Version 1.6
+        SACMODEL_REGISTRATION
+        SACMODEL_PARALLEL_PLANE
+        SACMODEL_NORMAL_PARALLEL_PLANE
+        SACMODEL_STICK
+###
+
+# cdef extern from "pcl/sample_consensus/rransac.h" namespace "pcl":
+#     cdef cppclass Functor[_Scalar]:
+#         # enum 
+#         # {
+#         #   InputsAtCompileTime = NX,
+#         #   ValuesAtCompileTime = NY
+#         # };
+
+
+# // Define the number of samples in SacModel needs
+# typedef std::map<pcl::SacModel, unsigned int>::value_type SampleSizeModel;
+# const static SampleSizeModel sample_size_pairs[] = {SampleSizeModel (pcl::SACMODEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_LINE, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_CIRCLE2D, 3),
+#                                                     //SampleSizeModel (pcl::SACMODEL_CIRCLE3D, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_SPHERE, 4),
+#                                                     SampleSizeModel (pcl::SACMODEL_CYLINDER, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_CONE, 3),
+#                                                     //SampleSizeModel (pcl::SACMODEL_TORUS, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_PARALLEL_LINE, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_PERPENDICULAR_PLANE, 3),
+#                                                     //SampleSizeModel (pcl::PARALLEL_LINES, 2),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_SPHERE, 4),
+#                                                     SampleSizeModel (pcl::SACMODEL_REGISTRATION, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_PARALLEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_NORMAL_PARALLEL_PLANE, 3),
+#                                                     SampleSizeModel (pcl::SACMODEL_STICK, 2)};
+# 
+# namespace pcl
+# {
+#   const static std::map<pcl::SacModel, unsigned int> SAC_SAMPLE_SIZE (sample_size_pairs, sample_size_pairs + sizeof (sample_size_pairs) / sizeof (SampleSizeModel));
+# }
+###
+
+###############################################################################
+# Activation
+###############################################################################
+
+
+# extend 172
+# sac_model_registration_2d.h
diff --git a/pcl/pcl_search.pxd b/pcl/pcl_search.pxd
new file mode 100644
index 0000000..cee4ee5
--- /dev/null
+++ b/pcl/pcl_search.pxd
@@ -0,0 +1,442 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+# Base Interface
+# Search.h
+# namespace pcl
+# namespace search
+# template<typename PointT>
+# class Search
+cdef extern from "pcl/Search/Search.h" namespace "pcl::search":
+    Search[T]:
+        Search()
+        # Search (const string& name = "", bool sorted = false)
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<pcl::search::Search<PointT> > Ptr;
+        # typedef boost::shared_ptr<const pcl::search::Search<PointT> > ConstPtr;
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # /** \brief returns the search method name
+        string getName ()
+        
+        # /** \brief sets whether the results should be sorted (ascending in the distance) or not
+        #   * \param[in] sorted should be true if the results should be sorted by the distance in ascending order.
+        #   * Otherwise the results may be returned in any order.
+        void setSortedResults (bool sorted)
+        
+        # /** \brief Pass the input dataset that the search will be performed on.
+        #   * \param[in] cloud a const pointer to the PointCloud data
+        #   * \param[in] indices the point indices subset that is to be used from the cloud
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # virtual PointCloudConstPtr getInputCloud () const
+        
+        # /** \brief Get a pointer to the vector of indices used. */
+        # virtual IndicesConstPtr getIndices () const
+        
+        # /** \brief Search for the k-nearest neighbors for the given query point.
+        #   * \param[in] point the given query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        # virtual int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const = 0;
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * This method accepts a different template parameter for the point type.
+        #   * \param[in] point the given query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        # template <typename PointTDiff>
+        # inline int nearestKSearchT (const PointTDiff &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # 
+        # /** \brief Search for k-nearest neighbors for the given query point (zero-copy).
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] index a \a valid index representing a \a valid query point in the dataset given
+        #   * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in
+        #   * the indices vector.
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances) const
+        # 
+        # /** \brief Search for the k-nearest neighbors for the given query point.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        # virtual void nearestKSearch (const PointCloud& cloud, vector[int]& indices, int k, vector[vector[int] ]& k_indices, std::vector< std::vector<float> >& k_sqr_distances) const
+        # 
+        # /** \brief Search for the k-nearest neighbors for the given query point. 
+        #   *  Use this method if the query points are of a different type than the points in the data set (e.g. PointXYZRGBA instead of PointXYZ).
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \note This method copies the input point cloud of type PointTDiff to a temporary cloud of type PointT and performs the batch search on the new cloud. You should prefer the single-point search if you don't use a search algorithm that accelerates batch NN search.
+        # template <typename PointTDiff> 
+        # void nearestKSearchT (const pcl::PointCloud<PointTDiff> &cloud, const std::vector<int>& indices, int k, std::vector< std::vector<int> > &k_indices, std::vector< std::vector<float> > &k_sqr_distances) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] point the given query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        # virtual int radiusSearch (const PointT& point, double radius, std::vector<int>& k_indices, std::vector<float>& k_sqr_distances, unsigned int max_nn = 0) const = 0;
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] point the given query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        # template <typename PointTDiff> 
+        # inline int radiusSearchT (const PointTDiff &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (const PointCloud &cloud, int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius (zero-copy).
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] index a \a valid index representing a \a valid query point in the dataset given
+        #   * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in
+        #   * the indices vector.
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices the indices in \a cloud. If indices is empty, neighbors will be searched for all points.
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        # virtual void radiusSearch (const PointCloud& cloud,
+        #               const std::vector<int>& indices,
+        #               double radius,
+        #               std::vector< std::vector<int> >& k_indices,
+        #               std::vector< std::vector<float> > &k_sqr_distances,
+        #               unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query points in a given radius.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \note This method copies the input point cloud of type PointTDiff to a temporary cloud of type PointT and performs the batch search on the new cloud. You should prefer the single-point search if you don't use a search algorithm that accelerates batch NN search.
+        # template <typename PointTDiff> void
+        # radiusSearchT (const pcl::PointCloud<PointTDiff> &cloud,
+        #                const std::vector<int>& indices,
+        #                double radius,
+        #                std::vector< std::vector<int> > &k_indices,
+        #                std::vector< std::vector<float> > &k_sqr_distances,
+        #                unsigned int max_nn = 0) const
+
+
+###
+
+# template<typename PointT> void
+# Search<PointT>::sortResults (std::vector<int>& indices, std::vector<float>& distances) const
+# cdef extern from "pcl/Search/Search.h" namespace "pcl::search":
+#   cdef Search[T]::sortResults (std::vector<int>& indices, std::vector<float>& distances) const
+###
+
+# pcl_search target out
+cdef extern from "pcl/Search/brute_force.h" namespace "pcl::search":
+    cdef cppclass BruteForce[PointT](Search[PointT]):
+        BruteForce()
+        # BruteForce (bool sorted_results = false)
+        # ctypedef typename Search<PointT>::PointCloud PointCloud;
+        # ctypedef typename Search<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # ctypedef shared_ptr[vector[int]] IndicesPtr;
+        # ctypedef shared_ptr[vector[int]] IndicesConstPtr;
+        # using Search<PointT>::input_;
+        # using Search<PointT>::indices_;
+        # using Search<PointT>::sorted_results_;
+        # 
+        # cdef struct Entry
+        #     Entry(int , float)
+        #     Entry ()
+        #     unsigned index;
+        #     float distance;
+        
+        # replace by some metric functor
+        # float getDistSqr (const PointT& point1, const PointT& point2) const;
+        float getDistSqr (const PointT& point1, const PointT& point2)
+        
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_distances) const;
+        int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_distances)
+        
+        # int radiusSearch (const PointT& point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+        int radiusSearch (const PointT& point, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        # int denseKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_distances) const;
+        int denseKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_distances)
+        
+        # int sparseKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_distances) const;
+        int sparseKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_distances)
+        
+        # int denseRadiusSearch (const PointT& point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+        int denseRadiusSearch (const PointT& point, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        # int sparseRadiusSearch (const PointT& point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+        int sparseRadiusSearch (const PointT& point, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+
+
+# ctypedef BruteForce
+###
+
+# pcl_search target out
+cdef extern from "pcl/Search/flann_search.h" namespace "pcl":
+    cdef cppclass FlannSearch[T](Search[PointT]):
+        VoxelGrid()
+        
+        void setLeafSize (float, float, float)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        void filter(cpp.PointCloud[T] c)
+        
+        # # ctypedef typename Search<PointT>::PointCloud PointCloud;
+        # # ctypedef typename Search<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # ctypedef sharedptr[vector[int]] IndicesPtr;
+        # ctypedef sharedptr[vector[int]] IndicesConstPtr;
+        # # ctypedef flann::NNIndex[FlannDistance] Index;
+        # ctypedef sharedptr[flann::NNIndex[FlannDistance]] IndexPtr;
+        # ctypedef sharedptr[flann::Matrix[float]] MatrixPtr;
+        # ctypedef sharedptr[flann::Matrix[float]] MatrixConstPtr;
+        # # ctypedef pcl::PointRepresentation<PointT> PointRepresentation;
+        # //typedef boost::shared_ptr<PointRepresentation> PointRepresentationPtr;
+        # ctypedef sharedptr[PointRepresentation] PointRepresentationConstPtr;
+        # # using Search<PointT>::input_;
+        # # using Search<PointT>::indices_;
+        # # using Search<PointT>::sorted_results_;
+        
+        # public:
+        # ctypedef sharedptr[FlannSearch[PointT]] Ptr;
+        # ctypedef sharedptr[FlannSearch[PointT]] ConstPtr;
+        # # cdef cppclass FlannIndexCreator
+        # #    virtual IndexPtr createIndex (MatrixConstPtr data)=0;
+        # # class KdTreeIndexCreator: public FlannIndexCreator
+        # cdef cppclass KdTreeIndexCreator:
+        # # KdTreeIndexCreator (unsigned int max_leaf_size=15)
+        # KdTreeIndexCreator (unsigned int)
+        # # virtual IndexPtr createIndex (MatrixConstPtr data);
+        # cdef FlannSearch (bool sorted = true, FlannIndexCreator* creator = new KdTreeIndexCreator());
+        # cdef void setEpsilon (double eps)
+        # cdef double getEpsilon ()
+        # cdef void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr& indices = IndicesConstPtr ());
+        # cdef int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        # cdef void nearestKSearch (const PointCloud& cloud, const std::vector<int>& indices, int k, 
+        #                           std::vector< std::vector<int> >& k_indices, std::vector< std::vector<float> >& k_sqr_distances) const;
+        # cdef int radiusSearch (const PointT& point, double radius, 
+        #                       std::vector<int> &k_indices, std::vector<float> &k_sqr_distances,
+        #                       unsigned int max_nn = 0) const;
+        # cdef void radiusSearch (const PointCloud& cloud, const std::vector<int>& indices, double radius, std::vector< std::vector<int> >& k_indices,
+        #                       vector[vector[float]] k_sqr_distances, unsigned int max_nn=0) const;
+        # cdef void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # cdef PointRepresentationConstPtr getPointRepresentation ()
+
+
+###
+
+# Conflict pcl_kdtree ?
+# cdef extern from "pcl/Search/kdtree.h" namespace "pcl::search":
+#     cdef cppclass KdTree[PointT](Search[PointT]):
+#         # KdTree()
+#         KdTree (bool)
+#         # public:
+#         # ctypedef typename Search<PointT>::PointCloud PointCloud;
+#         # ctypedef typename Search<PointT>::PointCloudConstPtr PointCloudConstPtr;
+#         
+#         # ctypedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+#         # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+#         # using pcl::search::Search<PointT>::indices_;
+#         # using pcl::search::Search<PointT>::input_;
+#         # using pcl::search::Search<PointT>::getIndices;
+#         # using pcl::search::Search<PointT>::getInputCloud;
+#         # using pcl::search::Search<PointT>::nearestKSearch;
+#         # using pcl::search::Search<PointT>::radiusSearch;
+#         # using pcl::search::Search<PointT>::sorted_results_;
+#         # typedef boost::shared_ptr<KdTree<PointT> > Ptr;
+#         # typedef boost::shared_ptr<const KdTree<PointT> > ConstPtr;
+#         # typedef boost::shared_ptr<pcl::KdTreeFLANN<PointT> > KdTreeFLANNPtr;
+#         # typedef boost::shared_ptr<const pcl::KdTreeFLANN<PointT> > KdTreeFLANNConstPtr;
+#         
+#         void setSortedResults (bool sorted_results)
+#         
+#         void setEpsilon (float eps)
+#         
+#         float getEpsilon ()
+#         
+#         # void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr& indices = IndicesConstPtr ())
+#         
+#         # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#         int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+#         
+#         int radiusSearch (const PointT& point, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+# 
+# 
+###
+
+# Conflict pcl_Octree ?
+# cdef extern from "pcl/Search/Octree.h" namespace "pcl::search":
+#     cdef cppclass Octree[PointT](Search[PointT]):
+#         # Octree (const double resolution)
+#         Octree (double)
+#         
+#         # public:
+#         # ctypedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+#         # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+#         # ctypedef pcl::PointCloud<PointT> PointCloud;
+#         # ctypedef boost::shared_ptr<PointCloud> PointCloudPtr;
+#         # ctypedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+#         # ctypedef boost::shared_ptr<pcl::octree::OctreePointCloudSearch<PointT, LeafTWrap, BranchTWrap> > Ptr;
+#         # ctypedef boost::shared_ptr<const pcl::octree::OctreePointCloudSearch<PointT, LeafTWrap, BranchTWrap> > ConstPtr;
+#         # Ptr tree_;
+#         # using pcl::search::Search<PointT>::input_;
+#         # using pcl::search::Search<PointT>::indices_;
+#         # using pcl::search::Search<PointT>::sorted_results_;
+#         
+#         # void setInputCloud (const PointCloudConstPtr &cloud)
+#         void setInputCloud (const shared_ptr[cpp.PointCloud[PointT]] &cloud)
+#         
+#         # void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr& indices)
+#         # void setInputCloud (const shared_ptr[cpp.PointCloud[PointT]] &cloud, const IndicesConstPtr& indices)
+#         
+#         int nearestKSearch (const cpp.PointCloud[PointT] &cloud, int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+#         
+#         # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#         int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+#         
+#         # int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+#         int nearestKSearch (int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+#         
+#         # int radiusSearch ( const PointCloud &cloud,  int index,  double radius, std::vector<int> &k_indices,  std::vector<float> &k_sqr_distances,  unsigned int max_nn = 0) const
+#         int radiusSearch ( const cpp.PointCloud[PointT] &cloud,  int index,  double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+#         
+#         # int radiusSearch (const PointT &p_q,  double radius,  std::vector<int> &k_indices, std::vector<float> &k_sqr_distances,  unsigned int max_nn = 0) const
+#         int radiusSearch (const PointT &p_q,  double radius,  vector[int] &k_indices, vector[float] &k_sqr_distances,  unsigned int max_nn)
+#         
+#         # cdef int radiusSearch (int index, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn = 0) const
+#         int radiusSearch (int index, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+#         
+#         # cdef void approxNearestSearch ( const PointCloudConstPtr &cloud, int query_index, int &result_index, float &sqr_distance)
+#         void approxNearestSearch ( const shared_ptr[cpp.PointCloud[PointT]] &cloud, int query_index, int &result_index, float &sqr_distance)
+#         
+#         # cdef void approxNearestSearch ( const PointT &p_q, int &result_index, float &sqr_distance)
+#         
+#         # cdef void approxNearestSearch (int query_index, int &result_index, float &sqr_distance)
+# 
+# 
+####
+
+cdef extern from "pcl/Search/organized.h" namespace "pcl::search":
+    cdef cppclass OrganizedNeighbor[PointT](Search[PointT]):
+        OrganizedNeighbor()
+        # OrganizedNeighbor (bool sorted_results = false, float eps = 1e-4f, unsigned pyramid_level = 5)
+        # public:
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # ctypedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # ctypedef boost::shared_ptr<pcl::search::OrganizedNeighbor<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const pcl::search::OrganizedNeighbor<PointT> > ConstPtr;
+        # using pcl::search::Search<PointT>::indices_;
+        # using pcl::search::Search<PointT>::sorted_results_;
+        # using pcl::search::Search<PointT>::input_;
+        
+        # bool isValid () const
+        bool isValid ()
+        
+        # void computeCameraMatrix (Eigen::Matrix3f& camera_matrix) const;
+        # void computeCameraMatrix (eigen3.Matrix3f& camera_matrix)
+        
+        # void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        
+        # int radiusSearch (const PointT &p_q, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+        int radiusSearch (const PointT &p_q, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        void estimateProjectionMatrix ()
+        
+        int nearestKSearch ( const PointT &p_q, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # bool projectPoint (const PointT& p, pcl::PointXY& q) const;
+
+
+###
+
+# pcl_search.h
+# include header
+###
+
+
diff --git a/pcl/pcl_search_172.pxd b/pcl/pcl_search_172.pxd
new file mode 100644
index 0000000..271b0b3
--- /dev/null
+++ b/pcl/pcl_search_172.pxd
@@ -0,0 +1,396 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+# Base Interface
+# Search.h
+# namespace pcl
+# namespace search
+# template<typename PointT>
+# class Search
+cdef extern from "pcl/Search/Search.h" namespace "pcl::search":
+    Search[T]:
+        Search()
+        # Search (const string& name = "", bool sorted = false)
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<pcl::search::Search<PointT> > Ptr;
+        # typedef boost::shared_ptr<const pcl::search::Search<PointT> > ConstPtr;
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # /** \brief returns the search method name
+        string getName ()
+        
+        # /** \brief sets whether the results should be sorted (ascending in the distance) or not
+        #   * \param[in] sorted should be true if the results should be sorted by the distance in ascending order.
+        #   * Otherwise the results may be returned in any order.
+        void setSortedResults (bool sorted)
+        
+        # /** \brief Pass the input dataset that the search will be performed on.
+        #   * \param[in] cloud a const pointer to the PointCloud data
+        #   * \param[in] indices the point indices subset that is to be used from the cloud
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # virtual PointCloudConstPtr getInputCloud () const
+        
+        # /** \brief Get a pointer to the vector of indices used. */
+        # virtual IndicesConstPtr getIndices () const
+        
+        # /** \brief Search for the k-nearest neighbors for the given query point.
+        #   * \param[in] point the given query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        # virtual int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const = 0;
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * This method accepts a different template parameter for the point type.
+        #   * \param[in] point the given query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        # template <typename PointTDiff>
+        # inline int nearestKSearchT (const PointTDiff &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # 
+        # /** \brief Search for k-nearest neighbors for the given query point (zero-copy).
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] index a \a valid index representing a \a valid query point in the dataset given
+        #   * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in
+        #   * the indices vector.
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances) const
+        # 
+        # /** \brief Search for the k-nearest neighbors for the given query point.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        # virtual void nearestKSearch (const PointCloud& cloud, vector[int]& indices, int k, vector[vector[int] ]& k_indices, std::vector< std::vector<float> >& k_sqr_distances) const
+        # 
+        # /** \brief Search for the k-nearest neighbors for the given query point. 
+        #   *  Use this method if the query points are of a different type than the points in the data set (e.g. PointXYZRGBA instead of PointXYZ).
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \note This method copies the input point cloud of type PointTDiff to a temporary cloud of type PointT and performs the batch search on the new cloud. You should prefer the single-point search if you don't use a search algorithm that accelerates batch NN search.
+        # template <typename PointTDiff> 
+        # void nearestKSearchT (const pcl::PointCloud<PointTDiff> &cloud, const std::vector<int>& indices, int k, std::vector< std::vector<int> > &k_indices, std::vector< std::vector<float> > &k_sqr_distances) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] point the given query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        # virtual int radiusSearch (const PointT& point, double radius, std::vector<int>& k_indices, std::vector<float>& k_sqr_distances, unsigned int max_nn = 0) const = 0;
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] point the given query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        # template <typename PointTDiff> 
+        # inline int radiusSearchT (const PointTDiff &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (const PointCloud &cloud, int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius (zero-copy).
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] index a \a valid index representing a \a valid query point in the dataset given
+        #   * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in
+        #   * the indices vector.
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices the indices in \a cloud. If indices is empty, neighbors will be searched for all points.
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        # virtual void radiusSearch (const PointCloud& cloud,
+        #               const std::vector<int>& indices,
+        #               double radius,
+        #               std::vector< std::vector<int> >& k_indices,
+        #               std::vector< std::vector<float> > &k_sqr_distances,
+        #               unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query points in a given radius.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \note This method copies the input point cloud of type PointTDiff to a temporary cloud of type PointT and performs the batch search on the new cloud. You should prefer the single-point search if you don't use a search algorithm that accelerates batch NN search.
+        # template <typename PointTDiff> void
+        # radiusSearchT (const pcl::PointCloud<PointTDiff> &cloud,
+        #                const std::vector<int>& indices,
+        #                double radius,
+        #                std::vector< std::vector<int> > &k_indices,
+        #                std::vector< std::vector<float> > &k_sqr_distances,
+        #                unsigned int max_nn = 0) const
+
+
+###
+
+# template<typename PointT> void
+# Search<PointT>::sortResults (std::vector<int>& indices, std::vector<float>& distances) const
+# cdef extern from "pcl/Search/Search.h" namespace "pcl::search":
+#   cdef Search[T]::sortResults (std::vector<int>& indices, std::vector<float>& distances) const
+###
+
+# pcl_search target out
+cdef extern from "pcl/Search/flann_search.h" namespace "pcl":
+    cdef cppclass FlannSearch[T](Search[PointT]):
+        VoxelGrid()
+        
+        void setLeafSize (float, float, float)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        void filter(cpp.PointCloud[T] c)
+        
+        # # ctypedef typename Search<PointT>::PointCloud PointCloud;
+        # # ctypedef typename Search<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # ctypedef sharedptr[vector[int]] IndicesPtr;
+        # ctypedef sharedptr[vector[int]] IndicesConstPtr;
+        # # ctypedef flann::NNIndex[FlannDistance] Index;
+        # ctypedef sharedptr[flann::NNIndex[FlannDistance]] IndexPtr;
+        # ctypedef sharedptr[flann::Matrix[float]] MatrixPtr;
+        # ctypedef sharedptr[flann::Matrix[float]] MatrixConstPtr;
+        # # ctypedef pcl::PointRepresentation<PointT> PointRepresentation;
+        # //typedef boost::shared_ptr<PointRepresentation> PointRepresentationPtr;
+        # ctypedef sharedptr[PointRepresentation] PointRepresentationConstPtr;
+        # # using Search<PointT>::input_;
+        # # using Search<PointT>::indices_;
+        # # using Search<PointT>::sorted_results_;
+        
+        # public:
+        # ctypedef sharedptr[FlannSearch[PointT]] Ptr;
+        # ctypedef sharedptr[FlannSearch[PointT]] ConstPtr;
+        # # cdef cppclass FlannIndexCreator
+        # #    virtual IndexPtr createIndex (MatrixConstPtr data)=0;
+        # # class KdTreeIndexCreator: public FlannIndexCreator
+        # cdef cppclass KdTreeIndexCreator:
+        # # KdTreeIndexCreator (unsigned int max_leaf_size=15)
+        # KdTreeIndexCreator (unsigned int)
+        # # virtual IndexPtr createIndex (MatrixConstPtr data);
+        # cdef FlannSearch (bool sorted = true, FlannIndexCreator* creator = new KdTreeIndexCreator());
+        # cdef void setEpsilon (double eps)
+        # cdef double getEpsilon ()
+        # cdef void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr& indices = IndicesConstPtr ());
+        # cdef int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        # cdef void nearestKSearch (const PointCloud& cloud, const std::vector<int>& indices, int k, 
+        #                           std::vector< std::vector<int> >& k_indices, std::vector< std::vector<float> >& k_sqr_distances) const;
+        # cdef int radiusSearch (const PointT& point, double radius, 
+        #                       std::vector<int> &k_indices, std::vector<float> &k_sqr_distances,
+        #                       unsigned int max_nn = 0) const;
+        # cdef void radiusSearch (const PointCloud& cloud, const std::vector<int>& indices, double radius, std::vector< std::vector<int> >& k_indices,
+        #                       vector[vector[float]] k_sqr_distances, unsigned int max_nn=0) const;
+        # cdef void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # cdef PointRepresentationConstPtr getPointRepresentation ()
+
+
+###
+
+cdef extern from "pcl/Search/kdtree.h" namespace "pcl::search":
+    cdef cppclass KdTree[PointT](Search[PointT]):
+        # KdTree()
+        KdTree (bool)
+        # public:
+        # ctypedef typename Search<PointT>::PointCloud PointCloud;
+        # ctypedef typename Search<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        
+        # ctypedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # using pcl::search::Search<PointT>::indices_;
+        # using pcl::search::Search<PointT>::input_;
+        # using pcl::search::Search<PointT>::getIndices;
+        # using pcl::search::Search<PointT>::getInputCloud;
+        # using pcl::search::Search<PointT>::nearestKSearch;
+        # using pcl::search::Search<PointT>::radiusSearch;
+        # using pcl::search::Search<PointT>::sorted_results_;
+        # typedef boost::shared_ptr<KdTree<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTree<PointT> > ConstPtr;
+        # typedef boost::shared_ptr<pcl::KdTreeFLANN<PointT> > KdTreeFLANNPtr;
+        # typedef boost::shared_ptr<const pcl::KdTreeFLANN<PointT> > KdTreeFLANNConstPtr;
+        
+        void setSortedResults (bool sorted_results)
+        
+        void setEpsilon (float eps)
+        
+        float getEpsilon ()
+        
+        # void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr& indices = IndicesConstPtr ())
+        
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        int radiusSearch (const PointT& point, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+
+
+###
+
+cdef extern from "pcl/Search/Octree.h" namespace "pcl::search":
+    cdef cppclass Octree[PointT](Search[PointT]):
+        # Octree (const double resolution)
+        Octree (double)
+        
+        # public:
+        # ctypedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # ctypedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # ctypedef boost::shared_ptr<pcl::octree::OctreePointCloudSearch<PointT, LeafTWrap, BranchTWrap> > Ptr;
+        # ctypedef boost::shared_ptr<const pcl::octree::OctreePointCloudSearch<PointT, LeafTWrap, BranchTWrap> > ConstPtr;
+        # Ptr tree_;
+        # using pcl::search::Search<PointT>::input_;
+        # using pcl::search::Search<PointT>::indices_;
+        # using pcl::search::Search<PointT>::sorted_results_;
+        
+        # void setInputCloud (const PointCloudConstPtr &cloud)
+        void setInputCloud (const shared_ptr[cpp.PointCloud[PointT]] &cloud)
+        
+        # void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr& indices)
+        # void setInputCloud (const shared_ptr[cpp.PointCloud[PointT]] &cloud, const IndicesConstPtr& indices)
+        
+        int nearestKSearch (const cpp.PointCloud[PointT] &cloud, int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        int nearestKSearch (int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # int radiusSearch ( const PointCloud &cloud,  int index,  double radius, std::vector<int> &k_indices,  std::vector<float> &k_sqr_distances,  unsigned int max_nn = 0) const
+        int radiusSearch ( const cpp.PointCloud[PointT] &cloud,  int index,  double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        # int radiusSearch (const PointT &p_q,  double radius,  std::vector<int> &k_indices, std::vector<float> &k_sqr_distances,  unsigned int max_nn = 0) const
+        int radiusSearch (const PointT &p_q,  double radius,  vector[int] &k_indices, vector[float] &k_sqr_distances,  unsigned int max_nn)
+        
+        # cdef int radiusSearch (int index, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn = 0) const
+        int radiusSearch (int index, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        # cdef void approxNearestSearch ( const PointCloudConstPtr &cloud, int query_index, int &result_index, float &sqr_distance)
+        void approxNearestSearch ( const shared_ptr[cpp.PointCloud[PointT]] &cloud, int query_index, int &result_index, float &sqr_distance)
+        
+        # cdef void approxNearestSearch ( const PointT &p_q, int &result_index, float &sqr_distance)
+        
+        # cdef void approxNearestSearch (int query_index, int &result_index, float &sqr_distance)
+
+
+###
+
+cdef extern from "pcl/Search/organized.h" namespace "pcl::search":
+    cdef cppclass OrganizedNeighbor[PointT](Search[PointT]):
+        OrganizedNeighbor()
+        # OrganizedNeighbor (bool sorted_results = false, float eps = 1e-4f, unsigned pyramid_level = 5)
+        # public:
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # ctypedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # ctypedef boost::shared_ptr<pcl::search::OrganizedNeighbor<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const pcl::search::OrganizedNeighbor<PointT> > ConstPtr;
+        # using pcl::search::Search<PointT>::indices_;
+        # using pcl::search::Search<PointT>::sorted_results_;
+        # using pcl::search::Search<PointT>::input_;
+        
+        # bool isValid () const
+        bool isValid ()
+        
+        # void computeCameraMatrix (Eigen::Matrix3f& camera_matrix) const;
+        # void computeCameraMatrix (eigen3.Matrix3f& camera_matrix)
+        
+        # void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        
+        # int radiusSearch (const PointT &p_q, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+        int radiusSearch (const PointT &p_q, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        void estimateProjectionMatrix ()
+        
+        int nearestKSearch ( const PointT &p_q, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # bool projectPoint (const PointT& p, pcl::PointXY& q) const;
+
+
+###
+
+# pcl_search.h
+###
+
+# search.h
+###
+
diff --git a/pcl/pcl_search_180.pxd b/pcl/pcl_search_180.pxd
new file mode 100644
index 0000000..271b0b3
--- /dev/null
+++ b/pcl/pcl_search_180.pxd
@@ -0,0 +1,396 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+# Base Interface
+# Search.h
+# namespace pcl
+# namespace search
+# template<typename PointT>
+# class Search
+cdef extern from "pcl/Search/Search.h" namespace "pcl::search":
+    Search[T]:
+        Search()
+        # Search (const string& name = "", bool sorted = false)
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<pcl::search::Search<PointT> > Ptr;
+        # typedef boost::shared_ptr<const pcl::search::Search<PointT> > ConstPtr;
+        # typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # typedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # /** \brief returns the search method name
+        string getName ()
+        
+        # /** \brief sets whether the results should be sorted (ascending in the distance) or not
+        #   * \param[in] sorted should be true if the results should be sorted by the distance in ascending order.
+        #   * Otherwise the results may be returned in any order.
+        void setSortedResults (bool sorted)
+        
+        # /** \brief Pass the input dataset that the search will be performed on.
+        #   * \param[in] cloud a const pointer to the PointCloud data
+        #   * \param[in] indices the point indices subset that is to be used from the cloud
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        
+        # /** \brief Get a pointer to the input point cloud dataset. */
+        # virtual PointCloudConstPtr getInputCloud () const
+        
+        # /** \brief Get a pointer to the vector of indices used. */
+        # virtual IndicesConstPtr getIndices () const
+        
+        # /** \brief Search for the k-nearest neighbors for the given query point.
+        #   * \param[in] point the given query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        # virtual int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const = 0;
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * This method accepts a different template parameter for the point type.
+        #   * \param[in] point the given query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        # template <typename PointTDiff>
+        # inline int nearestKSearchT (const PointTDiff &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        
+        # /** \brief Search for k-nearest neighbors for the given query point.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (const PointCloud &cloud, int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        # 
+        # /** \brief Search for k-nearest neighbors for the given query point (zero-copy).
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] index a \a valid index representing a \a valid query point in the dataset given
+        #   * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in
+        #   * the indices vector.
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points (must be resized to \a k a priori!)
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points (must be resized to \a k
+        #   * a priori!)
+        #   * \return number of neighbors found
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int nearestKSearch (int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances) const
+        # 
+        # /** \brief Search for the k-nearest neighbors for the given query point.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        # virtual void nearestKSearch (const PointCloud& cloud, vector[int]& indices, int k, vector[vector[int] ]& k_indices, std::vector< std::vector<float> >& k_sqr_distances) const
+        # 
+        # /** \brief Search for the k-nearest neighbors for the given query point. 
+        #   *  Use this method if the query points are of a different type than the points in the data set (e.g. PointXYZRGBA instead of PointXYZ).
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] k the number of neighbors to search for
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \note This method copies the input point cloud of type PointTDiff to a temporary cloud of type PointT and performs the batch search on the new cloud. You should prefer the single-point search if you don't use a search algorithm that accelerates batch NN search.
+        # template <typename PointTDiff> 
+        # void nearestKSearchT (const pcl::PointCloud<PointTDiff> &cloud, const std::vector<int>& indices, int k, std::vector< std::vector<int> > &k_indices, std::vector< std::vector<float> > &k_sqr_distances) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] point the given query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        # virtual int radiusSearch (const PointT& point, double radius, std::vector<int>& k_indices, std::vector<float>& k_sqr_distances, unsigned int max_nn = 0) const = 0;
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] point the given query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        # template <typename PointTDiff> 
+        # inline int radiusSearchT (const PointTDiff &point, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] index a \a valid index in \a cloud representing a \a valid (i.e., finite) query point
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (const PointCloud &cloud, int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius (zero-copy).
+        #   * \attention This method does not do any bounds checking for the input index
+        #   * (i.e., index >= cloud.points.size () || index < 0), and assumes valid (i.e., finite) data.
+        #   * \param[in] index a \a valid index representing a \a valid query point in the dataset given
+        #   * by \a setInputCloud. If indices were given in setInputCloud, index will be the position in
+        #   * the indices vector.
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \return number of neighbors found in radius
+        #   * \exception asserts in debug mode if the index is not between 0 and the maximum number of points
+        # virtual int radiusSearch (int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query point in a given radius.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices the indices in \a cloud. If indices is empty, neighbors will be searched for all points.
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        # virtual void radiusSearch (const PointCloud& cloud,
+        #               const std::vector<int>& indices,
+        #               double radius,
+        #               std::vector< std::vector<int> >& k_indices,
+        #               std::vector< std::vector<float> > &k_sqr_distances,
+        #               unsigned int max_nn = 0) const
+        # 
+        # /** \brief Search for all the nearest neighbors of the query points in a given radius.
+        #   * \param[in] cloud the point cloud data
+        #   * \param[in] indices a vector of point cloud indices to query for nearest neighbors
+        #   * \param[in] radius the radius of the sphere bounding all of p_q's neighbors
+        #   * \param[out] k_indices the resultant indices of the neighboring points, k_indices[i] corresponds to the neighbors of the query point i
+        #   * \param[out] k_sqr_distances the resultant squared distances to the neighboring points, k_sqr_distances[i] corresponds to the neighbors of the query point i
+        #   * \param[in] max_nn if given, bounds the maximum returned neighbors to this value. If \a max_nn is set to
+        #   * 0 or to a number higher than the number of points in the input cloud, all neighbors in \a radius will be
+        #   * returned.
+        #   * \note This method copies the input point cloud of type PointTDiff to a temporary cloud of type PointT and performs the batch search on the new cloud. You should prefer the single-point search if you don't use a search algorithm that accelerates batch NN search.
+        # template <typename PointTDiff> void
+        # radiusSearchT (const pcl::PointCloud<PointTDiff> &cloud,
+        #                const std::vector<int>& indices,
+        #                double radius,
+        #                std::vector< std::vector<int> > &k_indices,
+        #                std::vector< std::vector<float> > &k_sqr_distances,
+        #                unsigned int max_nn = 0) const
+
+
+###
+
+# template<typename PointT> void
+# Search<PointT>::sortResults (std::vector<int>& indices, std::vector<float>& distances) const
+# cdef extern from "pcl/Search/Search.h" namespace "pcl::search":
+#   cdef Search[T]::sortResults (std::vector<int>& indices, std::vector<float>& distances) const
+###
+
+# pcl_search target out
+cdef extern from "pcl/Search/flann_search.h" namespace "pcl":
+    cdef cppclass FlannSearch[T](Search[PointT]):
+        VoxelGrid()
+        
+        void setLeafSize (float, float, float)
+        void setInputCloud (shared_ptr[cpp.PointCloud[T]])
+        void filter(cpp.PointCloud[T] c)
+        
+        # # ctypedef typename Search<PointT>::PointCloud PointCloud;
+        # # ctypedef typename Search<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # ctypedef sharedptr[vector[int]] IndicesPtr;
+        # ctypedef sharedptr[vector[int]] IndicesConstPtr;
+        # # ctypedef flann::NNIndex[FlannDistance] Index;
+        # ctypedef sharedptr[flann::NNIndex[FlannDistance]] IndexPtr;
+        # ctypedef sharedptr[flann::Matrix[float]] MatrixPtr;
+        # ctypedef sharedptr[flann::Matrix[float]] MatrixConstPtr;
+        # # ctypedef pcl::PointRepresentation<PointT> PointRepresentation;
+        # //typedef boost::shared_ptr<PointRepresentation> PointRepresentationPtr;
+        # ctypedef sharedptr[PointRepresentation] PointRepresentationConstPtr;
+        # # using Search<PointT>::input_;
+        # # using Search<PointT>::indices_;
+        # # using Search<PointT>::sorted_results_;
+        
+        # public:
+        # ctypedef sharedptr[FlannSearch[PointT]] Ptr;
+        # ctypedef sharedptr[FlannSearch[PointT]] ConstPtr;
+        # # cdef cppclass FlannIndexCreator
+        # #    virtual IndexPtr createIndex (MatrixConstPtr data)=0;
+        # # class KdTreeIndexCreator: public FlannIndexCreator
+        # cdef cppclass KdTreeIndexCreator:
+        # # KdTreeIndexCreator (unsigned int max_leaf_size=15)
+        # KdTreeIndexCreator (unsigned int)
+        # # virtual IndexPtr createIndex (MatrixConstPtr data);
+        # cdef FlannSearch (bool sorted = true, FlannIndexCreator* creator = new KdTreeIndexCreator());
+        # cdef void setEpsilon (double eps)
+        # cdef double getEpsilon ()
+        # cdef void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr& indices = IndicesConstPtr ());
+        # cdef int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const;
+        # cdef void nearestKSearch (const PointCloud& cloud, const std::vector<int>& indices, int k, 
+        #                           std::vector< std::vector<int> >& k_indices, std::vector< std::vector<float> >& k_sqr_distances) const;
+        # cdef int radiusSearch (const PointT& point, double radius, 
+        #                       std::vector<int> &k_indices, std::vector<float> &k_sqr_distances,
+        #                       unsigned int max_nn = 0) const;
+        # cdef void radiusSearch (const PointCloud& cloud, const std::vector<int>& indices, double radius, std::vector< std::vector<int> >& k_indices,
+        #                       vector[vector[float]] k_sqr_distances, unsigned int max_nn=0) const;
+        # cdef void setPointRepresentation (const PointRepresentationConstPtr &point_representation)
+        # cdef PointRepresentationConstPtr getPointRepresentation ()
+
+
+###
+
+cdef extern from "pcl/Search/kdtree.h" namespace "pcl::search":
+    cdef cppclass KdTree[PointT](Search[PointT]):
+        # KdTree()
+        KdTree (bool)
+        # public:
+        # ctypedef typename Search<PointT>::PointCloud PointCloud;
+        # ctypedef typename Search<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        
+        # ctypedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # using pcl::search::Search<PointT>::indices_;
+        # using pcl::search::Search<PointT>::input_;
+        # using pcl::search::Search<PointT>::getIndices;
+        # using pcl::search::Search<PointT>::getInputCloud;
+        # using pcl::search::Search<PointT>::nearestKSearch;
+        # using pcl::search::Search<PointT>::radiusSearch;
+        # using pcl::search::Search<PointT>::sorted_results_;
+        # typedef boost::shared_ptr<KdTree<PointT> > Ptr;
+        # typedef boost::shared_ptr<const KdTree<PointT> > ConstPtr;
+        # typedef boost::shared_ptr<pcl::KdTreeFLANN<PointT> > KdTreeFLANNPtr;
+        # typedef boost::shared_ptr<const pcl::KdTreeFLANN<PointT> > KdTreeFLANNConstPtr;
+        
+        void setSortedResults (bool sorted_results)
+        
+        void setEpsilon (float eps)
+        
+        float getEpsilon ()
+        
+        # void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr& indices = IndicesConstPtr ())
+        
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        int radiusSearch (const PointT& point, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+
+
+###
+
+cdef extern from "pcl/Search/Octree.h" namespace "pcl::search":
+    cdef cppclass Octree[PointT](Search[PointT]):
+        # Octree (const double resolution)
+        Octree (double)
+        
+        # public:
+        # ctypedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+        # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # ctypedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # ctypedef boost::shared_ptr<pcl::octree::OctreePointCloudSearch<PointT, LeafTWrap, BranchTWrap> > Ptr;
+        # ctypedef boost::shared_ptr<const pcl::octree::OctreePointCloudSearch<PointT, LeafTWrap, BranchTWrap> > ConstPtr;
+        # Ptr tree_;
+        # using pcl::search::Search<PointT>::input_;
+        # using pcl::search::Search<PointT>::indices_;
+        # using pcl::search::Search<PointT>::sorted_results_;
+        
+        # void setInputCloud (const PointCloudConstPtr &cloud)
+        void setInputCloud (const shared_ptr[cpp.PointCloud[PointT]] &cloud)
+        
+        # void setInputCloud (const PointCloudConstPtr &cloud, const IndicesConstPtr& indices)
+        # void setInputCloud (const shared_ptr[cpp.PointCloud[PointT]] &cloud, const IndicesConstPtr& indices)
+        
+        int nearestKSearch (const cpp.PointCloud[PointT] &cloud, int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # int nearestKSearch (const PointT &point, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        int nearestKSearch (const PointT &point, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # int nearestKSearch (int index, int k, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances) const
+        int nearestKSearch (int index, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # int radiusSearch ( const PointCloud &cloud,  int index,  double radius, std::vector<int> &k_indices,  std::vector<float> &k_sqr_distances,  unsigned int max_nn = 0) const
+        int radiusSearch ( const cpp.PointCloud[PointT] &cloud,  int index,  double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        # int radiusSearch (const PointT &p_q,  double radius,  std::vector<int> &k_indices, std::vector<float> &k_sqr_distances,  unsigned int max_nn = 0) const
+        int radiusSearch (const PointT &p_q,  double radius,  vector[int] &k_indices, vector[float] &k_sqr_distances,  unsigned int max_nn)
+        
+        # cdef int radiusSearch (int index, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn = 0) const
+        int radiusSearch (int index, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        # cdef void approxNearestSearch ( const PointCloudConstPtr &cloud, int query_index, int &result_index, float &sqr_distance)
+        void approxNearestSearch ( const shared_ptr[cpp.PointCloud[PointT]] &cloud, int query_index, int &result_index, float &sqr_distance)
+        
+        # cdef void approxNearestSearch ( const PointT &p_q, int &result_index, float &sqr_distance)
+        
+        # cdef void approxNearestSearch (int query_index, int &result_index, float &sqr_distance)
+
+
+###
+
+cdef extern from "pcl/Search/organized.h" namespace "pcl::search":
+    cdef cppclass OrganizedNeighbor[PointT](Search[PointT]):
+        OrganizedNeighbor()
+        # OrganizedNeighbor (bool sorted_results = false, float eps = 1e-4f, unsigned pyramid_level = 5)
+        # public:
+        # ctypedef pcl::PointCloud<PointT> PointCloud;
+        # ctypedef boost::shared_ptr<PointCloud> PointCloudPtr;
+        # ctypedef boost::shared_ptr<const PointCloud> PointCloudConstPtr;
+        # ctypedef boost::shared_ptr<const std::vector<int> > IndicesConstPtr;
+        # ctypedef boost::shared_ptr<pcl::search::OrganizedNeighbor<PointT> > Ptr;
+        # ctypedef boost::shared_ptr<const pcl::search::OrganizedNeighbor<PointT> > ConstPtr;
+        # using pcl::search::Search<PointT>::indices_;
+        # using pcl::search::Search<PointT>::sorted_results_;
+        # using pcl::search::Search<PointT>::input_;
+        
+        # bool isValid () const
+        bool isValid ()
+        
+        # void computeCameraMatrix (Eigen::Matrix3f& camera_matrix) const;
+        # void computeCameraMatrix (eigen3.Matrix3f& camera_matrix)
+        
+        # void setInputCloud (const PointCloudConstPtr& cloud, const IndicesConstPtr &indices = IndicesConstPtr ())
+        
+        # int radiusSearch (const PointT &p_q, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn = 0) const;
+        int radiusSearch (const PointT &p_q, double radius, vector[int] &k_indices, vector[float] &k_sqr_distances, unsigned int max_nn)
+        
+        void estimateProjectionMatrix ()
+        
+        int nearestKSearch ( const PointT &p_q, int k, vector[int] &k_indices, vector[float] &k_sqr_distances)
+        
+        # bool projectPoint (const PointT& p, pcl::PointXY& q) const;
+
+
+###
+
+# pcl_search.h
+###
+
+# search.h
+###
+
diff --git a/pcl/pcl_segmentation.pxd b/pcl/pcl_segmentation.pxd
new file mode 100644
index 0000000..b2b31a3
--- /dev/null
+++ b/pcl/pcl_segmentation.pxd
@@ -0,0 +1,1588 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+from boost_shared_ptr cimport shared_ptr
+
+# main
+# cimport pcl_defs as cpp
+from pcl_defs cimport PointIndices
+from pcl_defs cimport ModelCoefficients
+from pcl_defs cimport PointCloud
+from pcl_defs cimport PointXYZ
+from pcl_defs cimport PointXYZI
+from pcl_defs cimport PointXYZRGB
+from pcl_defs cimport PointXYZRGBA
+from pcl_defs cimport Normal
+from pcl_defs cimport PCLBase
+from pcl_sample_consensus cimport SacModel
+cimport pcl_surface as pclsf
+cimport pcl_kdtree as pclkdt
+
+##
+
+from vector cimport vector as vector2
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+cdef extern from "pcl/segmentation/sac_segmentation.h" namespace "pcl":
+    cdef cppclass SACSegmentation[T](PCLBase[T]):
+        SACSegmentation()
+        void setModelType (SacModel)
+        # /** \brief Empty constructor. */
+        # SACSegmentation () :  model_ (), sac_ (), model_type_ (-1), method_type_ (0), 
+        #                       threshold_ (0), optimize_coefficients_ (true), 
+        #                       radius_min_ (-std::numeric_limits<double>::max()), radius_max_ (std::numeric_limits<double>::max()), samples_radius_ (0.0), eps_angle_ (0.0),
+        #                       axis_ (Eigen::Vector3f::Zero ()), max_iterations_ (50), probability_ (0.99)
+        # 
+        # /** \brief Get the type of SAC model used.
+        # inline int getModelType () const { return (model_type_); }
+        int getModelType ()
+        
+        # \brief Get a pointer to the SAC method used.
+        # inline SampleConsensusPtr getMethod () const { return (sac_); }
+        # 
+        # \brief Get a pointer to the SAC model used.
+        # inline SampleConsensusModelPtr getModel () const { return (model_); }
+        
+        void setMethodType (int)
+        # \brief Get the type of sample consensus method used.
+        # inline int getMethodType () const { return (method_type_); }
+        int getMethodType ()
+        
+        void setDistanceThreshold (float)
+        # \brief Get the distance to the model threshold.
+        # inline double getDistanceThreshold () const { return (threshold_); }
+        double getDistanceThreshold ()
+        
+        # use PCLBase class function
+        # void setInputCloud (shared_ptr[PointCloud[T]])
+        
+        void setMaxIterations (int)
+        # \brief Get maximum number of iterations before giving up.
+        # inline int getMaxIterations () const { return (max_iterations_); }
+        int getMaxIterations ()
+        
+        # \brief Set the probability of choosing at least one sample free from outliers.
+        # \param[in] probability the model fitting probability
+        # inline void setProbability (double probability) { probability_ = probability; }
+        void setProbability (double probability)
+        
+        # \brief Get the probability of choosing at least one sample free from outliers.
+        # inline double getProbability () const { return (probability_); }
+        double getProbability ()
+        
+        void setOptimizeCoefficients (bool)
+        
+        # \brief Get the coefficient refinement internal flag.
+        # inline bool getOptimizeCoefficients () const { return (optimize_coefficients_); }
+        bool getOptimizeCoefficients ()
+        
+        # \brief Set the minimum and maximum allowable radius limits for the model (applicable to models that estimate a radius)
+        # \param[in] min_radius the minimum radius model
+        # \param[in] max_radius the maximum radius model
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        void setRadiusLimits (const double &min_radius, const double &max_radius)
+        
+        # \brief Get the minimum and maximum allowable radius limits for the model as set by the user.
+        # \param[out] min_radius the resultant minimum radius model
+        # \param[out] max_radius the resultant maximum radius model
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        void getRadiusLimits (double &min_radius, double &max_radius)
+        
+        # \brief Set the maximum distance allowed when drawing random samples
+        # \param[in] radius the maximum distance (L2 norm)
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        # void setSamplesMaxDist (const double &radius, SearchPtr search)
+        
+        # \brief Get maximum distance allowed when drawing random samples
+        # \param[out] radius the maximum distance (L2 norm)
+        # inline void getSamplesMaxDist (double &radius)
+        void getSamplesMaxDist (double &radius)
+        
+        # \brief Set the axis along which we need to search for a model perpendicular to.
+        # \param[in] ax the axis along which we need to search for a model perpendicular to
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # void setAxis (const eigen3.Vector3f &ax)
+        
+        # \brief Get the axis along which we need to search for a model perpendicular to.
+        # inline Eigen::Vector3f getAxis () const { return (axis_); }
+        # eigen3.Vector3f getAxis ()
+        
+        # \brief Set the angle epsilon (delta) threshold.
+        # \param[in] ea the maximum allowed difference between the model normal and the given axis in radians.
+        # inline void setEpsAngle (double ea) { eps_angle_ = ea; }
+        void setEpsAngle (double ea)
+        
+        # /** \brief Get the epsilon (delta) model angle threshold in radians. */
+        # inline double getEpsAngle () const { return (eps_angle_); }
+        double getEpsAngle ()
+
+        void segment (PointIndices, ModelCoefficients)
+
+
+ctypedef SACSegmentation[PointXYZ] SACSegmentation_t
+ctypedef SACSegmentation[PointXYZI] SACSegmentation_PointXYZI_t
+ctypedef SACSegmentation[PointXYZRGB] SACSegmentation_PointXYZRGB_t
+ctypedef SACSegmentation[PointXYZRGBA] SACSegmentation_PointXYZRGBA_t
+###
+
+# comparator.h
+# namespace pcl
+# brief Comparator is the base class for comparators that compare two points given some function.
+# Currently intended for use with OrganizedConnectedComponentSegmentation
+# author Alex Trevor
+# template <typename PointT> class Comparator
+cdef extern from "pcl/segmentation/comparator.h" namespace "pcl":
+    cdef cppclass Comparator[T]:
+        Comparator()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<Comparator<PointT> > Ptr;
+        # typedef boost::shared_ptr<const Comparator<PointT> > ConstPtr;
+        # 
+        # /** \brief Set the input cloud for the comparator.
+        #   * \param[in] cloud the point cloud this comparator will operate on
+        #   */
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # 
+        # /** \brief Get the input cloud this comparator operates on. */
+        # virtual PointCloudConstPtr getInputCloud () const
+        # 
+        # /** \brief Compares the two points in the input cloud designated by these two indices.
+        #   * This is pure virtual and must be implemented by subclasses with some comparison function.
+        #   * \param[in] idx1 the index of the first point.
+        #   * \param[in] idx2 the index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const = 0;
+
+
+###
+
+# plane_coefficient_comparator.h
+# namespace pcl
+# brief PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation.
+# In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+# author Alex Trevor
+# template<typename PointT, typename PointNT> class PlaneCoefficientComparator: public Comparator<PointT>
+cdef extern from "pcl/segmentation/plane_coefficient_comparator.h" namespace "pcl":
+    cdef cppclass PlaneCoefficientComparator[T, NT](Comparator[T]):
+        PlaneCoefficientComparator()
+        # PlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<PlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const PlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        
+        # /** \brief Provide a pointer to the input normals.
+        #   * \param[in] normals the input normal cloud
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # void setPlaneCoeffD (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # void setPlaneCoeffD (std::vector<float>& plane_coeff_d)
+        
+        # /** \brief Get a pointer to the vector of the d-coefficient of the planes' hessian normal form. */
+        # const std::vector<float>& getPlaneCoeffD () const
+        
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #   * \param[in] angular_threshold the tolerance in radians
+        # virtual void setAngularThreshold (float angular_threshold)
+        
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        float getAngularThreshold ()
+        
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters (at 1m)
+        #   * \param[in] depth_dependent whether to scale the threshold based on range from the sensor (default: false)
+        # void setDistanceThreshold (float distance_threshold, bool depth_dependent = false)
+        void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        float getDistanceThreshold ()
+        
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+### Inheritance class ###
+
+# \brief @b SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and
+#  models that require the use of surface normals for estimation.
+# \ingroup segmentation
+# cdef cppclass SACSegmentationFromNormals[T, N]:
+cdef extern from "pcl/segmentation/sac_segmentation.h" namespace "pcl":
+    cdef cppclass SACSegmentationFromNormals[T, N](SACSegmentation[T]):
+        SACSegmentationFromNormals()
+        
+        # /** \brief Empty constructor. */
+        # SACSegmentationFromNormals () : 
+        #   normals_ (), 
+        #   distance_weight_ (0.1), 
+        #   distance_from_origin_ (0), 
+        #   min_angle_ (), 
+        #   max_angle_ ()
+        # {};
+        
+        # use PCLBase class function
+        # void setInputCloud (shared_ptr[PointCloud[T]])
+        
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        #   * the XYZ dataset.
+        #   * \param[in] normals the const boost shared pointer to a PointCloud message
+        #   */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) { normals_ = normals; }
+        # void setInputNormals (const PointCloudNConstPtr &normals)
+        void setInputNormals (shared_ptr[PointCloud[N]])
+        
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals () const { return (normals_); }
+        # PointCloudNConstPtr getInputNormals ()
+        
+        # /** \brief Set the relative weight (between 0 and 1) to give to the angular 
+        #   * distance (0 to pi/2) between point normals and the plane normal.
+        #   * \param[in] distance_weight the distance/angular weight
+        #   */
+        # inline void setNormalDistanceWeight (double distance_weight) { distance_weight_ = distance_weight; }
+        void setNormalDistanceWeight (double distance_weight)
+        
+        # /** \brief Get the relative weight (between 0 and 1) to give to the angular distance (0 to pi/2) between point
+        #   * normals and the plane normal. */
+        # inline double getNormalDistanceWeight () const { return (distance_weight_); }
+        double getNormalDistanceWeight ()
+        
+        # /** \brief Set the minimum opning angle for a cone model.
+        #   * \param oa the opening angle which we need minumum to validate a cone model.
+        #   */
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        
+        # /** \brief Get the opening angle which we need minumum to validate a cone model. */
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle)
+        void getMinMaxOpeningAngle (double &min_angle, double &max_angle)
+        
+        # /** \brief Set the distance we expect a plane model to be from the origin
+        #   * \param[in] d distance from the template plane modl to the origin
+        #   */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        void setDistanceFromOrigin (const double d)
+        
+        # /** \brief Get the distance of a plane model from the origin. */
+        # inline double getDistanceFromOrigin () const { return (distance_from_origin_); }
+        double getDistanceFromOrigin ()
+
+
+ctypedef SACSegmentationFromNormals[PointXYZ, Normal] SACSegmentationFromNormals_t
+ctypedef SACSegmentationFromNormals[PointXYZI, Normal] SACSegmentationFromNormals_PointXYZI_t
+ctypedef SACSegmentationFromNormals[PointXYZRGB, Normal] SACSegmentationFromNormals_PointXYZRGB_t
+ctypedef SACSegmentationFromNormals[PointXYZRGBA, Normal] SACSegmentationFromNormals_PointXYZRGBA_t
+###
+
+
+# edge_aware_plane_comparator.h
+# namespace pcl
+# /** \brief EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Stefan Holzer, Alex Trevor
+#   */
+# template<typename PointT, typename PointNT>
+# class EdgeAwarePlaneComparator: public PlaneCoefficientComparator<PointT, PointNT>
+cdef extern from "pcl/segmentation/edge_aware_plane_comparator.h" namespace "pcl":
+    cdef cppclass EdgeAwarePlaneComparator[T, NT](PlaneCoefficientComparator[T, NT]):
+        EdgeAwarePlaneComparator()
+        # EdgeAwarePlaneComparator (const float *distance_map)
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<EdgeAwarePlaneComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const EdgeAwarePlaneComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Set a distance map to use. For an example of a valid distance map see 
+        #   * \ref OrganizedIntegralImageNormalEstimation
+        #   * \param[in] distance_map the distance map to use
+        #   */
+        # inline void setDistanceMap (const float *distance_map)
+        # /** \brief Return the distance map used. */
+        # const float* getDistanceMap () const
+
+
+###
+
+# euclidean_cluster_comparator.h
+# namespace pcl
+# /** \brief EuclideanClusterComparator is a comparator used for finding clusters supported by planar surfaces.
+#   * This needs to be run as a second pass after extracting planar surfaces, using MultiPlaneSegmentation for example.
+#   * \author Alex Trevor
+# template<typename PointT, typename PointNT, typename PointLT>
+# class EuclideanClusterComparator: public Comparator<PointT>
+cdef extern from "pcl/segmentation/euclidean_cluster_comparator.h" namespace "pcl":
+    cdef cppclass EuclideanClusterComparator[T, NT, LT](Comparator[T]):
+        EuclideanClusterComparator()
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # typedef boost::shared_ptr<EuclideanClusterComparator<PointT, PointNT, PointLT> > Ptr;
+        # typedef boost::shared_ptr<const EuclideanClusterComparator<PointT, PointNT, PointLT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        
+        # /** \brief Provide a pointer to the input normals.
+        #   * \param[in] normals the input normal cloud
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        void setInputNormals (const shared_ptr[PointCloud[NT]] &normals)
+        
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        const shared_ptr[PointCloud[NT]] getInputNormals ()
+        
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #   * \param[in] angular_threshold the tolerance in radians
+        # virtual inline void setAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        float getAngularThreshold ()
+        
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters
+        # inline void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        float getDistanceThreshold ()
+        
+        # /** \brief Set label cloud
+        #   * \param[in] labels The label cloud
+        # void setLabels (PointCloudLPtr& labels)
+        void setLabels (shared_ptr[PointCloud[LT]] &labels)
+        
+        # 
+        # /** \brief Set labels in the label cloud to exclude.
+        #   * \param exclude_labels a vector of bools corresponding to whether or not a given label should be considered
+        # void setExcludeLabels (std::vector<bool>& exclude_labels)
+        void setExcludeLabels (vector[bool]& exclude_labels)
+        
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        # virtual bool compare (int idx1, int idx2) const
+
+
+ctypedef EuclideanClusterComparator[PointXYZ, Normal, PointXYZ] EuclideanClusterComparator_t
+ctypedef EuclideanClusterComparator[PointXYZI, Normal, PointXYZ] EuclideanClusterComparator_PointXYZI_t
+ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t
+ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGBA_Ptr_t
+###
+
+# euclidean_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Alex Trevor
+# template<typename PointT, typename PointNT>
+# class EuclideanPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+cdef extern from "pcl/segmentation/euclidean_plane_coefficient_comparator.h" namespace "pcl":
+    cdef cppclass EuclideanPlaneCoefficientComparator[T, NT](PlaneCoefficientComparator[T, NT]):
+        EuclideanPlaneCoefficientComparator()
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<EuclideanPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const EuclideanPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Compare two neighboring points, by using normal information, and euclidean distance information.
+        #   * \param[in] idx1 The index of the first point.
+        #   * \param[in] idx2 The index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# extract_clusters.h
+# namespace pcl
+# brief Decompose a region of space into clusters based on the Euclidean distance between points
+# param cloud the point cloud message
+# param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+# note the tree has to be created as a spatial locator on \a cloud
+# param tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+# param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+# param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+# param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+# ingroup segmentation
+# template <typename PointT> void extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const boost::shared_ptr<search::Search<PointT> > &tree, 
+#       float tolerance, std::vector<PointIndices> &clusters, 
+#       unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ());
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#   * \param cloud the point cloud message
+#   * \param indices a list of point indices to use from \a cloud
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud and \a indices
+#   * \param tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> void 
+# extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const std::vector<int> &indices, 
+#       const boost::shared_ptr<search::Search<PointT> > &tree, float tolerance, std::vector<PointIndices> &clusters, 
+#       unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ());
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the euclidean distance between points, and the normal
+#   * angular deviation
+#   * \param cloud the point cloud message
+#   * \param normals the point cloud message containing normal information
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param eps_angle the maximum allowed difference between normals in radians for cluster/region growing
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT, typename Normal> void 
+# extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const PointCloud<Normal> &normals, 
+#       float tolerance, const boost::shared_ptr<KdTree<PointT> > &tree, 
+#       std::vector<PointIndices> &clusters, double eps_angle, 
+#       unsigned int min_pts_per_cluster = 1, 
+#       unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ())
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the euclidean distance between points, and the normal
+#   * angular deviation
+#   * \param cloud the point cloud message
+#   * \param normals the point cloud message containing normal information
+#   * \param indices a list of point indices to use from \a cloud
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as PointIndices)
+#   * \param eps_angle the maximum allowed difference between normals in degrees for cluster/region growing
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT, typename Normal> 
+# void extractEuclideanClusters (
+#     const PointCloud<PointT> &cloud, const PointCloud<Normal> &normals, 
+#     const std::vector<int> &indices, const boost::shared_ptr<KdTree<PointT> > &tree, 
+#     float tolerance, std::vector<PointIndices> &clusters, double eps_angle, 
+#     unsigned int min_pts_per_cluster = 1, 
+#     unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ())
+###
+
+# extract_clusters.h
+# namespace pcl
+# EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense.
+# author Radu Bogdan Rusu
+# ingroup segmentation
+# template <typename PointT>
+# class EuclideanClusterExtraction: public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_clusters.h" namespace "pcl":
+    cdef cppclass EuclideanClusterExtraction[T](PCLBase[T]):
+        EuclideanClusterExtraction()
+        # public:
+        # EuclideanClusterExtraction () : tree_ (), 
+        #                                 cluster_tolerance_ (0),
+        #                                 min_pts_per_cluster_ (1), 
+        #                                 max_pts_per_cluster_ (std::numeric_limits<int>::max ())
+        
+        # brief Provide a pointer to the search object.
+        # param[in] tree a pointer to the spatial search object.
+        # inline void setSearchMethod (const KdTreePtr &tree) 
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # brief Get a pointer to the search method used. 
+        # @todo fix this for a generic search tree
+        # inline KdTreePtr getSearchMethod () const 
+        pclkdt.KdTreePtr_t getSearchMethod ()
+        
+        # brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+        # param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+        # inline void setClusterTolerance (double tolerance) 
+        void setClusterTolerance (double tolerance) 
+        
+        # brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space.
+        # inline double getClusterTolerance () const 
+        double getClusterTolerance ()
+        
+        # brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # param[in] min_cluster_size the minimum cluster size
+        # inline void setMinClusterSize (int min_cluster_size) 
+        void setMinClusterSize (int min_cluster_size) 
+        
+        # brief Get the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # inline int getMinClusterSize () const 
+        int getMinClusterSize ()
+        
+        # brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # param[in] max_cluster_size the maximum cluster size
+        # inline void setMaxClusterSize (int max_cluster_size) 
+        void setMaxClusterSize (int max_cluster_size) 
+        
+        # brief Get the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # inline int getMaxClusterSize () const 
+        int getMaxClusterSize ()
+        
+        # brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        # param[out] clusters the resultant point clusters
+        # void extract (std::vector<PointIndices> &clusters);
+        void extract (vector[PointIndices] &clusters)
+
+
+ctypedef EuclideanClusterExtraction[PointXYZ] EuclideanClusterExtraction_t
+ctypedef EuclideanClusterExtraction[PointXYZI] EuclideanClusterExtraction_PointXYZI_t
+ctypedef EuclideanClusterExtraction[PointXYZRGB] EuclideanClusterExtraction_PointXYZRGB_t
+ctypedef EuclideanClusterExtraction[PointXYZRGBA] EuclideanClusterExtraction_PointXYZRGBA_t
+###
+
+
+# extract_labeled_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#   * \param[in] cloud the point cloud message
+#   * \param[in] tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param[in] tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#   * \param[out] labeled_clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param[in] min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param[in] max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \param[in] max_label
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> void 
+# extractLabeledEuclideanClusters (
+#     const PointCloud<PointT> &cloud, const boost::shared_ptr<search::Search<PointT> > &tree, 
+#     float tolerance, std::vector<std::vector<PointIndices> > &labeled_clusters, 
+#     unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) (), 
+#     unsigned int max_label = (std::numeric_limits<int>::max));
+
+
+# extract_labeled_clusters.h
+# namespace pcl
+# brief @b LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info.
+# author Koen Buys
+# ingroup segmentation
+# template <typename PointT>
+# class LabeledEuclideanClusterExtraction: public PCLBase<PointT>
+        # typedef PCLBase<PointT> BasePCLBase;
+        # 
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::search::Search<PointT> KdTree;
+        # typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # LabeledEuclideanClusterExtraction () : 
+        #   tree_ (), 
+        #   cluster_tolerance_ (0),
+        #   min_pts_per_cluster_ (1), 
+        #   max_pts_per_cluster_ (std::numeric_limits<int>::max ()),
+        #   max_label_ (std::numeric_limits<int>::max ())
+        # {};
+        # 
+        # /** \brief Provide a pointer to the search object.
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   */
+        # inline void setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+        # 
+        # /** \brief Get a pointer to the search method used. */
+        # inline KdTreePtr getSearchMethod () const { return (tree_); }
+        # 
+        # /** \brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+        #   * \param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+        #   */
+        # inline void setClusterTolerance (double tolerance) { cluster_tolerance_ = tolerance; }
+        # 
+        # /** \brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space. */
+        # inline double getClusterTolerance () const { return (cluster_tolerance_); }
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        #   * \param[in] min_cluster_size the minimum cluster size
+        #   */
+        # inline void setMinClusterSize (int min_cluster_size) { min_pts_per_cluster_ = min_cluster_size; }
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # inline int getMinClusterSize () const { return (min_pts_per_cluster_); }
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        #   * \param[in] max_cluster_size the maximum cluster size
+        #   */
+        # inline void setMaxClusterSize (int max_cluster_size) { max_pts_per_cluster_ = max_cluster_size; }
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # inline int getMaxClusterSize () const { return (max_pts_per_cluster_); }
+        # 
+        # /** \brief Set the maximum number of labels in the cloud.
+        #   * \param[in] max_label the maximum
+        #   */
+        # inline void setMaxLabels (unsigned int max_label) { max_label_ = max_label; }
+        # 
+        # /** \brief Get the maximum number of labels */
+        # inline unsigned int getMaxLabels () const { return (max_label_); }
+        # 
+        # /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        #   * \param[out] labeled_clusters the resultant point clusters
+        #   */
+        # void extract (std::vector<std::vector<PointIndices> > &labeled_clusters);
+        # 
+        # protected:
+        #     // Members derived from the base class
+        #     using BasePCLBase::input_;
+        #     using BasePCLBase::indices_;
+        #     using BasePCLBase::initCompute;
+        #     using BasePCLBase::deinitCompute;
+        # 
+        # /** \brief A pointer to the spatial search object. */
+        # KdTreePtr tree_;
+        # /** \brief The spatial cluster tolerance as a measure in the L2 Euclidean space. */
+        # double cluster_tolerance_;
+        # /** \brief The minimum number of points that a cluster needs to contain in order to be considered valid (default = 1). */
+        # int min_pts_per_cluster_;
+        # /** \brief The maximum number of points that a cluster needs to contain in order to be considered valid (default = MAXINT). */
+        # int max_pts_per_cluster_;
+        # /** \brief The maximum number of labels we can find in this pointcloud (default = MAXINT)*/
+        # unsigned int max_label_;
+        # /** \brief Class getName method. */
+        # virtual std::string getClassName () const { return ("LabeledEuclideanClusterExtraction"); }
+        # 
+
+        #   brief Sort clusters method (for std::sort). 
+        #   ingroup segmentation
+        #   inline bool compareLabeledPointClusters (const pcl::PointIndices &a, const pcl::PointIndices &b)
+        #   {
+        #     return (a.indices.size () < b.indices.size ());
+        #   }
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief General purpose method for checking if a 3D point is inside or
+#   * outside a given 2D polygon. 
+#   * \note this method accepts any general 3D point that is projected onto the
+#   * 2D polygon, but performs an internal XY projection of both the polygon and the point. 
+#   * \param point a 3D point projected onto the same plane as the polygon
+#   * \param polygon a polygon
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> bool isPointIn2DPolygon (const PointT &point, const pcl::PointCloud<PointT> &polygon);
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief Check if a 2d point (X and Y coordinates considered only!) is
+#   * inside or outside a given polygon. This method assumes that both the point
+#   * and the polygon are projected onto the XY plane.
+#   *
+#   * \note (This is highly optimized code taken from http://www.visibone.com/inpoly/)
+#   *       Copyright (c) 1995-1996 Galacticomm, Inc.  Freeware source code.
+#   * \param point a 3D point projected onto the same plane as the polygon
+#   * \param polygon a polygon
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> bool 
+# isXYPointIn2DXYPolygon (const PointT &point, const pcl::PointCloud<PointT> &polygon);
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief @b ExtractPolygonalPrismData uses a set of point indices that
+#   * represent a planar model, and together with a given height, generates a 3D
+#   * polygonal prism. The polygonal prism is then used to segment all points
+#   * lying inside it.
+#   * An example of its usage is to extract the data lying within a set of 3D
+#   * boundaries (e.g., objects supported by a plane).
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class ExtractPolygonalPrismData : public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_polygonal_prism_data.h" namespace "pcl":
+    cdef cppclass ExtractPolygonalPrismData[T](PCLBase[T]):
+        ExtractPolygonalPrismData()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # brief Empty constructor.
+        # ExtractPolygonalPrismData () : planar_hull_ (), min_pts_hull_ (3), 
+        #                                height_limit_min_ (0), height_limit_max_ (FLT_MAX),
+        #                                vpx_ (0), vpy_ (0), vpz_ (0)
+        # {};
+        # 
+        # brief Provide a pointer to the input planar hull dataset.
+        # param[in] hull the input planar hull dataset
+        # inline void setInputPlanarHull (const PointCloudConstPtr &hull) { planar_hull_ = hull; }
+        # 
+        # brief Get a pointer the input planar hull dataset.
+        # inline PointCloudConstPtr getInputPlanarHull () const { return (planar_hull_); }
+        # 
+        # brief Set the height limits. All points having distances to the
+        # model outside this interval will be discarded.
+        # param[in] height_min the minimum allowed distance to the plane model value
+        # param[in] height_max the maximum allowed distance to the plane model value
+        # inline void setHeightLimits (double height_min, double height_max)
+        # 
+        # brief Get the height limits (min/max) as set by the user. The
+        # default values are -FLT_MAX, FLT_MAX. 
+        # param[out] height_min the resultant min height limit
+        # param[out] height_max the resultant max height limit
+        # inline void getHeightLimits (double &height_min, double &height_max) const
+        # 
+        # brief Set the viewpoint.
+        # param[in] vpx the X coordinate of the viewpoint
+        # param[in] vpy the Y coordinate of the viewpoint
+        # param[in] vpz the Z coordinate of the viewpoint
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # brief Get the viewpoint.
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz) const
+        # 
+        # /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        #   * \param[out] output the resultant point indices that support the model found (inliers)
+        # void segment (PointIndices &output);
+        # 
+        # protected:
+        # brief A pointer to the input planar hull dataset.
+        # PointCloudConstPtr planar_hull_;
+        # 
+        # brief The minimum number of points needed on the convex hull.
+        # int min_pts_hull_;
+        # 
+        # brief The minimum allowed height (distance to the model) a point
+        # will be considered from. 
+        # double height_limit_min_;
+        # 
+        # brief The maximum allowed height (distance to the model) a point will be considered from. 
+        # double height_limit_max_;
+        # 
+        # brief Values describing the data acquisition viewpoint. Default: 0,0,0.
+        # float vpx_, vpy_, vpz_;
+        # 
+        # brief Class getName method.
+        # virtual std::string getClassName () const { return ("ExtractPolygonalPrismData"); }
+
+
+###
+
+# organized_connected_component_segmentation.h
+# namespace pcl
+# /** \brief OrganizedConnectedComponentSegmentation allows connected
+#   * components to be found within organized point cloud data, given a
+#   * comparison function.  Given an input cloud and a comparator, it will
+#   * output a PointCloud of labels, giving each connected component a unique
+#   * id, along with a vector of PointIndices corresponding to each component.
+#   * See OrganizedMultiPlaneSegmentation for an example application.
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template <typename PointT, typename PointLT>
+# class OrganizedConnectedComponentSegmentation : public PCLBase<PointT>
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::indices_;
+#     using PCLBase<PointT>::initCompute;
+#     using PCLBase<PointT>::deinitCompute;
+# 
+#     public:
+#       typedef typename pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+# 
+#       typedef typename pcl::Comparator<PointT> Comparator;
+#       typedef typename Comparator::Ptr ComparatorPtr;
+#       typedef typename Comparator::ConstPtr ComparatorConstPtr;
+#       
+#       /** \brief Constructor for OrganizedConnectedComponentSegmentation
+#         * \param[in] compare A pointer to the comparator to be used for segmentation.  Must be an instance of pcl::Comparator.
+#         */
+#       OrganizedConnectedComponentSegmentation (const ComparatorConstPtr& compare)
+#         : compare_ (compare)
+#       {
+#       }
+# 
+#       /** \brief Destructor for OrganizedConnectedComponentSegmentation. */
+#       virtual
+#       ~OrganizedConnectedComponentSegmentation ()
+#       {
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for segmentation.
+#         * \param[in] compare the comparator
+#         */
+#       void
+#       setComparator (const ComparatorConstPtr& compare)
+#       {
+#         compare_ = compare;
+#       }
+#       
+#       /** \brief Get the comparator.*/
+#       ComparatorConstPtr
+#       getComparator () const { return (compare_); }
+# 
+#       /** \brief Perform the connected component segmentation.
+#         * \param[out] labels a PointCloud of labels: each connected component will have a unique id.
+#         * \param[out] label_indices a vector of PointIndices corresponding to each label / component id.
+#         */
+#       void
+#       segment (pcl::PointCloud<PointLT>& labels, std::vector<pcl::PointIndices>& label_indices) const;
+#       
+#       /** \brief Find the boundary points / contour of a connected component
+#         * \param[in] start_idx the first (lowest) index of the connected component for which a boundary shoudl be returned
+#         * \param[in] labels the Label cloud produced by segmentation
+#         * \param[out] boundary_indices the indices of the boundary points for the label corresponding to start_idx
+#         */
+#       static void
+#       findLabeledRegionBoundary (int start_idx, PointCloudLPtr labels, pcl::PointIndices& boundary_indices);      
+#       
+# 
+#     protected:
+#       ComparatorConstPtr compare_;
+#       
+#       inline unsigned
+#       findRoot (const std::vector<unsigned>& runs, unsigned index) const
+#       {
+#         register unsigned idx = index;
+#         while (runs[idx] != idx)
+#           idx = runs[idx];
+# 
+#         return (idx);
+#       }
+###
+
+# organized_multi_plane_segmentation.h
+# namespace pcl
+# /** \brief OrganizedMultiPlaneSegmentation finds all planes present in the
+#   * input cloud, and outputs a vector of plane equations, as well as a vector
+#   * of point clouds corresponding to the inliers of each detected plane.  Only
+#   * planes with more than min_inliers points are detected.
+#   * Templated on point type, normal type, and label type
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class OrganizedMultiPlaneSegmentation : public PCLBase<PointT>
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::indices_;
+#     using PCLBase<PointT>::initCompute;
+#     using PCLBase<PointT>::deinitCompute;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+# 
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+# 
+#       typedef typename pcl::PlaneCoefficientComparator<PointT, PointNT> PlaneComparator;
+#       typedef typename PlaneComparator::Ptr PlaneComparatorPtr;
+#       typedef typename PlaneComparator::ConstPtr PlaneComparatorConstPtr;
+# 
+#       typedef typename pcl::PlaneRefinementComparator<PointT, PointNT, PointLT> PlaneRefinementComparator;
+#       typedef typename PlaneRefinementComparator::Ptr PlaneRefinementComparatorPtr;
+#       typedef typename PlaneRefinementComparator::ConstPtr PlaneRefinementComparatorConstPtr;
+# 
+#       /** \brief Constructor for OrganizedMultiPlaneSegmentation. */
+#       OrganizedMultiPlaneSegmentation () :
+#         normals_ (), 
+#         min_inliers_ (1000), 
+#         angular_threshold_ (pcl::deg2rad (3.0)), 
+#         distance_threshold_ (0.02),
+#         maximum_curvature_ (0.001),
+#         project_points_ (false), 
+#         compare_ (new PlaneComparator ()), refinement_compare_ (new PlaneRefinementComparator ())
+#       {
+#       }
+# 
+#       /** \brief Destructor for OrganizedMultiPlaneSegmentation. */
+#       virtual
+#       ~OrganizedMultiPlaneSegmentation ()
+#       {
+#       }
+# 
+#       /** \brief Provide a pointer to the input normals.
+#         * \param[in] normals the input normal cloud
+#         */
+#       inline void
+#       setInputNormals (const PointCloudNConstPtr &normals) 
+#       {
+#         normals_ = normals;
+#       }
+# 
+#       /** \brief Get the input normals. */
+#       inline PointCloudNConstPtr
+#       getInputNormals () const
+#       {
+#         return (normals_);
+#       }
+# 
+#       /** \brief Set the minimum number of inliers required for a plane
+#         * \param[in] min_inliers the minimum number of inliers required per plane
+#         */
+#       inline void
+#       setMinInliers (unsigned min_inliers)
+#       {
+#         min_inliers_ = min_inliers;
+#       }
+# 
+#       /** \brief Get the minimum number of inliers required per plane. */
+#       inline unsigned
+#       getMinInliers () const
+#       {
+#         return (min_inliers_);
+#       }
+# 
+#       /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+#         * \param[in] angular_threshold the tolerance in radians
+#         */
+#       inline void
+#       setAngularThreshold (double angular_threshold)
+#       {
+#         angular_threshold_ = angular_threshold;
+#       }
+# 
+#       /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+#       inline double
+#       getAngularThreshold () const
+#       {
+#         return (angular_threshold_);
+#       }
+# 
+#       /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+#         * \param[in] distance_threshold the tolerance in meters
+#         */
+#       inline void
+#       setDistanceThreshold (double distance_threshold)
+#       {
+#         distance_threshold_ = distance_threshold;
+#       }
+# 
+#       /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+#       inline double
+#       getDistanceThreshold () const
+#       {
+#         return (distance_threshold_);
+#       }
+# 
+#       /** \brief Set the maximum curvature allowed for a planar region.
+#         * \param[in] maximum_curvature the maximum curvature
+#         */
+#       inline void
+#       setMaximumCurvature (double maximum_curvature)
+#       {
+#         maximum_curvature_ = maximum_curvature;
+#       }
+# 
+#       /** \brief Get the maximum curvature allowed for a planar region. */
+#       inline double
+#       getMaximumCurvature () const
+#       {
+#         return (maximum_curvature_);
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for segmentation.
+#         * \param[in] compare A pointer to the comparator to be used for segmentation.
+#         */
+#       void
+#       setComparator (const PlaneComparatorPtr& compare)
+#       {
+#         compare_ = compare;
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for refinement.
+#         * \param[in] compare A pointer to the comparator to be used for refinement.
+#         */
+#       void
+#       setRefinementComparator (const PlaneRefinementComparatorPtr& compare)
+#       {
+#         refinement_compare_ = compare;
+#       }
+# 
+#       /** \brief Set whether or not to project boundary points to the plane, or leave them in the original 3D space.
+#         * \param[in] project_points true if points should be projected, false if not.
+#         */
+#       void
+#       setProjectPoints (bool project_points)
+#       {
+#         project_points_ = project_points;
+#       }
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+#         * \param[out] inlier_indices a vector of inliers for each detected plane
+#         * \param[out] centroids a vector of centroids for each plane
+#         * \param[out] covariances a vector of covariance matricies for the inliers of each plane
+#         * \param[out] labels a point cloud for the connected component labels of each pixel
+#         * \param[out] label_indices a vector of PointIndices for each labeled component
+#         */
+#       void
+#       segment (std::vector<ModelCoefficients>& model_coefficients, 
+#                std::vector<PointIndices>& inlier_indices,
+#                std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+#                std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+#                pcl::PointCloud<PointLT>& labels, 
+#                std::vector<pcl::PointIndices>& label_indices);
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+#         * \param[out] inlier_indices a vector of inliers for each detected plane
+#         */
+#       void
+#       segment (std::vector<ModelCoefficients>& model_coefficients, 
+#                std::vector<PointIndices>& inlier_indices);
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] regions a list of resultant planar polygonal regions
+#         */
+#       void
+#       segment (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+#       
+#       /** \brief Perform a segmentation, as well as an additional refinement step.  This helps with including points whose normals may not match neighboring points well, but may match the planar model well.
+#         * \param[out] regions A list of regions generated by segmentation and refinement.
+#         */
+#       void
+#       segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+# 
+#       /** \brief Perform a segmentation, as well as additional refinement step.  Returns intermediate data structures for use in
+#         * subsequent processing.
+#         * \param[out] regions A vector of PlanarRegions generated by segmentation
+#         * \param[out] model_coefficients A vector of model coefficients for each segmented plane
+#         * \param[out] inlier_indices A vector of PointIndices, indicating the inliers to each segmented plane
+#         * \param[out] labels A PointCloud<PointLT> corresponding to the resulting segmentation.
+#         * \param[out] label_indices A vector of PointIndices for each label
+#         * \param[out] boundary_indices A vector of PointIndices corresponding to the outer boundary / contour of each label
+#         */
+#       void
+#       segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions,
+#                         std::vector<ModelCoefficients>& model_coefficients,
+#                         std::vector<PointIndices>& inlier_indices,
+#                         PointCloudLPtr& labels,
+#                         std::vector<pcl::PointIndices>& label_indices,
+#                         std::vector<pcl::PointIndices>& boundary_indices);
+#       
+#       /** \brief Perform a refinement of an initial segmentation, by comparing points to adjacent regions detected by the initial segmentation.
+#         * \param [in] model_coefficients The list of segmented model coefficients
+#         * \param [in] inlier_indices The list of segmented inlier indices, corresponding to each model
+#         * \param [in] centroids The list of centroids corresponding to each segmented plane
+#         * \param [in] covariances The list of covariances corresponding to each segemented plane
+#         * \param [in] labels The labels produced by the initial segmentation
+#         * \param [in] label_indices The list of indices corresponding to each label
+#         */
+#       void
+#       refine (std::vector<ModelCoefficients>& model_coefficients, 
+#               std::vector<PointIndices>& inlier_indices,
+#               std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+#               std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+#               PointCloudLPtr& labels,
+#               std::vector<pcl::PointIndices>& label_indices);
+
+
+###
+
+# planar_polygon_fusion.h
+# namespace pcl
+# /** \brief PlanarPolygonFusion takes a list of 2D planar polygons and
+#   * attempts to reduce them to a minimum set that best represents the scene,
+#   * based on various given comparators.
+#   */
+# template <typename PointT>
+# class PlanarPolygonFusion
+#     public:
+#       /** \brief Constructor */
+#       PlanarPolygonFusion () : regions_ () {}
+#      
+#       /** \brief Destructor */
+#       virtual ~PlanarPolygonFusion () {}
+# 
+#       /** \brief Reset the state (clean the list of planar models). */
+#       void 
+#       reset ()
+#       {
+#         regions_.clear ();
+#       }
+#       
+#       /** \brief Set the list of 2D planar polygons to refine.
+#         * \param[in] input the list of 2D planar polygons to refine
+#         */
+#       void
+#       addInputPolygons (const std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > > &input)
+#       {
+#         int start = static_cast<int> (regions_.size ());
+#         regions_.resize (regions_.size () + input.size ());
+#         for(size_t i = 0; i < input.size (); i++)
+#           regions_[start+i] = input[i];
+#       }
+
+
+###
+
+# planar_region.h
+# namespace pcl
+# /** \brief PlanarRegion represents a set of points that lie in a plane.  Inherits summary statistics about these points from Region3D, and  summary statistics of a 3D collection of points.
+#   * \author Alex Trevor
+#   */
+# template <typename PointT>
+# class PlanarRegion : public pcl::Region3D<PointT>, public pcl::PlanarPolygon<PointT>
+#     protected:
+#       using Region3D<PointT>::centroid_;
+#       using Region3D<PointT>::covariance_; 
+#       using Region3D<PointT>::count_;
+#       using PlanarPolygon<PointT>::contour_;
+#       using PlanarPolygon<PointT>::coefficients_;
+# 
+#     public:
+#       /** \brief Empty constructor for PlanarRegion. */
+#       PlanarRegion () : contour_labels_ ()
+#       {}
+# 
+#       /** \brief Constructor for Planar region from a Region3D and a PlanarPolygon. 
+#         * \param[in] region a Region3D for the input data
+#         * \param[in] polygon a PlanarPolygon for the input region
+#         */
+#       PlanarRegion (const pcl::Region3D<PointT>& region, const pcl::PlanarPolygon<PointT>& polygon) :
+#         contour_labels_ ()
+#       {
+#         centroid_ = region.centroid;
+#         covariance_ = region.covariance;
+#         count_ = region.count;
+#         contour_ = polygon.contour;
+#         coefficients_ = polygon.coefficients;
+#       }
+#       
+#       /** \brief Destructor. */
+#       virtual ~PlanarRegion () {}
+# 
+#       /** \brief Constructor for PlanarRegion.
+#         * \param[in] centroid the centroid of the region.
+#         * \param[in] covariance the covariance of the region.
+#         * \param[in] count the number of points in the region.
+#         * \param[in] contour the contour / boudnary for the region
+#         * \param[in] coefficients the model coefficients (a,b,c,d) for the plane
+#         */
+#       PlanarRegion (const Eigen::Vector3f& centroid, const Eigen::Matrix3f& covariance, unsigned count,
+#                     const typename pcl::PointCloud<PointT>::VectorType& contour,
+#                     const Eigen::Vector4f& coefficients) :
+#         contour_labels_ ()
+#       {
+#         centroid_ = centroid;
+#         covariance_ = covariance;
+#         count_ = count;
+#         contour_ = contour;
+#         coefficients_ = coefficients;
+#       }
+
+
+###
+
+# plane_refinement_comparator.h
+# namespace pcl
+# /** \brief PlaneRefinementComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class PlaneRefinementComparator: public PlaneCoefficientComparator<PointT, PointNT>
+#     public:
+#       typedef typename Comparator<PointT>::PointCloud PointCloud;
+#       typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+#       typedef boost::shared_ptr<PlaneRefinementComparator<PointT, PointNT, PointLT> > Ptr;
+#       typedef boost::shared_ptr<const PlaneRefinementComparator<PointT, PointNT, PointLT> > ConstPtr;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+# 
+#       /** \brief Empty constructor for PlaneCoefficientComparator. */
+#      PlaneRefinementComparator ()
+#         : models_ ()
+#         , labels_ ()
+#         , refine_labels_ ()
+#         , label_to_model_ ()
+#         , depth_dependent_ (false)
+#       
+#       /** \brief Empty constructor for PlaneCoefficientComparator. 
+#         * \param[in] models
+#         * \param[in] refine_labels
+#         */
+#       PlaneRefinementComparator (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models,
+#                                  boost::shared_ptr<std::vector<bool> >& refine_labels)
+#         : models_ (models)
+#         , labels_ ()
+#         , refine_labels_ (refine_labels)
+#         , label_to_model_ ()
+#         , depth_dependent_ (false)
+#       
+#       /** \brief Destructor for PlaneCoefficientComparator. */
+#       virtual
+#       ~PlaneRefinementComparator ()
+#       
+#       /** \brief Set the vector of model coefficients to which we will compare.
+#         * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+#         */
+#       void setModelCoefficients (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models)
+#       
+#       /** \brief Set the vector of model coefficients to which we will compare.
+#         * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+#         */
+#       void setModelCoefficients (std::vector<pcl::ModelCoefficients>& models)
+#       
+#       /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+#         * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+#         */
+#       void setRefineLabels (boost::shared_ptr<std::vector<bool> >& refine_labels)
+#       
+#       /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+#         * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+#         */
+#       void setRefineLabels (std::vector<bool>& refine_labels)
+#       
+#       /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+#         * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+#         */
+#       inline void setLabelToModel (boost::shared_ptr<std::vector<int> >& label_to_model)
+#       
+#       /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+#         * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+#         */
+#       inline void setLabelToModel (std::vector<int>& label_to_model)
+#       
+#       /** \brief Get the vector of model coefficients to which we will compare. */
+#       inline boost::shared_ptr<std::vector<pcl::ModelCoefficients> > getModelCoefficients () const
+#       
+#       /** \brief ...
+#         * \param[in] labels
+#         */
+#       inline void setLabels (PointCloudLPtr& labels)
+#       
+#       /** \brief Compare two neighboring points
+#         * \param[in] idx1 The index of the first point.
+#         * \param[in] idx2 The index of the second point.
+#         */
+#       virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# region_3d.h
+# namespace pcl
+# /** \brief Region3D represents summary statistics of a 3D collection of points.
+#   * \author Alex Trevor
+#   */
+# template <typename PointT>
+# class Region3D
+#     public:
+#       /** \brief Empty constructor for Region3D. */
+#       Region3D () : centroid_ (Eigen::Vector3f::Zero ()), covariance_ (Eigen::Matrix3f::Identity ()), count_ (0)
+#       {
+#       }
+#       
+#       /** \brief Constructor for Region3D. 
+#         * \param[in] centroid The centroid of the region.
+#         * \param[in] covariance The covariance of the region.
+#         * \param[in] count The number of points in the region.
+#         */
+#       Region3D (Eigen::Vector3f& centroid, Eigen::Matrix3f& covariance, unsigned count) 
+#         : centroid_ (centroid), covariance_ (covariance), count_ (count)
+#       {
+#       }
+#      
+#       /** \brief Destructor. */
+#       virtual ~Region3D () {}
+# 
+#       /** \brief Get the centroid of the region. */
+#       inline Eigen::Vector3f 
+#       getCentroid () const
+#       {
+#         return (centroid_);
+#       }
+#       
+#       /** \brief Get the covariance of the region. */
+#       inline Eigen::Matrix3f
+#       getCovariance () const
+#       {
+#         return (covariance_);
+#       }
+#       
+#       /** \brief Get the number of points in the region. */
+#       unsigned getCount () const
+
+
+###
+
+# rgb_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.  Also takes into account RGB, so we can segmented different colored co-planar regions.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   *
+#   * \author Alex Trevor
+#   */
+# template<typename PointT, typename PointNT>
+# class RGBPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+#     public:
+#       typedef typename Comparator<PointT>::PointCloud PointCloud;
+#       typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+#       
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+#       
+#       typedef boost::shared_ptr<RGBPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+#       typedef boost::shared_ptr<const RGBPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+# 
+#       using pcl::Comparator<PointT>::input_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+# 
+#       /** \brief Empty constructor for RGBPlaneCoefficientComparator. */
+#       RGBPlaneCoefficientComparator ()
+#         : color_threshold_ (50.0f)
+#       {
+#       }
+# 
+#       /** \brief Constructor for RGBPlaneCoefficientComparator.
+#         * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+#         */
+#       RGBPlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+#         : PlaneCoefficientComparator<PointT, PointNT> (plane_coeff_d), color_threshold_ (50.0f)
+#       {
+#       }
+#       
+#       /** \brief Destructor for RGBPlaneCoefficientComparator. */
+#       virtual
+#       ~RGBPlaneCoefficientComparator ()
+#       {
+#       }
+# 
+#       /** \brief Set the tolerance in color space between neighboring points, to be considered part of the same plane.
+#         * \param[in] color_threshold The distance in color space
+#         */
+#       inline void
+#       setColorThreshold (float color_threshold)
+#       {
+#         color_threshold_ = color_threshold * color_threshold;
+#       }
+# 
+#       /** \brief Get the color threshold between neighboring points, to be considered part of the same plane. */
+#       inline float
+#       getColorThreshold () const
+#       {
+#         return (color_threshold_);
+#       }
+# 
+#       /** \brief Compare two neighboring points, by using normal information, euclidean distance, and color information.
+#         * \param[in] idx1 The index of the first point.
+#         * \param[in] idx2 The index of the second point.
+#         */
+#       bool
+#       compare (int idx1, int idx2) const
+#       {
+#         float dx = input_->points[idx1].x - input_->points[idx2].x;
+#         float dy = input_->points[idx1].y - input_->points[idx2].y;
+#         float dz = input_->points[idx1].z - input_->points[idx2].z;
+#         float dist = sqrtf (dx*dx + dy*dy + dz*dz);
+#         int dr = input_->points[idx1].r - input_->points[idx2].r;
+#         int dg = input_->points[idx1].g - input_->points[idx2].g;
+#         int db = input_->points[idx1].b - input_->points[idx2].b;
+#         //Note: This is not the best metric for color comparisons, we should probably use HSV space.
+#         float color_dist = static_cast<float> (dr*dr + dg*dg + db*db);
+#         return ( (dist < distance_threshold_)
+#                  && (normals_->points[idx1].getNormalVector3fMap ().dot (normals_->points[idx2].getNormalVector3fMap () ) > angular_threshold_ )
+#                  && (color_dist < color_threshold_));
+#       }
+
+
+###
+
+# segment_differences.h
+# namespace pcl
+# /** \brief Obtain the difference between two aligned point clouds as another point cloud, given a distance threshold.
+#   * \param src the input point cloud source
+#   * \param tgt the input point cloud target we need to obtain the difference against
+#   * \param threshold the distance threshold (tolerance) for point correspondences. (e.g., check if f a point p1 from 
+#   * src has a correspondence > threshold than a point p2 from tgt)
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching built over \a tgt
+#   * \param output the resultant output point cloud difference
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> 
+# void getPointCloudDifference (
+#     const pcl::PointCloud<PointT> &src, const pcl::PointCloud<PointT> &tgt, 
+#     double threshold, const boost::shared_ptr<pcl::search::Search<PointT> > &tree,
+#     pcl::PointCloud<PointT> &output);
+
+# segment_differences.h
+# namespace pcl
+# /** \brief @b SegmentDifferences obtains the difference between two spatially
+#   * aligned point clouds and returns the difference between them for a maximum
+#   * given distance threshold.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class SegmentDifferences: public PCLBase<PointT>
+#     typedef PCLBase<PointT> BasePCLBase;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef typename pcl::search::Search<PointT> KdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+# 
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+# 
+#       /** \brief Empty constructor. */
+#       SegmentDifferences ()
+# 
+#       /** \brief Provide a pointer to the target dataset against which we
+#         * compare the input cloud given in setInputCloud
+#         * \param cloud the target PointCloud dataset
+#       inline void setTargetCloud (const PointCloudConstPtr &cloud)
+# 
+#       /** \brief Get a pointer to the input target point cloud dataset. */
+#       inline PointCloudConstPtr const getTargetCloud ()
+#       /** \brief Provide a pointer to the search object.
+#         * \param tree a pointer to the spatial search object.
+#       inline void setSearchMethod (const KdTreePtr &tree)
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr getSearchMethod ()
+#       /** \brief Set the maximum distance tolerance (squared) between corresponding
+#         * points in the two input datasets.
+#         * \param sqr_threshold the squared distance tolerance as a measure in L2 Euclidean space
+#       inline void setDistanceThreshold (double sqr_threshold)
+#       /** \brief Get the squared distance tolerance between corresponding points as a
+#         * measure in the L2 Euclidean space.
+#       inline double getDistanceThreshold ()
+# 
+#       /** \brief Segment differences between two input point clouds.
+#         * \param output the resultant difference between the two point clouds as a PointCloud
+#         */
+#       void segment (PointCloud &output);
+#       protected:
+#       // Members derived from the base class
+#       using BasePCLBase::input_;
+#       using BasePCLBase::indices_;
+#       using BasePCLBase::initCompute;
+#       using BasePCLBase::deinitCompute;
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+#       /** \brief The input target point cloud dataset. */
+#       PointCloudConstPtr target_;
+#       /** \brief The distance tolerance (squared) as a measure in the L2
+#         * Euclidean space between corresponding points. 
+#         */
+#       double distance_threshold_;
+#       /** \brief Class getName method. */
+#       virtual std::string getClassName () const { return ("SegmentDifferences"); }
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
diff --git a/pcl/pcl_segmentation_172.pxd b/pcl/pcl_segmentation_172.pxd
new file mode 100644
index 0000000..2711f2b
--- /dev/null
+++ b/pcl/pcl_segmentation_172.pxd
@@ -0,0 +1,4065 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+from boost_shared_ptr cimport shared_ptr
+
+# main
+# cimport pcl_defs as cpp
+from pcl_defs cimport PointIndices
+from pcl_defs cimport ModelCoefficients
+from pcl_defs cimport PointCloud
+from pcl_defs cimport PointXYZ
+from pcl_defs cimport PointXYZI
+from pcl_defs cimport PointXYZRGB
+from pcl_defs cimport PointXYZRGBA
+from pcl_defs cimport Normal
+from pcl_defs cimport PCLBase
+from pcl_sample_consensus cimport SacModel
+cimport pcl_surface as pclsf
+cimport pcl_kdtree as pclkdt
+
+##
+
+from vector cimport vector as vector2
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+cdef extern from "pcl/segmentation/sac_segmentation.h" namespace "pcl":
+    cdef cppclass SACSegmentation[T](PCLBase[T]):
+        SACSegmentation()
+        void setModelType (SacModel)
+        # /** \brief Empty constructor. */
+        # SACSegmentation () :  model_ (), sac_ (), model_type_ (-1), method_type_ (0), 
+        #                       threshold_ (0), optimize_coefficients_ (true), 
+        #                       radius_min_ (-std::numeric_limits<double>::max()), radius_max_ (std::numeric_limits<double>::max()), samples_radius_ (0.0), eps_angle_ (0.0),
+        #                       axis_ (Eigen::Vector3f::Zero ()), max_iterations_ (50), probability_ (0.99)
+        # 
+        # /** \brief Get the type of SAC model used.
+        # inline int getModelType () const { return (model_type_); }
+        int getModelType ()
+        
+        # \brief Get a pointer to the SAC method used.
+        # inline SampleConsensusPtr getMethod () const { return (sac_); }
+        # 
+        # \brief Get a pointer to the SAC model used.
+        # inline SampleConsensusModelPtr getModel () const { return (model_); }
+        
+        void setMethodType (int)
+        # \brief Get the type of sample consensus method used.
+        # inline int getMethodType () const { return (method_type_); }
+        int getMethodType ()
+        
+        void setDistanceThreshold (float)
+        # \brief Get the distance to the model threshold.
+        # inline double getDistanceThreshold () const { return (threshold_); }
+        double getDistanceThreshold ()
+        
+        # use PCLBase class function
+        # void setInputCloud (shared_ptr[PointCloud[T]])
+        
+        void setMaxIterations (int)
+        # \brief Get maximum number of iterations before giving up.
+        # inline int getMaxIterations () const { return (max_iterations_); }
+        int getMaxIterations ()
+        
+        # \brief Set the probability of choosing at least one sample free from outliers.
+        # \param[in] probability the model fitting probability
+        # inline void setProbability (double probability) { probability_ = probability; }
+        void setProbability (double probability)
+        
+        # \brief Get the probability of choosing at least one sample free from outliers.
+        # inline double getProbability () const { return (probability_); }
+        double getProbability ()
+        
+        void setOptimizeCoefficients (bool)
+        
+        # \brief Get the coefficient refinement internal flag.
+        # inline bool getOptimizeCoefficients () const { return (optimize_coefficients_); }
+        bool getOptimizeCoefficients ()
+        
+        # \brief Set the minimum and maximum allowable radius limits for the model (applicable to models that estimate a radius)
+        # \param[in] min_radius the minimum radius model
+        # \param[in] max_radius the maximum radius model
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        void setRadiusLimits (const double &min_radius, const double &max_radius)
+        
+        # \brief Get the minimum and maximum allowable radius limits for the model as set by the user.
+        # \param[out] min_radius the resultant minimum radius model
+        # \param[out] max_radius the resultant maximum radius model
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        void getRadiusLimits (double &min_radius, double &max_radius)
+        
+        # \brief Set the maximum distance allowed when drawing random samples
+        # \param[in] radius the maximum distance (L2 norm)
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        # void setSamplesMaxDist (const double &radius, SearchPtr search)
+        
+        # \brief Get maximum distance allowed when drawing random samples
+        # \param[out] radius the maximum distance (L2 norm)
+        # inline void getSamplesMaxDist (double &radius)
+        void getSamplesMaxDist (double &radius)
+        
+        # \brief Set the axis along which we need to search for a model perpendicular to.
+        # \param[in] ax the axis along which we need to search for a model perpendicular to
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # void setAxis (const eigen3.Vector3f &ax)
+        
+        # \brief Get the axis along which we need to search for a model perpendicular to.
+        # inline Eigen::Vector3f getAxis () const { return (axis_); }
+        # eigen3.Vector3f getAxis ()
+        
+        # \brief Set the angle epsilon (delta) threshold.
+        # \param[in] ea the maximum allowed difference between the model normal and the given axis in radians.
+        # inline void setEpsAngle (double ea) { eps_angle_ = ea; }
+        void setEpsAngle (double ea)
+        
+        # /** \brief Get the epsilon (delta) model angle threshold in radians. */
+        # inline double getEpsAngle () const { return (eps_angle_); }
+        double getEpsAngle ()
+
+        void segment (PointIndices, ModelCoefficients)
+
+
+ctypedef SACSegmentation[PointXYZ] SACSegmentation_t
+ctypedef SACSegmentation[PointXYZI] SACSegmentation_PointXYZI_t
+ctypedef SACSegmentation[PointXYZRGB] SACSegmentation_PointXYZRGB_t
+ctypedef SACSegmentation[PointXYZRGBA] SACSegmentation_PointXYZRGBA_t
+###
+
+# \brief @b SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and
+# models that require the use of surface normals for estimation.
+# \ingroup segmentation
+cdef extern from "pcl/segmentation/sac_segmentation.h" namespace "pcl":
+    # cdef cppclass SACSegmentationFromNormals[T, N](SACSegmentation[T])
+    cdef cppclass SACSegmentationFromNormals[T, N]:
+        SACSegmentationFromNormals()
+        void setOptimizeCoefficients (bool)
+        void setModelType (SacModel)
+        void setMethodType (int)
+        void setNormalDistanceWeight (float)
+        void setMaxIterations (int)
+        void setDistanceThreshold (float)
+        void setRadiusLimits (float, float)
+        void setInputCloud (shared_ptr[PointCloud[T]])
+        void setInputNormals (shared_ptr[PointCloud[N]])
+        void setEpsAngle (double ea)
+        void segment (PointIndices, ModelCoefficients)
+        void setMinMaxOpeningAngle(double, double)
+        void getMinMaxOpeningAngle(double, double)
+        # Add
+        # /** \brief Empty constructor. */
+        # SACSegmentationFromNormals () : 
+        #   normals_ (), 
+        #   distance_weight_ (0.1), 
+        #   distance_from_origin_ (0), 
+        #   min_angle_ (), 
+        #   max_angle_ ()
+        # {};
+        # 
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        #   * the XYZ dataset.
+        #   * \param[in] normals the const boost shared pointer to a PointCloud message
+        #   */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) { normals_ = normals; }
+        # 
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals () const { return (normals_); }
+        # 
+        # /** \brief Set the relative weight (between 0 and 1) to give to the angular 
+        #   * distance (0 to pi/2) between point normals and the plane normal.
+        #   * \param[in] distance_weight the distance/angular weight
+        #   */
+        # inline void setNormalDistanceWeight (double distance_weight) { distance_weight_ = distance_weight; }
+        # 
+        # /** \brief Get the relative weight (between 0 and 1) to give to the angular distance (0 to pi/2) between point
+        #   * normals and the plane normal. */
+        # inline double getNormalDistanceWeight () const { return (distance_weight_); }
+        # 
+        # /** \brief Set the minimum opning angle for a cone model.
+        #   * \param oa the opening angle which we need minumum to validate a cone model.
+        #   */
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        # 
+        # /** \brief Get the opening angle which we need minumum to validate a cone model. */
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle)
+        # 
+        # /** \brief Set the distance we expect a plane model to be from the origin
+        #   * \param[in] d distance from the template plane modl to the origin
+        #   */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        # 
+        # /** \brief Get the distance of a plane model from the origin. */
+        # inline double getDistanceFromOrigin () const { return (distance_from_origin_); }
+
+
+ctypedef SACSegmentationFromNormals[PointXYZ,Normal] SACSegmentationFromNormals_t
+ctypedef SACSegmentationFromNormals[PointXYZI,Normal] SACSegmentationFromNormals_PointXYZI_t
+ctypedef SACSegmentationFromNormals[PointXYZRGB,Normal] SACSegmentationFromNormals_PointXYZRGB_t
+ctypedef SACSegmentationFromNormals[PointXYZRGBA,Normal] SACSegmentationFromNormals_PointXYZRGBA_t
+###
+
+# comparator.h
+# namespace pcl
+# brief Comparator is the base class for comparators that compare two points given some function.
+# Currently intended for use with OrganizedConnectedComponentSegmentation
+# author Alex Trevor
+# template <typename PointT> class Comparator
+cdef extern from "pcl/segmentation/comparator.h" namespace "pcl":
+    cdef cppclass Comparator[T]:
+        Comparator()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<Comparator<PointT> > Ptr;
+        # typedef boost::shared_ptr<const Comparator<PointT> > ConstPtr;
+        # 
+        # /** \brief Set the input cloud for the comparator.
+        #   * \param[in] cloud the point cloud this comparator will operate on
+        #   */
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # 
+        # /** \brief Get the input cloud this comparator operates on. */
+        # virtual PointCloudConstPtr getInputCloud () const
+        # 
+        # /** \brief Compares the two points in the input cloud designated by these two indices.
+        #   * This is pure virtual and must be implemented by subclasses with some comparison function.
+        #   * \param[in] idx1 the index of the first point.
+        #   * \param[in] idx2 the index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const = 0;
+
+
+###
+
+# plane_coefficient_comparator.h
+# namespace pcl
+# brief PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation.
+# In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+# author Alex Trevor
+# template<typename PointT, typename PointNT> class PlaneCoefficientComparator: public Comparator<PointT>
+cdef extern from "pcl/segmentation/plane_coefficient_comparator.h" namespace "pcl":
+    cdef cppclass PlaneCoefficientComparator[T, NT](Comparator[T]):
+        PlaneCoefficientComparator()
+        # PlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<PlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const PlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        
+        # /** \brief Provide a pointer to the input normals.
+        #   * \param[in] normals the input normal cloud
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # void setPlaneCoeffD (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # void setPlaneCoeffD (std::vector<float>& plane_coeff_d)
+        
+        # /** \brief Get a pointer to the vector of the d-coefficient of the planes' hessian normal form. */
+        # const std::vector<float>& getPlaneCoeffD () const
+        
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #   * \param[in] angular_threshold the tolerance in radians
+        # virtual void setAngularThreshold (float angular_threshold)
+        
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        float getAngularThreshold ()
+        
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters (at 1m)
+        #   * \param[in] depth_dependent whether to scale the threshold based on range from the sensor (default: false)
+        # void setDistanceThreshold (float distance_threshold, bool depth_dependent = false)
+        void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        float getDistanceThreshold ()
+        
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+### Inheritance class ###
+
+# edge_aware_plane_comparator.h
+# namespace pcl
+# /** \brief EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Stefan Holzer, Alex Trevor
+#   */
+# template<typename PointT, typename PointNT>
+# class EdgeAwarePlaneComparator: public PlaneCoefficientComparator<PointT, PointNT>
+cdef extern from "pcl/segmentation/edge_aware_plane_comparator.h" namespace "pcl":
+    cdef cppclass EdgeAwarePlaneComparator[T, NT](PlaneCoefficientComparator[T, NT]):
+        EdgeAwarePlaneComparator()
+        # EdgeAwarePlaneComparator (const float *distance_map)
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<EdgeAwarePlaneComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const EdgeAwarePlaneComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Set a distance map to use. For an example of a valid distance map see 
+        #   * \ref OrganizedIntegralImageNormalEstimation
+        #   * \param[in] distance_map the distance map to use
+        #   */
+        # inline void setDistanceMap (const float *distance_map)
+        # /** \brief Return the distance map used. */
+        # const float* getDistanceMap () const
+
+
+###
+
+# euclidean_cluster_comparator.h
+# namespace pcl
+# /** \brief EuclideanClusterComparator is a comparator used for finding clusters supported by planar surfaces.
+#   * This needs to be run as a second pass after extracting planar surfaces, using MultiPlaneSegmentation for example.
+#   * \author Alex Trevor
+# template<typename PointT, typename PointNT, typename PointLT>
+# class EuclideanClusterComparator: public Comparator<PointT>
+cdef extern from "pcl/segmentation/euclidean_cluster_comparator.h" namespace "pcl":
+    cdef cppclass EuclideanClusterComparator[T, NT, LT](Comparator[T]):
+        EuclideanClusterComparator()
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # typedef boost::shared_ptr<EuclideanClusterComparator<PointT, PointNT, PointLT> > Ptr;
+        # typedef boost::shared_ptr<const EuclideanClusterComparator<PointT, PointNT, PointLT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        
+        # /** \brief Provide a pointer to the input normals.
+        #   * \param[in] normals the input normal cloud
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        void setInputNormals (const shared_ptr[PointCloud[NT]] &normals)
+        
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        const shared_ptr[PointCloud[NT]] getInputNormals ()
+        
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #   * \param[in] angular_threshold the tolerance in radians
+        # virtual inline void setAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        float getAngularThreshold ()
+        
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters
+        # inline void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        float getDistanceThreshold ()
+        
+        # /** \brief Set label cloud
+        #   * \param[in] labels The label cloud
+        # void setLabels (PointCloudLPtr& labels)
+        void setLabels (shared_ptr[PointCloud[LT]] &labels)
+        
+        # 
+        # /** \brief Set labels in the label cloud to exclude.
+        #   * \param exclude_labels a vector of bools corresponding to whether or not a given label should be considered
+        # void setExcludeLabels (std::vector<bool>& exclude_labels)
+        void setExcludeLabels (vector[bool]& exclude_labels)
+        
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        # virtual bool compare (int idx1, int idx2) const
+
+
+ctypedef EuclideanClusterComparator[PointXYZ, Normal, PointXYZ] EuclideanClusterComparator_t
+ctypedef EuclideanClusterComparator[PointXYZI, Normal, PointXYZ] EuclideanClusterComparator_PointXYZI_t
+ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t
+ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGBA_Ptr_t
+###
+
+# euclidean_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Alex Trevor
+# template<typename PointT, typename PointNT>
+# class EuclideanPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+cdef extern from "pcl/segmentation/euclidean_plane_coefficient_comparator.h" namespace "pcl":
+    cdef cppclass EuclideanPlaneCoefficientComparator[T, NT](PlaneCoefficientComparator[T, NT]):
+        EuclideanPlaneCoefficientComparator()
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<EuclideanPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const EuclideanPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Compare two neighboring points, by using normal information, and euclidean distance information.
+        #   * \param[in] idx1 The index of the first point.
+        #   * \param[in] idx2 The index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# extract_clusters.h
+# namespace pcl
+# brief Decompose a region of space into clusters based on the Euclidean distance between points
+# param cloud the point cloud message
+# param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+# note the tree has to be created as a spatial locator on \a cloud
+# param tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+# param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+# param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+# param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+# ingroup segmentation
+# template <typename PointT> void extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const boost::shared_ptr<search::Search<PointT> > &tree, 
+#       float tolerance, std::vector<PointIndices> &clusters, 
+#       unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ());
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#   * \param cloud the point cloud message
+#   * \param indices a list of point indices to use from \a cloud
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud and \a indices
+#   * \param tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> void 
+# extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const std::vector<int> &indices, 
+#       const boost::shared_ptr<search::Search<PointT> > &tree, float tolerance, std::vector<PointIndices> &clusters, 
+#       unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ());
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the euclidean distance between points, and the normal
+#   * angular deviation
+#   * \param cloud the point cloud message
+#   * \param normals the point cloud message containing normal information
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param eps_angle the maximum allowed difference between normals in radians for cluster/region growing
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT, typename Normal> void 
+# extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const PointCloud<Normal> &normals, 
+#       float tolerance, const boost::shared_ptr<KdTree<PointT> > &tree, 
+#       std::vector<PointIndices> &clusters, double eps_angle, 
+#       unsigned int min_pts_per_cluster = 1, 
+#       unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ())
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the euclidean distance between points, and the normal
+#   * angular deviation
+#   * \param cloud the point cloud message
+#   * \param normals the point cloud message containing normal information
+#   * \param indices a list of point indices to use from \a cloud
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as PointIndices)
+#   * \param eps_angle the maximum allowed difference between normals in degrees for cluster/region growing
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT, typename Normal> 
+# void extractEuclideanClusters (
+#     const PointCloud<PointT> &cloud, const PointCloud<Normal> &normals, 
+#     const std::vector<int> &indices, const boost::shared_ptr<KdTree<PointT> > &tree, 
+#     float tolerance, std::vector<PointIndices> &clusters, double eps_angle, 
+#     unsigned int min_pts_per_cluster = 1, 
+#     unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ())
+###
+
+# extract_clusters.h
+# namespace pcl
+# EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense.
+# author Radu Bogdan Rusu
+# ingroup segmentation
+# template <typename PointT>
+# class EuclideanClusterExtraction: public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_clusters.h" namespace "pcl":
+    cdef cppclass EuclideanClusterExtraction[T](PCLBase[T]):
+        EuclideanClusterExtraction()
+        # public:
+        # EuclideanClusterExtraction () : tree_ (), 
+        #                                 cluster_tolerance_ (0),
+        #                                 min_pts_per_cluster_ (1), 
+        #                                 max_pts_per_cluster_ (std::numeric_limits<int>::max ())
+        
+        # brief Provide a pointer to the search object.
+        # param[in] tree a pointer to the spatial search object.
+        # inline void setSearchMethod (const KdTreePtr &tree) 
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # brief Get a pointer to the search method used. 
+        # @todo fix this for a generic search tree
+        # inline KdTreePtr getSearchMethod () const 
+        pclkdt.KdTreePtr_t getSearchMethod ()
+        
+        # brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+        # param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+        # inline void setClusterTolerance (double tolerance) 
+        void setClusterTolerance (double tolerance) 
+        
+        # brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space.
+        # inline double getClusterTolerance () const 
+        double getClusterTolerance ()
+        
+        # brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # param[in] min_cluster_size the minimum cluster size
+        # inline void setMinClusterSize (int min_cluster_size) 
+        void setMinClusterSize (int min_cluster_size) 
+        
+        # brief Get the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # inline int getMinClusterSize () const 
+        int getMinClusterSize ()
+        
+        # brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # param[in] max_cluster_size the maximum cluster size
+        # inline void setMaxClusterSize (int max_cluster_size) 
+        void setMaxClusterSize (int max_cluster_size) 
+        
+        # brief Get the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # inline int getMaxClusterSize () const 
+        int getMaxClusterSize ()
+        
+        # brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        # param[out] clusters the resultant point clusters
+        # void extract (std::vector<PointIndices> &clusters);
+        void extract (vector[PointIndices] &clusters)
+
+
+ctypedef EuclideanClusterExtraction[PointXYZ] EuclideanClusterExtraction_t
+ctypedef EuclideanClusterExtraction[PointXYZI] EuclideanClusterExtraction_PointXYZI_t
+ctypedef EuclideanClusterExtraction[PointXYZRGB] EuclideanClusterExtraction_PointXYZRGB_t
+ctypedef EuclideanClusterExtraction[PointXYZRGBA] EuclideanClusterExtraction_PointXYZRGBA_t
+###
+
+
+# extract_labeled_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#   * \param[in] cloud the point cloud message
+#   * \param[in] tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param[in] tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#   * \param[out] labeled_clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param[in] min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param[in] max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \param[in] max_label
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> void 
+# extractLabeledEuclideanClusters (
+#     const PointCloud<PointT> &cloud, const boost::shared_ptr<search::Search<PointT> > &tree, 
+#     float tolerance, std::vector<std::vector<PointIndices> > &labeled_clusters, 
+#     unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) (), 
+#     unsigned int max_label = (std::numeric_limits<int>::max));
+
+
+# extract_labeled_clusters.h
+# namespace pcl
+# brief @b LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info.
+# author Koen Buys
+# ingroup segmentation
+# template <typename PointT>
+# class LabeledEuclideanClusterExtraction: public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_labeled_clusters.h" namespace "pcl":
+    cdef cppclass LabeledEuclideanClusterExtraction[T](PCLBase[T]):
+        LabeledEuclideanClusterExtraction()
+        # typedef PCLBase<PointT> BasePCLBase;
+        # 
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::search::Search<PointT> KdTree;
+        # typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # LabeledEuclideanClusterExtraction () : 
+        #   tree_ (), 
+        #   cluster_tolerance_ (0),
+        #   min_pts_per_cluster_ (1), 
+        #   max_pts_per_cluster_ (std::numeric_limits<int>::max ()),
+        #   max_label_ (std::numeric_limits<int>::max ())
+        # {};
+        # 
+        # /** \brief Provide a pointer to the search object.
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   */
+        # inline void setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+        # 
+        # /** \brief Get a pointer to the search method used. */
+        # inline KdTreePtr getSearchMethod () const { return (tree_); }
+        # 
+        # /** \brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+        #   * \param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+        #   */
+        # inline void setClusterTolerance (double tolerance) { cluster_tolerance_ = tolerance; }
+        # 
+        # /** \brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space. */
+        # inline double getClusterTolerance () const { return (cluster_tolerance_); }
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        #   * \param[in] min_cluster_size the minimum cluster size
+        #   */
+        # inline void setMinClusterSize (int min_cluster_size) { min_pts_per_cluster_ = min_cluster_size; }
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # inline int getMinClusterSize () const { return (min_pts_per_cluster_); }
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        #   * \param[in] max_cluster_size the maximum cluster size
+        #   */
+        # inline void setMaxClusterSize (int max_cluster_size) { max_pts_per_cluster_ = max_cluster_size; }
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # inline int getMaxClusterSize () const { return (max_pts_per_cluster_); }
+        # 
+        # /** \brief Set the maximum number of labels in the cloud.
+        #   * \param[in] max_label the maximum
+        #   */
+        # inline void setMaxLabels (unsigned int max_label) { max_label_ = max_label; }
+        # 
+        # /** \brief Get the maximum number of labels */
+        # inline unsigned int getMaxLabels () const { return (max_label_); }
+        # 
+        # /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        #   * \param[out] labeled_clusters the resultant point clusters
+        #   */
+        # void extract (std::vector<std::vector<PointIndices> > &labeled_clusters);
+        # 
+        # protected:
+        #     // Members derived from the base class
+        #     using BasePCLBase::input_;
+        #     using BasePCLBase::indices_;
+        #     using BasePCLBase::initCompute;
+        #     using BasePCLBase::deinitCompute;
+        # 
+        # /** \brief A pointer to the spatial search object. */
+        # KdTreePtr tree_;
+        # /** \brief The spatial cluster tolerance as a measure in the L2 Euclidean space. */
+        # double cluster_tolerance_;
+        # /** \brief The minimum number of points that a cluster needs to contain in order to be considered valid (default = 1). */
+        # int min_pts_per_cluster_;
+        # /** \brief The maximum number of points that a cluster needs to contain in order to be considered valid (default = MAXINT). */
+        # int max_pts_per_cluster_;
+        # /** \brief The maximum number of labels we can find in this pointcloud (default = MAXINT)*/
+        # unsigned int max_label_;
+        # /** \brief Class getName method. */
+        # virtual std::string getClassName () const { return ("LabeledEuclideanClusterExtraction"); }
+        # 
+
+        #   brief Sort clusters method (for std::sort). 
+        #   ingroup segmentation
+        #   inline bool compareLabeledPointClusters (const pcl::PointIndices &a, const pcl::PointIndices &b)
+        #   {
+        #     return (a.indices.size () < b.indices.size ());
+        #   }
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief General purpose method for checking if a 3D point is inside or
+#   * outside a given 2D polygon. 
+#   * \note this method accepts any general 3D point that is projected onto the
+#   * 2D polygon, but performs an internal XY projection of both the polygon and the point. 
+#   * \param point a 3D point projected onto the same plane as the polygon
+#   * \param polygon a polygon
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> bool isPointIn2DPolygon (const PointT &point, const pcl::PointCloud<PointT> &polygon);
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief Check if a 2d point (X and Y coordinates considered only!) is
+#   * inside or outside a given polygon. This method assumes that both the point
+#   * and the polygon are projected onto the XY plane.
+#   *
+#   * \note (This is highly optimized code taken from http://www.visibone.com/inpoly/)
+#   *       Copyright (c) 1995-1996 Galacticomm, Inc.  Freeware source code.
+#   * \param point a 3D point projected onto the same plane as the polygon
+#   * \param polygon a polygon
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> bool 
+# isXYPointIn2DXYPolygon (const PointT &point, const pcl::PointCloud<PointT> &polygon);
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief @b ExtractPolygonalPrismData uses a set of point indices that
+#   * represent a planar model, and together with a given height, generates a 3D
+#   * polygonal prism. The polygonal prism is then used to segment all points
+#   * lying inside it.
+#   * An example of its usage is to extract the data lying within a set of 3D
+#   * boundaries (e.g., objects supported by a plane).
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class ExtractPolygonalPrismData : public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_polygonal_prism_data.h" namespace "pcl":
+    cdef cppclass ExtractPolygonalPrismData[T](PCLBase[T]):
+        ExtractPolygonalPrismData()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # brief Empty constructor.
+        # ExtractPolygonalPrismData () : planar_hull_ (), min_pts_hull_ (3), 
+        #                                height_limit_min_ (0), height_limit_max_ (FLT_MAX),
+        #                                vpx_ (0), vpy_ (0), vpz_ (0)
+        # {};
+        # 
+        # brief Provide a pointer to the input planar hull dataset.
+        # param[in] hull the input planar hull dataset
+        # inline void setInputPlanarHull (const PointCloudConstPtr &hull) { planar_hull_ = hull; }
+        # 
+        # brief Get a pointer the input planar hull dataset.
+        # inline PointCloudConstPtr getInputPlanarHull () const { return (planar_hull_); }
+        # 
+        # brief Set the height limits. All points having distances to the
+        # model outside this interval will be discarded.
+        # param[in] height_min the minimum allowed distance to the plane model value
+        # param[in] height_max the maximum allowed distance to the plane model value
+        # inline void setHeightLimits (double height_min, double height_max)
+        # 
+        # brief Get the height limits (min/max) as set by the user. The
+        # default values are -FLT_MAX, FLT_MAX. 
+        # param[out] height_min the resultant min height limit
+        # param[out] height_max the resultant max height limit
+        # inline void getHeightLimits (double &height_min, double &height_max) const
+        # 
+        # brief Set the viewpoint.
+        # param[in] vpx the X coordinate of the viewpoint
+        # param[in] vpy the Y coordinate of the viewpoint
+        # param[in] vpz the Z coordinate of the viewpoint
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # brief Get the viewpoint.
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz) const
+        # 
+        # /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        #   * \param[out] output the resultant point indices that support the model found (inliers)
+        # void segment (PointIndices &output);
+        # 
+        # protected:
+        # brief A pointer to the input planar hull dataset.
+        # PointCloudConstPtr planar_hull_;
+        # 
+        # brief The minimum number of points needed on the convex hull.
+        # int min_pts_hull_;
+        # 
+        # brief The minimum allowed height (distance to the model) a point
+        # will be considered from. 
+        # double height_limit_min_;
+        # 
+        # brief The maximum allowed height (distance to the model) a point will be considered from. 
+        # double height_limit_max_;
+        # 
+        # brief Values describing the data acquisition viewpoint. Default: 0,0,0.
+        # float vpx_, vpy_, vpz_;
+        # 
+        # brief Class getName method.
+        # virtual std::string getClassName () const { return ("ExtractPolygonalPrismData"); }
+
+
+###
+
+# organized_connected_component_segmentation.h
+# namespace pcl
+# /** \brief OrganizedConnectedComponentSegmentation allows connected
+#   * components to be found within organized point cloud data, given a
+#   * comparison function.  Given an input cloud and a comparator, it will
+#   * output a PointCloud of labels, giving each connected component a unique
+#   * id, along with a vector of PointIndices corresponding to each component.
+#   * See OrganizedMultiPlaneSegmentation for an example application.
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template <typename PointT, typename PointLT>
+# class OrganizedConnectedComponentSegmentation : public PCLBase<PointT>
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::indices_;
+#     using PCLBase<PointT>::initCompute;
+#     using PCLBase<PointT>::deinitCompute;
+# 
+#     public:
+#       typedef typename pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+# 
+#       typedef typename pcl::Comparator<PointT> Comparator;
+#       typedef typename Comparator::Ptr ComparatorPtr;
+#       typedef typename Comparator::ConstPtr ComparatorConstPtr;
+#       
+#       /** \brief Constructor for OrganizedConnectedComponentSegmentation
+#         * \param[in] compare A pointer to the comparator to be used for segmentation.  Must be an instance of pcl::Comparator.
+#         */
+#       OrganizedConnectedComponentSegmentation (const ComparatorConstPtr& compare)
+#         : compare_ (compare)
+#       {
+#       }
+# 
+#       /** \brief Destructor for OrganizedConnectedComponentSegmentation. */
+#       virtual
+#       ~OrganizedConnectedComponentSegmentation ()
+#       {
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for segmentation.
+#         * \param[in] compare the comparator
+#         */
+#       void
+#       setComparator (const ComparatorConstPtr& compare)
+#       {
+#         compare_ = compare;
+#       }
+#       
+#       /** \brief Get the comparator.*/
+#       ComparatorConstPtr
+#       getComparator () const { return (compare_); }
+# 
+#       /** \brief Perform the connected component segmentation.
+#         * \param[out] labels a PointCloud of labels: each connected component will have a unique id.
+#         * \param[out] label_indices a vector of PointIndices corresponding to each label / component id.
+#         */
+#       void
+#       segment (pcl::PointCloud<PointLT>& labels, std::vector<pcl::PointIndices>& label_indices) const;
+#       
+#       /** \brief Find the boundary points / contour of a connected component
+#         * \param[in] start_idx the first (lowest) index of the connected component for which a boundary shoudl be returned
+#         * \param[in] labels the Label cloud produced by segmentation
+#         * \param[out] boundary_indices the indices of the boundary points for the label corresponding to start_idx
+#         */
+#       static void
+#       findLabeledRegionBoundary (int start_idx, PointCloudLPtr labels, pcl::PointIndices& boundary_indices);      
+#       
+# 
+#     protected:
+#       ComparatorConstPtr compare_;
+#       
+#       inline unsigned
+#       findRoot (const std::vector<unsigned>& runs, unsigned index) const
+#       {
+#         register unsigned idx = index;
+#         while (runs[idx] != idx)
+#           idx = runs[idx];
+# 
+#         return (idx);
+#       }
+###
+
+# organized_multi_plane_segmentation.h
+# namespace pcl
+# /** \brief OrganizedMultiPlaneSegmentation finds all planes present in the
+#   * input cloud, and outputs a vector of plane equations, as well as a vector
+#   * of point clouds corresponding to the inliers of each detected plane.  Only
+#   * planes with more than min_inliers points are detected.
+#   * Templated on point type, normal type, and label type
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class OrganizedMultiPlaneSegmentation : public PCLBase<PointT>
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::indices_;
+#     using PCLBase<PointT>::initCompute;
+#     using PCLBase<PointT>::deinitCompute;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+# 
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+# 
+#       typedef typename pcl::PlaneCoefficientComparator<PointT, PointNT> PlaneComparator;
+#       typedef typename PlaneComparator::Ptr PlaneComparatorPtr;
+#       typedef typename PlaneComparator::ConstPtr PlaneComparatorConstPtr;
+# 
+#       typedef typename pcl::PlaneRefinementComparator<PointT, PointNT, PointLT> PlaneRefinementComparator;
+#       typedef typename PlaneRefinementComparator::Ptr PlaneRefinementComparatorPtr;
+#       typedef typename PlaneRefinementComparator::ConstPtr PlaneRefinementComparatorConstPtr;
+# 
+#       /** \brief Constructor for OrganizedMultiPlaneSegmentation. */
+#       OrganizedMultiPlaneSegmentation () :
+#         normals_ (), 
+#         min_inliers_ (1000), 
+#         angular_threshold_ (pcl::deg2rad (3.0)), 
+#         distance_threshold_ (0.02),
+#         maximum_curvature_ (0.001),
+#         project_points_ (false), 
+#         compare_ (new PlaneComparator ()), refinement_compare_ (new PlaneRefinementComparator ())
+#       {
+#       }
+# 
+#       /** \brief Destructor for OrganizedMultiPlaneSegmentation. */
+#       virtual
+#       ~OrganizedMultiPlaneSegmentation ()
+#       {
+#       }
+# 
+#       /** \brief Provide a pointer to the input normals.
+#         * \param[in] normals the input normal cloud
+#         */
+#       inline void
+#       setInputNormals (const PointCloudNConstPtr &normals) 
+#       {
+#         normals_ = normals;
+#       }
+# 
+#       /** \brief Get the input normals. */
+#       inline PointCloudNConstPtr
+#       getInputNormals () const
+#       {
+#         return (normals_);
+#       }
+# 
+#       /** \brief Set the minimum number of inliers required for a plane
+#         * \param[in] min_inliers the minimum number of inliers required per plane
+#         */
+#       inline void
+#       setMinInliers (unsigned min_inliers)
+#       {
+#         min_inliers_ = min_inliers;
+#       }
+# 
+#       /** \brief Get the minimum number of inliers required per plane. */
+#       inline unsigned
+#       getMinInliers () const
+#       {
+#         return (min_inliers_);
+#       }
+# 
+#       /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+#         * \param[in] angular_threshold the tolerance in radians
+#         */
+#       inline void
+#       setAngularThreshold (double angular_threshold)
+#       {
+#         angular_threshold_ = angular_threshold;
+#       }
+# 
+#       /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+#       inline double
+#       getAngularThreshold () const
+#       {
+#         return (angular_threshold_);
+#       }
+# 
+#       /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+#         * \param[in] distance_threshold the tolerance in meters
+#         */
+#       inline void
+#       setDistanceThreshold (double distance_threshold)
+#       {
+#         distance_threshold_ = distance_threshold;
+#       }
+# 
+#       /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+#       inline double
+#       getDistanceThreshold () const
+#       {
+#         return (distance_threshold_);
+#       }
+# 
+#       /** \brief Set the maximum curvature allowed for a planar region.
+#         * \param[in] maximum_curvature the maximum curvature
+#         */
+#       inline void
+#       setMaximumCurvature (double maximum_curvature)
+#       {
+#         maximum_curvature_ = maximum_curvature;
+#       }
+# 
+#       /** \brief Get the maximum curvature allowed for a planar region. */
+#       inline double
+#       getMaximumCurvature () const
+#       {
+#         return (maximum_curvature_);
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for segmentation.
+#         * \param[in] compare A pointer to the comparator to be used for segmentation.
+#         */
+#       void
+#       setComparator (const PlaneComparatorPtr& compare)
+#       {
+#         compare_ = compare;
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for refinement.
+#         * \param[in] compare A pointer to the comparator to be used for refinement.
+#         */
+#       void
+#       setRefinementComparator (const PlaneRefinementComparatorPtr& compare)
+#       {
+#         refinement_compare_ = compare;
+#       }
+# 
+#       /** \brief Set whether or not to project boundary points to the plane, or leave them in the original 3D space.
+#         * \param[in] project_points true if points should be projected, false if not.
+#         */
+#       void
+#       setProjectPoints (bool project_points)
+#       {
+#         project_points_ = project_points;
+#       }
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+#         * \param[out] inlier_indices a vector of inliers for each detected plane
+#         * \param[out] centroids a vector of centroids for each plane
+#         * \param[out] covariances a vector of covariance matricies for the inliers of each plane
+#         * \param[out] labels a point cloud for the connected component labels of each pixel
+#         * \param[out] label_indices a vector of PointIndices for each labeled component
+#         */
+#       void
+#       segment (std::vector<ModelCoefficients>& model_coefficients, 
+#                std::vector<PointIndices>& inlier_indices,
+#                std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+#                std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+#                pcl::PointCloud<PointLT>& labels, 
+#                std::vector<pcl::PointIndices>& label_indices);
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+#         * \param[out] inlier_indices a vector of inliers for each detected plane
+#         */
+#       void
+#       segment (std::vector<ModelCoefficients>& model_coefficients, 
+#                std::vector<PointIndices>& inlier_indices);
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] regions a list of resultant planar polygonal regions
+#         */
+#       void
+#       segment (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+#       
+#       /** \brief Perform a segmentation, as well as an additional refinement step.  This helps with including points whose normals may not match neighboring points well, but may match the planar model well.
+#         * \param[out] regions A list of regions generated by segmentation and refinement.
+#         */
+#       void
+#       segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+# 
+#       /** \brief Perform a segmentation, as well as additional refinement step.  Returns intermediate data structures for use in
+#         * subsequent processing.
+#         * \param[out] regions A vector of PlanarRegions generated by segmentation
+#         * \param[out] model_coefficients A vector of model coefficients for each segmented plane
+#         * \param[out] inlier_indices A vector of PointIndices, indicating the inliers to each segmented plane
+#         * \param[out] labels A PointCloud<PointLT> corresponding to the resulting segmentation.
+#         * \param[out] label_indices A vector of PointIndices for each label
+#         * \param[out] boundary_indices A vector of PointIndices corresponding to the outer boundary / contour of each label
+#         */
+#       void
+#       segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions,
+#                         std::vector<ModelCoefficients>& model_coefficients,
+#                         std::vector<PointIndices>& inlier_indices,
+#                         PointCloudLPtr& labels,
+#                         std::vector<pcl::PointIndices>& label_indices,
+#                         std::vector<pcl::PointIndices>& boundary_indices);
+#       
+#       /** \brief Perform a refinement of an initial segmentation, by comparing points to adjacent regions detected by the initial segmentation.
+#         * \param [in] model_coefficients The list of segmented model coefficients
+#         * \param [in] inlier_indices The list of segmented inlier indices, corresponding to each model
+#         * \param [in] centroids The list of centroids corresponding to each segmented plane
+#         * \param [in] covariances The list of covariances corresponding to each segemented plane
+#         * \param [in] labels The labels produced by the initial segmentation
+#         * \param [in] label_indices The list of indices corresponding to each label
+#         */
+#       void
+#       refine (std::vector<ModelCoefficients>& model_coefficients, 
+#               std::vector<PointIndices>& inlier_indices,
+#               std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+#               std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+#               PointCloudLPtr& labels,
+#               std::vector<pcl::PointIndices>& label_indices);
+
+
+###
+
+# planar_polygon_fusion.h
+# namespace pcl
+# /** \brief PlanarPolygonFusion takes a list of 2D planar polygons and
+#   * attempts to reduce them to a minimum set that best represents the scene,
+#   * based on various given comparators.
+#   */
+# template <typename PointT>
+# class PlanarPolygonFusion
+#     public:
+#       /** \brief Constructor */
+#       PlanarPolygonFusion () : regions_ () {}
+#      
+#       /** \brief Destructor */
+#       virtual ~PlanarPolygonFusion () {}
+# 
+#       /** \brief Reset the state (clean the list of planar models). */
+#       void 
+#       reset ()
+#       {
+#         regions_.clear ();
+#       }
+#       
+#       /** \brief Set the list of 2D planar polygons to refine.
+#         * \param[in] input the list of 2D planar polygons to refine
+#         */
+#       void
+#       addInputPolygons (const std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > > &input)
+#       {
+#         int start = static_cast<int> (regions_.size ());
+#         regions_.resize (regions_.size () + input.size ());
+#         for(size_t i = 0; i < input.size (); i++)
+#           regions_[start+i] = input[i];
+#       }
+
+
+###
+
+# planar_region.h
+# namespace pcl
+# /** \brief PlanarRegion represents a set of points that lie in a plane.  Inherits summary statistics about these points from Region3D, and  summary statistics of a 3D collection of points.
+#   * \author Alex Trevor
+#   */
+# template <typename PointT>
+# class PlanarRegion : public pcl::Region3D<PointT>, public pcl::PlanarPolygon<PointT>
+#     protected:
+#       using Region3D<PointT>::centroid_;
+#       using Region3D<PointT>::covariance_; 
+#       using Region3D<PointT>::count_;
+#       using PlanarPolygon<PointT>::contour_;
+#       using PlanarPolygon<PointT>::coefficients_;
+# 
+#     public:
+#       /** \brief Empty constructor for PlanarRegion. */
+#       PlanarRegion () : contour_labels_ ()
+#       {}
+# 
+#       /** \brief Constructor for Planar region from a Region3D and a PlanarPolygon. 
+#         * \param[in] region a Region3D for the input data
+#         * \param[in] polygon a PlanarPolygon for the input region
+#         */
+#       PlanarRegion (const pcl::Region3D<PointT>& region, const pcl::PlanarPolygon<PointT>& polygon) :
+#         contour_labels_ ()
+#       {
+#         centroid_ = region.centroid;
+#         covariance_ = region.covariance;
+#         count_ = region.count;
+#         contour_ = polygon.contour;
+#         coefficients_ = polygon.coefficients;
+#       }
+#       
+#       /** \brief Destructor. */
+#       virtual ~PlanarRegion () {}
+# 
+#       /** \brief Constructor for PlanarRegion.
+#         * \param[in] centroid the centroid of the region.
+#         * \param[in] covariance the covariance of the region.
+#         * \param[in] count the number of points in the region.
+#         * \param[in] contour the contour / boudnary for the region
+#         * \param[in] coefficients the model coefficients (a,b,c,d) for the plane
+#         */
+#       PlanarRegion (const Eigen::Vector3f& centroid, const Eigen::Matrix3f& covariance, unsigned count,
+#                     const typename pcl::PointCloud<PointT>::VectorType& contour,
+#                     const Eigen::Vector4f& coefficients) :
+#         contour_labels_ ()
+#       {
+#         centroid_ = centroid;
+#         covariance_ = covariance;
+#         count_ = count;
+#         contour_ = contour;
+#         coefficients_ = coefficients;
+#       }
+
+
+###
+
+# plane_refinement_comparator.h
+# namespace pcl
+# /** \brief PlaneRefinementComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class PlaneRefinementComparator: public PlaneCoefficientComparator<PointT, PointNT>
+#     public:
+#       typedef typename Comparator<PointT>::PointCloud PointCloud;
+#       typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+#       typedef boost::shared_ptr<PlaneRefinementComparator<PointT, PointNT, PointLT> > Ptr;
+#       typedef boost::shared_ptr<const PlaneRefinementComparator<PointT, PointNT, PointLT> > ConstPtr;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+# 
+#       /** \brief Empty constructor for PlaneCoefficientComparator. */
+#      PlaneRefinementComparator ()
+#         : models_ ()
+#         , labels_ ()
+#         , refine_labels_ ()
+#         , label_to_model_ ()
+#         , depth_dependent_ (false)
+#       
+#       /** \brief Empty constructor for PlaneCoefficientComparator. 
+#         * \param[in] models
+#         * \param[in] refine_labels
+#         */
+#       PlaneRefinementComparator (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models,
+#                                  boost::shared_ptr<std::vector<bool> >& refine_labels)
+#         : models_ (models)
+#         , labels_ ()
+#         , refine_labels_ (refine_labels)
+#         , label_to_model_ ()
+#         , depth_dependent_ (false)
+#       
+#       /** \brief Destructor for PlaneCoefficientComparator. */
+#       virtual
+#       ~PlaneRefinementComparator ()
+#       
+#       /** \brief Set the vector of model coefficients to which we will compare.
+#         * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+#         */
+#       void setModelCoefficients (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models)
+#       
+#       /** \brief Set the vector of model coefficients to which we will compare.
+#         * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+#         */
+#       void setModelCoefficients (std::vector<pcl::ModelCoefficients>& models)
+#       
+#       /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+#         * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+#         */
+#       void setRefineLabels (boost::shared_ptr<std::vector<bool> >& refine_labels)
+#       
+#       /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+#         * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+#         */
+#       void setRefineLabels (std::vector<bool>& refine_labels)
+#       
+#       /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+#         * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+#         */
+#       inline void setLabelToModel (boost::shared_ptr<std::vector<int> >& label_to_model)
+#       
+#       /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+#         * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+#         */
+#       inline void setLabelToModel (std::vector<int>& label_to_model)
+#       
+#       /** \brief Get the vector of model coefficients to which we will compare. */
+#       inline boost::shared_ptr<std::vector<pcl::ModelCoefficients> > getModelCoefficients () const
+#       
+#       /** \brief ...
+#         * \param[in] labels
+#         */
+#       inline void setLabels (PointCloudLPtr& labels)
+#       
+#       /** \brief Compare two neighboring points
+#         * \param[in] idx1 The index of the first point.
+#         * \param[in] idx2 The index of the second point.
+#         */
+#       virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# region_3d.h
+# namespace pcl
+# /** \brief Region3D represents summary statistics of a 3D collection of points.
+#   * \author Alex Trevor
+#   */
+# template <typename PointT>
+# class Region3D
+#     public:
+#       /** \brief Empty constructor for Region3D. */
+#       Region3D () : centroid_ (Eigen::Vector3f::Zero ()), covariance_ (Eigen::Matrix3f::Identity ()), count_ (0)
+#       {
+#       }
+#       
+#       /** \brief Constructor for Region3D. 
+#         * \param[in] centroid The centroid of the region.
+#         * \param[in] covariance The covariance of the region.
+#         * \param[in] count The number of points in the region.
+#         */
+#       Region3D (Eigen::Vector3f& centroid, Eigen::Matrix3f& covariance, unsigned count) 
+#         : centroid_ (centroid), covariance_ (covariance), count_ (count)
+#       {
+#       }
+#      
+#       /** \brief Destructor. */
+#       virtual ~Region3D () {}
+# 
+#       /** \brief Get the centroid of the region. */
+#       inline Eigen::Vector3f getCentroid () const
+#       
+#       /** \brief Get the covariance of the region. */
+#       inline Eigen::Matrix3f getCovariance () const
+#       
+#       /** \brief Get the number of points in the region. */
+#       unsigned getCount () const
+
+
+###
+
+# rgb_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.  Also takes into account RGB, so we can segmented different colored co-planar regions.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Alex Trevor
+#   */
+# template<typename PointT, typename PointNT>
+# class RGBPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+#     public:
+#       typedef typename Comparator<PointT>::PointCloud PointCloud;
+#       typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+#       
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+#       
+#       typedef boost::shared_ptr<RGBPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+#       typedef boost::shared_ptr<const RGBPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+# 
+#       using pcl::Comparator<PointT>::input_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+# 
+#       /** \brief Empty constructor for RGBPlaneCoefficientComparator. */
+#       RGBPlaneCoefficientComparator ()
+#         : color_threshold_ (50.0f)
+#       {
+#       }
+# 
+#       /** \brief Constructor for RGBPlaneCoefficientComparator.
+#         * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+#         */
+#       RGBPlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+#         : PlaneCoefficientComparator<PointT, PointNT> (plane_coeff_d), color_threshold_ (50.0f)
+#       {
+#       }
+#       
+#       /** \brief Destructor for RGBPlaneCoefficientComparator. */
+#       virtual
+#       ~RGBPlaneCoefficientComparator ()
+#       {
+#       }
+# 
+#       /** \brief Set the tolerance in color space between neighboring points, to be considered part of the same plane.
+#         * \param[in] color_threshold The distance in color space
+#         */
+#       inline void
+#       setColorThreshold (float color_threshold)
+#       {
+#         color_threshold_ = color_threshold * color_threshold;
+#       }
+# 
+#       /** \brief Get the color threshold between neighboring points, to be considered part of the same plane. */
+#       inline float
+#       getColorThreshold () const
+#       {
+#         return (color_threshold_);
+#       }
+# 
+#       /** \brief Compare two neighboring points, by using normal information, euclidean distance, and color information.
+#         * \param[in] idx1 The index of the first point.
+#         * \param[in] idx2 The index of the second point.
+#         */
+#       bool
+#       compare (int idx1, int idx2) const
+#       {
+#         float dx = input_->points[idx1].x - input_->points[idx2].x;
+#         float dy = input_->points[idx1].y - input_->points[idx2].y;
+#         float dz = input_->points[idx1].z - input_->points[idx2].z;
+#         float dist = sqrtf (dx*dx + dy*dy + dz*dz);
+#         int dr = input_->points[idx1].r - input_->points[idx2].r;
+#         int dg = input_->points[idx1].g - input_->points[idx2].g;
+#         int db = input_->points[idx1].b - input_->points[idx2].b;
+#         //Note: This is not the best metric for color comparisons, we should probably use HSV space.
+#         float color_dist = static_cast<float> (dr*dr + dg*dg + db*db);
+#         return ( (dist < distance_threshold_)
+#                  && (normals_->points[idx1].getNormalVector3fMap ().dot (normals_->points[idx2].getNormalVector3fMap () ) > angular_threshold_ )
+#                  && (color_dist < color_threshold_));
+#       }
+
+
+###
+
+# segment_differences.h
+# namespace pcl
+# /** \brief Obtain the difference between two aligned point clouds as another point cloud, given a distance threshold.
+#   * \param src the input point cloud source
+#   * \param tgt the input point cloud target we need to obtain the difference against
+#   * \param threshold the distance threshold (tolerance) for point correspondences. (e.g., check if f a point p1 from 
+#   * src has a correspondence > threshold than a point p2 from tgt)
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching built over \a tgt
+#   * \param output the resultant output point cloud difference
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> 
+# void getPointCloudDifference (
+#     const pcl::PointCloud<PointT> &src, const pcl::PointCloud<PointT> &tgt, 
+#     double threshold, const boost::shared_ptr<pcl::search::Search<PointT> > &tree,
+#     pcl::PointCloud<PointT> &output);
+
+# segment_differences.h
+# namespace pcl
+# /** \brief @b SegmentDifferences obtains the difference between two spatially
+#   * aligned point clouds and returns the difference between them for a maximum
+#   * given distance threshold.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class SegmentDifferences: public PCLBase<PointT>
+#     typedef PCLBase<PointT> BasePCLBase;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef typename pcl::search::Search<PointT> KdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+# 
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+# 
+#       /** \brief Empty constructor. */
+#       SegmentDifferences ()
+# 
+#       /** \brief Provide a pointer to the target dataset against which we
+#         * compare the input cloud given in setInputCloud
+#         * \param cloud the target PointCloud dataset
+#       inline void setTargetCloud (const PointCloudConstPtr &cloud)
+# 
+#       /** \brief Get a pointer to the input target point cloud dataset. */
+#       inline PointCloudConstPtr const getTargetCloud ()
+#       /** \brief Provide a pointer to the search object.
+#         * \param tree a pointer to the spatial search object.
+#       inline void setSearchMethod (const KdTreePtr &tree)
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr getSearchMethod ()
+#       /** \brief Set the maximum distance tolerance (squared) between corresponding
+#         * points in the two input datasets.
+#         * \param sqr_threshold the squared distance tolerance as a measure in L2 Euclidean space
+#       inline void setDistanceThreshold (double sqr_threshold)
+#       /** \brief Get the squared distance tolerance between corresponding points as a
+#         * measure in the L2 Euclidean space.
+#       inline double getDistanceThreshold ()
+# 
+#       /** \brief Segment differences between two input point clouds.
+#         * \param output the resultant difference between the two point clouds as a PointCloud
+#         */
+#       void segment (PointCloud &output);
+#       protected:
+#       // Members derived from the base class
+#       using BasePCLBase::input_;
+#       using BasePCLBase::indices_;
+#       using BasePCLBase::initCompute;
+#       using BasePCLBase::deinitCompute;
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+#       /** \brief The input target point cloud dataset. */
+#       PointCloudConstPtr target_;
+#       /** \brief The distance tolerance (squared) as a measure in the L2
+#         * Euclidean space between corresponding points. 
+#         */
+#       double distance_threshold_;
+#       /** \brief Class getName method. */
+#       virtual std::string getClassName () const { return ("SegmentDifferences"); }
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
+
+
+### pcl 1.7.2 ###
+# approximate_progressive_morphological_filter.h
+# namespace pcl
+# /** \brief
+# * Implements the Progressive Morphological Filter for segmentation of ground points.
+# * Description can be found in the article
+# * "A Progressive Morphological Filter for Removing Nonground Measurements from
+# * Airborne LIDAR Data"
+# * by K. Zhang, S. Chen, D. Whitman, M. Shyu, J. Yan, and C. Zhang.
+# */
+# template <typename PointT>
+# class PCL_EXPORTS ApproximateProgressiveMorphologicalFilter : public pcl::PCLBase<PointT>
+        # public:
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # /** \brief Constructor that sets default values for member variables. */
+        # ApproximateProgressiveMorphologicalFilter ();
+        # 
+        # virtual ~ApproximateProgressiveMorphologicalFilter ();
+        # 
+        # /** \brief Get the maximum window size to be used in filtering ground returns. */
+        # inline int getMaxWindowSize () const { return (max_window_size_); }
+        # 
+        # /** \brief Set the maximum window size to be used in filtering ground returns. */
+        # inline void setMaxWindowSize (int max_window_size) { max_window_size_ = max_window_size; }
+        # 
+        # /** \brief Get the slope value to be used in computing the height threshold. */
+        # inline float getSlope () const { return (slope_); }
+        # 
+        # /** \brief Set the slope value to be used in computing the height threshold. */
+        # inline void setSlope (float slope) { slope_ = slope; }
+        # 
+        # /** \brief Get the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline float getMaxDistance () const { return (max_distance_); }
+        # 
+        # /** \brief Set the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline void setMaxDistance (float max_distance) { max_distance_ = max_distance; }
+        # 
+        # /** \brief Get the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline float getInitialDistance () const { return (initial_distance_); }
+        # 
+        # /** \brief Set the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline void setInitialDistance (float initial_distance) { initial_distance_ = initial_distance; }
+        # 
+        # /** \brief Get the cell size. */
+        # inline float getCellSize () const { return (cell_size_); }
+        # 
+        # /** \brief Set the cell size. */
+        # inline void setCellSize (float cell_size) { cell_size_ = cell_size; }
+        # 
+        # /** \brief Get the base to be used in computing progressive window sizes. */
+        # inline float getBase () const { return (base_); }
+        # 
+        # /** \brief Set the base to be used in computing progressive window sizes. */
+        # inline void setBase (float base) { base_ = base; }
+        # 
+        # /** \brief Get flag indicating whether or not to exponentially grow window sizes? */
+        # inline bool getExponential () const { return (exponential_); }
+        # 
+        # /** \brief Set flag indicating whether or not to exponentially grow window sizes? */
+        # inline void setExponential (bool exponential) { exponential_ = exponential; }
+        # 
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void setNumberOfThreads (unsigned int nr_threads = 0) { threads_ = nr_threads; }
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns indices of
+        # * points determined to be ground returns.
+        # * \param[out] ground indices of points determined to be ground returns.
+        # */
+        # virtual void extract (std::vector<int>& ground);
+
+
+###
+
+# boost.h
+###
+
+# conditional_euclidean_clustering.h
+# namespace pcl
+# typedef std::vector<pcl::PointIndices> IndicesClusters;
+# typedef boost::shared_ptr<std::vector<pcl::PointIndices> > IndicesClustersPtr;
+# 
+# /** \brief @b ConditionalEuclideanClustering performs segmentation based on Euclidean distance and a user-defined clustering condition.
+#   * \details The condition that need to hold is currently passed using a function pointer.
+#   * For more information check the documentation of setConditionFunction() or the usage example below:
+#   * \code
+#   * bool
+#   * enforceIntensitySimilarity (const pcl::PointXYZI& point_a, const pcl::PointXYZI& point_b, float squared_distance)
+#   * {
+#   *   if (fabs (point_a.intensity - point_b.intensity) < 0.1f)
+#   *     return (true);
+#   *   else
+#   *     return (false);
+#   * }
+#   * // ...
+#   * // Somewhere down to the main code
+#   * // ...
+#   * pcl::ConditionalEuclideanClustering<pcl::PointXYZI> cec (true);
+#   * cec.setInputCloud (cloud_in);
+#   * cec.setConditionFunction (&enforceIntensitySimilarity);
+#   * // Points within this distance from one another are going to need to validate the enforceIntensitySimilarity function to be part of the same cluster:
+#   * cec.setClusterTolerance (0.09f);
+#   * // Size constraints for the clusters:
+#   * cec.setMinClusterSize (5);
+#   * cec.setMaxClusterSize (30);
+#   * // The resulting clusters (an array of pointindices):
+#   * cec.segment (*clusters);
+#   * // The clusters that are too small or too large in size can also be extracted separately:
+#   * cec.getRemovedClusters (small_clusters, large_clusters);
+#   * \endcode
+#   * \author Frits Florentinus
+#   * \ingroup segmentation
+#   */
+# template<typename PointT>
+# class ConditionalEuclideanClustering : public PCLBase<PointT>
+        # protected:
+        # typedef typename pcl::search::Search<PointT>::Ptr SearcherPtr;
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # 
+        # public:
+        # /** \brief Constructor.
+        # * \param[in] extract_removed_clusters Set to true if you want to be able to extract the clusters that are too large or too small (default = false)
+        # */
+        # ConditionalEuclideanClustering (bool extract_removed_clusters = false) :
+        #   searcher_ (),
+        #   condition_function_ (),
+        #   cluster_tolerance_ (0.0f),
+        #   min_cluster_size_ (1),
+        #   max_cluster_size_ (std::numeric_limits<int>::max ()),
+        #   extract_removed_clusters_ (extract_removed_clusters),
+        #   small_clusters_ (new pcl::IndicesClusters),
+        #   large_clusters_ (new pcl::IndicesClusters)
+		# 
+        # 
+        # /** \brief Set the condition that needs to hold for neighboring points to be considered part of the same cluster.
+        # * \details Any two points within a certain distance from one another will need to evaluate this condition in order to be made part of the same cluster.
+        # * The distance can be set using setClusterTolerance().
+        # * <br>
+        # * Note that for a point to be part of a cluster, the condition only needs to hold for at least 1 point pair.
+        # * To clarify, the following statement is false:
+        # * Any two points within a cluster always evaluate this condition function to true.
+        # * <br><br>
+        # * The input arguments of the condition function are:
+        # * <ul>
+        # *  <li>PointT The first point of the point pair</li>
+        # *  <li>PointT The second point of the point pair</li>
+        # *  <li>float The squared distance between the points</li>
+        # * </ul>
+        # * The output argument is a boolean, returning true will merge the second point into the cluster of the first point.
+        # * \param[in] condition_function The condition function that needs to hold for clustering
+        # */
+        # inline void setConditionFunction (bool (*condition_function) (const PointT&, const PointT&, float)) 
+        # 
+        # /** \brief Set the spatial tolerance for new cluster candidates.
+        # * \details Any two points within this distance from one another will need to evaluate a certain condition in order to be made part of the same cluster.
+        # * The condition can be set using setConditionFunction().
+        # * \param[in] cluster_tolerance The distance to scan for cluster candidates (default = 0.0)
+        # */
+        # inline void setClusterTolerance (float cluster_tolerance)
+        # 
+        # /** \brief Get the spatial tolerance for new cluster candidates.*/
+        # inline float getClusterTolerance ()
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # * \param[in] min_cluster_size The minimum cluster size (default = 1)
+        # */
+        # inline void setMinClusterSize (int min_cluster_size)
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid.*/
+        # inline int getMinClusterSize ()
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # * \param[in] max_cluster_size The maximum cluster size (default = unlimited)
+        # */
+        # inline void setMaxClusterSize (int max_cluster_size)
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid.*/
+        # inline int getMaxClusterSize ()
+        # 
+        # /** \brief Segment the input into separate clusters.
+        # * \details The input can be set using setInputCloud() and setIndices().
+        # * <br>
+        # * The size constraints for the resulting clusters can be set using setMinClusterSize() and setMaxClusterSize().
+        # * <br>
+        # * The region growing parameters can be set using setConditionFunction() and setClusterTolerance().
+        # * <br>
+        # * \param[out] clusters The resultant set of indices, indexing the points of the input cloud that correspond to the clusters
+        # */
+        # void segment (IndicesClusters &clusters);
+        # 
+        # /** \brief Get the clusters that are invalidated due to size constraints.
+        # * \note The constructor of this class needs to be initialized with true, and the segment method needs to have been called prior to using this method.
+        # * \param[out] small_clusters The resultant clusters that contain less than min_cluster_size points
+        # * \param[out] large_clusters The resultant clusters that contain more than max_cluster_size points
+        # */
+        # inline void getRemovedClusters (IndicesClustersPtr &small_clusters, IndicesClustersPtr &large_clusters)
+
+
+###
+
+# crf_normal_segmentation.h
+# namespace pcl
+# /** \brief
+# * \author Christian Potthast
+# * 
+# */
+# template <typename PointT>
+# class PCL_EXPORTS CrfNormalSegmentation
+        # public:
+        # 
+        # /** \brief Constructor that sets default values for member variables. */
+        # CrfNormalSegmentation ();
+        # 
+        # /** \brief Destructor that frees memory. */
+        # ~CrfNormalSegmentation ();
+        # 
+        # /** \brief This method sets the input cloud.
+        # * \param[in] input_cloud input point cloud
+        # */
+        # void setCloud (typename pcl::PointCloud<PointT>::Ptr input_cloud);
+        # 
+        # /** \brief This method simply launches the segmentation algorithm */
+        # void segmentPoints ();
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+# /** boost implementation of Boykov and Kolmogorov's maxflow algorithm doesn't support
+# * negative flows which makes it inappropriate for this conext.
+# * This implementation of Boykov and Kolmogorov's maxflow algorithm by Stephen Gould
+# * <stephen.gould@anu.edu.au> in DARWIN under BSD does the trick however solwer than original
+# * implementation.
+# */
+# class PCL_EXPORTS BoykovKolmogorov
+        # public:
+        # typedef int vertex_descriptor;
+        # typedef double edge_capacity_type;
+        # 
+        # /// construct a maxflow/mincut problem with estimated max_nodes
+        # BoykovKolmogorov (std::size_t max_nodes = 0);
+        # 
+        # /// destructor
+        # virtual ~BoykovKolmogorov () {}
+        # 
+        # /// get number of nodes in the graph
+        # size_t numNodes () const { return nodes_.size (); }
+        # 
+        # /// reset all edge capacities to zero (but don't free the graph)
+        # void reset ();
+        # 
+        # /// clear the graph and internal datastructures
+        # void clear ();
+        # 
+        # /// add nodes to the graph (returns the id of the first node added)
+        # int addNodes (std::size_t n = 1);
+        # 
+        # /// add constant flow to graph
+        # void addConstant (double c) { flow_value_ += c; }
+        # 
+        # /// add edge from s to nodeId
+        # void addSourceEdge (int u, double cap);
+        # 
+        # /// add edge from nodeId to t
+        # void addTargetEdge (int u, double cap);
+        # 
+        # /// add edge from u to v and edge from v to u
+        # /// (requires cap_uv + cap_vu >= 0)
+        # void addEdge (int u, int v, double cap_uv, double cap_vu = 0.0);
+        # 
+        # /// solve the max-flow problem and return the flow
+        # double solve ();
+        # 
+        # /// return true if \p u is in the s-set after calling \ref solve.
+        # bool inSourceTree (int u) const { return (cut_[u] == SOURCE); }
+        # 
+        # /// return true if \p u is in the t-set after calling \ref solve
+        # bool inSinkTree (int u) const { return (cut_[u] == TARGET); }
+        # 
+        # /// returns the residual capacity for an edge (use -1 for terminal (-1,-1) is the current flow
+        # double operator() (int u, int v) const;
+        # 
+        # double getSourceEdgeCapacity (int u) const;
+        # 
+        # double getTargetEdgeCapacity (int u) const;
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+      	# /**\brief Structure to save RGB colors into floats */
+      	# struct Color
+      	# {
+      	#   Color () : r (0), g (0), b (0) {}
+      	#   Color (float _r, float _g, float _b) : r(_r), g(_g), b(_b) {}
+      	#   Color (const pcl::RGB& color) : r (color.r), g (color.g), b (color.b) {}
+		# 
+        # template<typename PointT> Color (const PointT& p);
+		# 
+        # template<typename PointT> operator PointT () const;
+		# 
+        # float r, g, b;
+      	# };
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+        # /// An Image is a point cloud of Color
+        # typedef pcl::PointCloud<Color> Image;
+        # 
+        # /** \brief Compute squared distance between two colors
+        # * \param[in] c1 first color
+        # * \param[in] c2 second color
+        # * \return the squared distance measure in RGB space
+        # */
+        # float colorDistance (const Color& c1, const Color& c2);
+        # 
+        # /// User supplied Trimap values
+        # enum TrimapValue { TrimapUnknown = -1, TrimapForeground, TrimapBackground };
+        # 
+        # /// Grabcut derived hard segementation values
+        # enum SegmentationValue { SegmentationForeground = 0, SegmentationBackground };
+        # 
+        # /// Gaussian structure
+        # struct Gaussian
+        # {
+        #     Gaussian () {}
+        #     /// mean of the gaussian
+        #     Color mu;
+        #     /// covariance matrix of the gaussian
+        #     Eigen::Matrix3f covariance;
+        #     /// determinant of the covariance matrix
+        #     float determinant;
+        #     /// inverse of the covariance matrix
+        #     Eigen::Matrix3f inverse;
+        #     /// weighting of this gaussian in the GMM.
+        #     float pi;
+        #     /// heighest eigenvalue of covariance matrix
+        #     float eigenvalue;
+        #     /// eigenvector corresponding to the heighest eigenvector
+        #     Eigen::Vector3f eigenvector;
+        # };
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+# class PCL_EXPORTS GMM
+        # public:
+        #   /// Initialize GMM with ddesired number of gaussians.
+        #   GMM () : gaussians_ (0) {}
+        #   /// Initialize GMM with ddesired number of gaussians.
+        #   GMM (std::size_t K) : gaussians_ (K) {}
+        #   /// Destructor
+        #   ~GMM () {}
+        # 
+        # /// \return K
+        # std::size_t getK () const { return gaussians_.size (); }
+        # 
+        #   /// resize gaussians
+        #   void resize (std::size_t K) { gaussians_.resize (K); }
+        #   
+        #   /// \return a reference to the gaussian at a given position
+        #   Gaussian& operator[] (std::size_t pos) { return (gaussians_[pos]); }
+        # 
+        #   /// \return a const reference to the gaussian at a given position
+        #   const Gaussian& operator[] (std::size_t pos) const { return (gaussians_[pos]); }
+        # 
+        #   /// \brief \return the computed probability density of a color in this GMM
+        #   float probabilityDensity (const Color &c);
+        # 
+        #   /// \brief \return the computed probability density of a color in just one Gaussian
+        #   float probabilityDensity(std::size_t i, const Color &c);
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+# /** Helper class that fits a single Gaussian to color samples */
+# class GaussianFitter
+        # public:
+        # GaussianFitter (float epsilon = 0.0001)
+        #   : sum_ (Eigen::Vector3f::Zero ())
+        #   , accumulator_ (Eigen::Matrix3f::Zero ())
+        #   , count_ (0)
+        #   , epsilon_ (epsilon)
+        # { }
+		# 
+        # /// Add a color sample
+        # void add (const Color &c);
+        # 
+        # /// Build the gaussian out of all the added color samples
+        # void fit (Gaussian& g, std::size_t total_count, bool compute_eigens = false) const;
+        # 
+        # /// \return epsilon
+        # float getEpsilon () { return (epsilon_); }
+        # 
+        # /** set epsilon which will be added to the covariance matrix diagonal which avoids singular
+        #   * covariance matrix
+        #   * \param[in] epsilon user defined epsilon
+        #   */
+        # void setEpsilon (float epsilon) { epsilon_ = epsilon; }
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+      	# /** Build the initial GMMs using the Orchard and Bouman color clustering algorithm */
+      	# PCL_EXPORTS void buildGMMs (const Image &image,
+        #          const std::vector<int>& indices,
+        #          const std::vector<SegmentationValue> &hardSegmentation,
+        #          std::vector<std::size_t> &components,
+        #          GMM &background_GMM, GMM &foreground_GMM);
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+		# /** Iteratively learn GMMs using GrabCut updating algorithm */
+      	# PCL_EXPORTS void learnGMMs (const Image& image,
+        #          				const std::vector<int>& indices,
+        #          				const std::vector<SegmentationValue>& hard_segmentation,
+        #          				std::vector<std::size_t>& components,
+        #          				GMM& background_GMM, GMM& foreground_GMM);
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# /** \brief Implementation of the GrabCut segmentation in
+# * "GrabCut — Interactive Foreground Extraction using Iterated Graph Cuts" by
+# * Carsten Rother, Vladimir Kolmogorov and Andrew Blake.
+# * \author Justin Talbot, jtalbot@stanford.edu placed in Public Domain, 2010
+# * \author Nizar Sallem port to PCL and adaptation of original code.
+# * \ingroup segmentation
+# */
+# template <typename PointT>
+# class GrabCut : public pcl::PCLBase<PointT>
+        # public:
+        # typedef typename pcl::search::Search<PointT> KdTree;
+        # typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # typedef typename PCLBase<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename PCLBase<PointT>::PointCloudPtr PointCloudPtr;
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::fake_indices_;
+        # 
+        # /// Constructor
+        # GrabCut (uint32_t K = 5, float lambda = 50.f)
+        # : K_ (K)
+        # , lambda_ (lambda)
+        # , nb_neighbours_ (9)
+        # , initialized_ (false)
+        # {}
+        # 
+        # /// Desctructor
+        # virtual ~GrabCut () {};
+        # 
+        # // /// Set input cloud
+        # void setInputCloud (const PointCloudConstPtr& cloud);
+        # 
+        # /// Set background points, foreground points = points \ background points
+        # void setBackgroundPoints (const PointCloudConstPtr& background_points);
+        # 
+        # /// Set background indices, foreground indices = indices \ background indices
+        # void setBackgroundPointsIndices (int x1, int y1, int x2, int y2);
+        # 
+        # /// Set background indices, foreground indices = indices \ background indices
+        # void setBackgroundPointsIndices (const PointIndicesConstPtr& indices);
+        # 
+        # /// Run Grabcut refinement on the hard segmentation
+        # virtual void refine ();
+        # 
+        # /// \return the number of pixels that have changed from foreground to background or vice versa
+        # virtual int refineOnce ();
+        # 
+        # /// \return lambda
+        # float getLambda () { return (lambda_); }
+        # 
+        # /** Set lambda parameter to user given value. Suggested value by the authors is 50
+        # * \param[in] lambda
+        # */
+        # void setLambda (float lambda) { lambda_ = lambda; }
+        # 
+        # /// \return the number of components in the GMM
+        # uint32_t getK () { return (K_); }
+        # 
+        # /** Set K parameter to user given value. Suggested value by the authors is 5
+        # * \param[in] K the number of components used in GMM
+        # */
+        # void setK (uint32_t K) { K_ = K; }
+        # 
+        # /** \brief Provide a pointer to the search object.
+        # * \param tree a pointer to the spatial search object.
+        # */
+        # inline void setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+        # 
+        # /** \brief Get a pointer to the search method used. */
+        # inline KdTreePtr getSearchMethod () { return (tree_); }
+        # 
+        # /** \brief Allows to set the number of neighbours to find.
+        # * \param[in] nb_neighbours new number of neighbours
+        # */
+        # void setNumberOfNeighbours (int nb_neighbours) { nb_neighbours_ = nb_neighbours; }
+        # 
+        # /** \brief Returns the number of neighbours to find. */
+        # int getNumberOfNeighbours () const { return (nb_neighbours_); }
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        # * obtained during the segmentation. The indices of points belonging to the object will be stored
+        # * in the cluster with index 1, other indices will be stored in the cluster with index 0.
+        # * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        # */
+        # void extract (std::vector<pcl::PointIndices>& clusters);
+
+
+###
+
+# ground_plane_comparator.h
+# namespace pcl
+# /** \brief GroundPlaneComparator is a Comparator for detecting smooth surfaces suitable for driving.
+# * In conjunction with OrganizedConnectedComponentSegmentation, this allows smooth groundplanes / road surfaces to be segmented from point clouds.
+# * \author Alex Trevor
+# */
+# template<typename PointT, typename PointNT>
+# class GroundPlaneComparator: public Comparator<PointT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<GroundPlaneComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const GroundPlaneComparator<PointT, PointNT> > ConstPtr;
+        # 
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # /** \brief Empty constructor for GroundPlaneComparator. */
+        # GroundPlaneComparator ()
+        # : normals_ ()
+        # , plane_coeff_d_ ()
+        # , angular_threshold_ (cosf (pcl::deg2rad (2.0f)))
+        # , road_angular_threshold_ ( cosf(pcl::deg2rad (10.0f)))
+        # , distance_threshold_ (0.1f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0, 0.0, 1.0) )
+        # , desired_road_axis_ (Eigen::Vector3f(0.0, -1.0, 0.0))
+        # 
+        # /** \brief Constructor for GroundPlaneComparator.
+        # * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+        # */
+        # GroundPlaneComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+        # : normals_ ()
+        # , plane_coeff_d_ (plane_coeff_d)
+        # , angular_threshold_ (cosf (pcl::deg2rad (3.0f)))
+        # , distance_threshold_ (0.1f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0f, 0.0f, 1.0f))
+        # , road_angular_threshold_ ( cosf(pcl::deg2rad (40.0f)))
+        # , desired_road_axis_ (Eigen::Vector3f(0.0, -1.0, 0.0))
+        # 
+        # /** \brief Destructor for GroundPlaneComparator. */
+        # virtual ~GroundPlaneComparator ()
+        # 
+        # /** \brief Provide the input cloud.
+        # * \param[in] cloud the input point cloud.
+        # */
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # 
+        # /** \brief Provide a pointer to the input normals.
+        # * \param[in] normals the input normal cloud.
+        # */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # 
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        # * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # */
+        # void setPlaneCoeffD (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        # * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # */
+        # void setPlaneCoeffD (std::vector<float>& plane_coeff_d)
+        # 
+        # /** \brief Get a pointer to the vector of the d-coefficient of the planes' hessian normal form. */
+        # const std::vector<float>& getPlaneCoeffD () const
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        # * \param[in] angular_threshold the tolerance in radians
+        # */
+        # virtual void setAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between a point and the expected ground normal.
+        # * \param[in] angular_threshold the
+        # */
+        # virtual void setGroundAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Set the expected ground plane normal with respect to the sensor.  Pixels labeled as ground must be within ground_angular_threshold radians of this normal to be labeled as ground.
+        # * \param[in] normal The normal direction of the expected ground plane.
+        # */
+        # void setExpectedGroundNormal (Eigen::Vector3f normal)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        # 
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        # * \param[in] distance_threshold the tolerance in meters (at 1m)
+        # * \param[in] depth_dependent whether to scale the threshold based on range from the sensor (default: false)
+        # */
+        # void setDistanceThreshold (float distance_threshold, bool depth_dependent = false)
+        # 
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        # 
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        # * and the difference between the d component of the normals is less than distance threshold, else false
+        # * \param idx1 The first index for the comparison
+        # * \param idx2 The second index for the comparison
+        # */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# min_cut_segmentation.h
+# namespace pcl
+# template <typename PointT>
+# class PCL_EXPORTS MinCutSegmentation : public pcl::PCLBase<PointT>
+cdef extern from "pcl/segmentation/min_cut_segmentation.h" namespace "pcl":
+    cdef cppclass MinCutSegmentation[T](PCLBase[T]):
+        MinCutSegmentation()
+        # public:
+        # typedef pcl::search::Search <PointT> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::PointCloud< PointT > PointCloud;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # typedef boost::adjacency_list_traits< boost::vecS, boost::vecS, boost::directedS > Traits;
+        # typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS,
+        #                              boost::property< boost::vertex_name_t, std::string,
+        #                                boost::property< boost::vertex_index_t, long,
+        #                                  boost::property< boost::vertex_color_t, boost::default_color_type,
+        #                                    boost::property< boost::vertex_distance_t, long,
+        #                                      boost::property< boost::vertex_predecessor_t, Traits::edge_descriptor > > > > >,
+        #                              boost::property< boost::edge_capacity_t, double,
+        #                                boost::property< boost::edge_residual_capacity_t, double,
+        #                                  boost::property< boost::edge_reverse_t, Traits::edge_descriptor > > > > mGraph;
+        # typedef boost::property_map< mGraph, boost::edge_capacity_t >::type CapacityMap;
+        # typedef boost::property_map< mGraph, boost::edge_reverse_t>::type ReverseEdgeMap;
+        # typedef Traits::vertex_descriptor VertexDescriptor;
+        # typedef boost::graph_traits< mGraph >::edge_descriptor EdgeDescriptor;
+        # typedef boost::graph_traits< mGraph >::out_edge_iterator OutEdgeIterator;
+        # typedef boost::graph_traits< mGraph >::vertex_iterator VertexIterator;
+        # typedef boost::property_map< mGraph, boost::edge_residual_capacity_t >::type ResidualCapacityMap;
+        # typedef boost::property_map< mGraph, boost::vertex_index_t >::type IndexMap;
+        # typedef boost::graph_traits< mGraph >::in_edge_iterator InEdgeIterator;
+        # public:
+        # /** \brief This method simply sets the input point cloud.
+        #   * \param[in] cloud the const boost shared pointer to a PointCloud
+        # virtual void setInputCloud (const PointCloudConstPtr &cloud);
+        # /** \brief Returns normalization value for binary potentials. For more information see the article. */
+        double getSigma ()
+        # /** \brief Allows to set the normalization value for the binary potentials as described in the article.
+        #   * \param[in] sigma new normalization value
+        void setSigma (double sigma)
+        # /** \brief Returns radius to the background. */
+        double getRadius ()
+        # /** \brief Allows to set the radius to the background.
+        #   * \param[in] radius new radius to the background
+        void setRadius (double radius)
+        # /** \brief Returns weight that every edge from the source point has. */
+        double getSourceWeight ()
+        # /** \brief Allows to set weight for source edges. Every edge that comes from the source point will have that weight.
+        #   * \param[in] weight new weight
+        void setSourceWeight (double weight)
+        # /** \brief Returns search method that is used for finding KNN.
+        #   * The graph is build such way that it contains the edges that connect point and its KNN.
+        # KdTreePtr getSearchMethod () const;
+        # /** \brief Allows to set search method for finding KNN.
+        #   * The graph is build such way that it contains the edges that connect point and its KNN.
+        #   * \param[in] search search method that will be used for finding KNN.
+        # void setSearchMethod (const KdTreePtr& tree);
+        # /** \brief Returns the number of neighbours to find. */
+        unsigned int getNumberOfNeighbours ()
+        # /** \brief Allows to set the number of neighbours to find.
+        #   * \param[in] number_of_neighbours new number of neighbours
+        void setNumberOfNeighbours (unsigned int neighbour_number)
+        # /** \brief Returns the points that must belong to foreground. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > getForegroundPoints () const;
+        # /** \brief Allows to specify points which are known to be the points of the object.
+        #   * \param[in] foreground_points point cloud that contains foreground points. At least one point must be specified.
+        # void setForegroundPoints (typename pcl::PointCloud<PointT>::Ptr foreground_points);
+        # /** \brief Returns the points that must belong to background. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > getBackgroundPoints () const;
+        # /** \brief Allows to specify points which are known to be the points of the background.
+        #   * \param[in] background_points point cloud that contains background points.
+        # void setBackgroundPoints (typename pcl::PointCloud<PointT>::Ptr background_points);
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        #   * obtained during the segmentation. The indices of points that belong to the object will be stored
+        #   * in the cluster with index 1, other indices will be stored in the cluster with index 0.
+        #   * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        # void extract (vector <pcl::PointIndices>& clusters);
+        # /** \brief Returns that flow value that was calculated during the segmentation. */
+        double getMaxFlow ()
+        # /** \brief Returns the graph that was build for finding the minimum cut. */
+        # typename boost::shared_ptr<typename pcl::MinCutSegmentation<PointT>::mGraph> getGraph () const;
+        # /** \brief Returns the colored cloud. Points that belong to the object have the same color. */
+        # pcl::PointCloud<pcl::PointXYZRGB>::Ptr getColoredCloud ();
+        # protected:
+        # /** \brief This method simply builds the graph that will be used during the segmentation. */
+        bool buildGraph ()
+        # /** \brief Returns unary potential(data cost) for the given point index.
+        #   * In other words it calculates weights for (source, point) and (point, sink) edges.
+        #   * \param[in] point index of the point for which weights will be calculated
+        #   * \param[out] source_weight calculated weight for the (source, point) edge
+        #   * \param[out] sink_weight calculated weight for the (point, sink) edge
+        void calculateUnaryPotential (int point, double& source_weight, double& sink_weight)
+        # /** \brief This method simply adds the edge from the source point to the target point with a given weight.
+        #   * \param[in] source index of the source point of the edge
+        #   * \param[in] target index of the target point of the edge
+        #   * \param[in] weight weight that will be assigned to the (source, target) edge
+        bool addEdge (int source, int target, double weight)
+        # /** \brief Returns the binary potential(smooth cost) for the given indices of points.
+        #   * In other words it returns weight that must be assigned to the edge from source to target point.
+        #   * \param[in] source index of the source point of the edge
+        #   * \param[in] target index of the target point of the edge
+        double calculateBinaryPotential (int source, int target)
+        # brief This method recalculates unary potentials(data cost) if some changes were made, instead of creating new graph. */
+        bool recalculateUnaryPotentials ()
+        # brief This method recalculates binary potentials(smooth cost) if some changes were made, instead of creating new graph. */
+        bool recalculateBinaryPotentials ()
+        # /** \brief This method analyzes the residual network and assigns a label to every point in the cloud.
+        #   * \param[in] residual_capacity residual network that was obtained during the segmentation
+        # void assembleLabels (ResidualCapacityMap& residual_capacity);
+        # protected:
+        # /** \brief Stores the sigma coefficient. It is used for finding smooth costs. More information can be found in the article. */
+        # double inverse_sigma_;
+        # /** \brief Signalizes if the binary potentials are valid. */
+        # bool binary_potentials_are_valid_;
+        # /** \brief Used for comparison of the floating point numbers. */
+        # double epsilon_;
+        # /** \brief Stores the distance to the background. */
+        # double radius_;
+        # /** \brief Signalizes if the unary potentials are valid. */
+        # bool unary_potentials_are_valid_;
+        # /** \brief Stores the weight for every edge that comes from source point. */
+        # double source_weight_;
+        # /** \brief Stores the search method that will be used for finding K nearest neighbors. Neighbours are used for building the graph. */
+        # KdTreePtr search_;
+        # /** \brief Stores the number of neighbors to find. */
+        # unsigned int number_of_neighbours_;
+        # /** \brief Signalizes if the graph is valid. */
+        # bool graph_is_valid_;
+        # /** \brief Stores the points that are known to be in the foreground. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > foreground_points_;
+        # /** \brief Stores the points that are known to be in the background. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > background_points_;
+        # /** \brief After the segmentation it will contain the segments. */
+        # std::vector <pcl::PointIndices> clusters_;
+        # /** \brief Stores the graph for finding the maximum flow. */
+        # boost::shared_ptr<mGraph> graph_;
+        # /** \brief Stores the capacity of every edge in the graph. */
+        # boost::shared_ptr<CapacityMap> capacity_;
+        # /** \brief Stores reverse edges for every edge in the graph. */
+        # boost::shared_ptr<ReverseEdgeMap> reverse_edges_;
+        # /** \brief Stores the vertices of the graph. */
+        # std::vector< VertexDescriptor > vertices_;
+        # /** \brief Stores the information about the edges that were added to the graph. It is used to avoid the duplicate edges. */
+        # std::vector< std::set<int> > edge_marker_;
+        # /** \brief Stores the vertex that serves as source. */
+        # VertexDescriptor source_;
+        # /** \brief Stores the vertex that serves as sink. */
+        # VertexDescriptor sink_;
+        # /** \brief Stores the maximum flow value that was calculated during the segmentation. */
+        # double max_flow_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+
+
+# organized_connected_component_segmentation.h
+# namespace pcl
+# /** \brief OrganizedConnectedComponentSegmentation allows connected
+#   * components to be found within organized point cloud data, given a
+#   * comparison function.  Given an input cloud and a comparator, it will
+#   * output a PointCloud of labels, giving each connected component a unique
+#   * id, along with a vector of PointIndices corresponding to each component.
+#   * See OrganizedMultiPlaneSegmentation for an example application.
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template <typename PointT, typename PointLT>
+# class OrganizedConnectedComponentSegmentation : public PCLBase<PointT>
+# {
+cdef extern from "pcl/segmentation/organized_connected_component_segmentation.h" namespace "pcl":
+    cdef cppclass OrganizedConnectedComponentSegmentation[T, LT](PCLBase[T]):
+        OrganizedConnectedComponentSegmentation()
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # 
+        # public:
+        # typedef typename pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # 
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # typedef typename pcl::Comparator<PointT> Comparator;
+        # typedef typename Comparator::Ptr ComparatorPtr;
+        # typedef typename Comparator::ConstPtr ComparatorConstPtr;
+        # 
+        # /** \brief Constructor for OrganizedConnectedComponentSegmentation
+        #  * \param[in] compare A pointer to the comparator to be used for segmentation.  Must be an instance of pcl::Comparator.
+        # */
+        # OrganizedConnectedComponentSegmentation (const ComparatorConstPtr& compare) : compare_ (compare)
+        # /** \brief Destructor for OrganizedConnectedComponentSegmentation. */
+        # virtual ~OrganizedConnectedComponentSegmentation ()
+        # 
+        # /** \brief Provide a pointer to the comparator to be used for segmentation.
+        #  * \param[in] compare the comparator
+        # */
+        # void setComparator (const ComparatorConstPtr& compare)
+        # 
+        # /** \brief Get the comparator.*/
+        # ComparatorConstPtr getComparator () const { return (compare_); }
+        # 
+        # /** \brief Perform the connected component segmentation.
+        #  * \param[out] labels a PointCloud of labels: each connected component will have a unique id.
+        #  * \param[out] label_indices a vector of PointIndices corresponding to each label / component id.
+        # */
+        # void segment (pcl::PointCloud<PointLT>& labels, std::vector<pcl::PointIndices>& label_indices) const;
+        # 
+        # /** \brief Find the boundary points / contour of a connected component
+        #  * \param[in] start_idx the first (lowest) index of the connected component for which a boundary shoudl be returned
+        #  * \param[in] labels the Label cloud produced by segmentation
+        #  * \param[out] boundary_indices the indices of the boundary points for the label corresponding to start_idx
+        # */
+        # static void findLabeledRegionBoundary (int start_idx, PointCloudLPtr labels, pcl::PointIndices& boundary_indices);      
+
+
+###
+
+# organized_multi_plane_segmentation.h
+# namespace pcl
+# {
+# /** \brief OrganizedMultiPlaneSegmentation finds all planes present in the
+# * input cloud, and outputs a vector of plane equations, as well as a vector
+# * of point clouds corresponding to the inliers of each detected plane.  Only
+# * planes with more than min_inliers points are detected.
+# * Templated on point type, normal type, and label type
+# *
+# * \author Alex Trevor, Suat Gedikli
+# */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class OrganizedMultiPlaneSegmentation : public PCLBase<PointT>
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # 
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # typedef typename pcl::PlaneCoefficientComparator<PointT, PointNT> PlaneComparator;
+        # typedef typename PlaneComparator::Ptr PlaneComparatorPtr;
+        # typedef typename PlaneComparator::ConstPtr PlaneComparatorConstPtr;
+        # typedef typename pcl::PlaneRefinementComparator<PointT, PointNT, PointLT> PlaneRefinementComparator;
+        # typedef typename PlaneRefinementComparator::Ptr PlaneRefinementComparatorPtr;
+        # typedef typename PlaneRefinementComparator::ConstPtr PlaneRefinementComparatorConstPtr;
+        # 
+        # /** \brief Constructor for OrganizedMultiPlaneSegmentation. */
+        # OrganizedMultiPlaneSegmentation () :
+        # normals_ (), 
+        # min_inliers_ (1000), 
+        # angular_threshold_ (pcl::deg2rad (3.0)), 
+        # distance_threshold_ (0.02),
+        # maximum_curvature_ (0.001),
+        # project_points_ (false), 
+        # compare_ (new PlaneComparator ()), refinement_compare_ (new PlaneRefinementComparator ())
+        # 
+        # /** \brief Destructor for OrganizedMultiPlaneSegmentation. */
+        # virtual ~OrganizedMultiPlaneSegmentation ()
+        # 
+        # /** \brief Provide a pointer to the input normals.
+        # * \param[in] normals the input normal cloud
+        # */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) 
+        # 
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        # 
+        # /** \brief Set the minimum number of inliers required for a plane
+        # * \param[in] min_inliers the minimum number of inliers required per plane
+        # */
+        # inline void setMinInliers (unsigned min_inliers)
+        # 
+        # /** \brief Get the minimum number of inliers required per plane. */
+        # inline unsigned getMinInliers () const
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        # * \param[in] angular_threshold the tolerance in radians
+        # */
+        # inline void setAngularThreshold (double angular_threshold)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline double getAngularThreshold () const
+        # 
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        # * \param[in] distance_threshold the tolerance in meters
+        # */
+        # inline void setDistanceThreshold (double distance_threshold)
+        # 
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline double getDistanceThreshold () const
+        # 
+        # /** \brief Set the maximum curvature allowed for a planar region.
+        # * \param[in] maximum_curvature the maximum curvature
+        # */
+        # inline void setMaximumCurvature (double maximum_curvature)
+        # 
+        # /** \brief Get the maximum curvature allowed for a planar region. */
+        # inline double getMaximumCurvature () const
+        # 
+        # /** \brief Provide a pointer to the comparator to be used for segmentation.
+        # * \param[in] compare A pointer to the comparator to be used for segmentation.
+        # */
+        # void setComparator (const PlaneComparatorPtr& compare)
+        # 
+        # /** \brief Provide a pointer to the comparator to be used for refinement.
+        # * \param[in] compare A pointer to the comparator to be used for refinement.
+        # */
+        # void setRefinementComparator (const PlaneRefinementComparatorPtr& compare)
+        # 
+        # /** \brief Set whether or not to project boundary points to the plane, or leave them in the original 3D space.
+        # * \param[in] project_points true if points should be projected, false if not.
+        # */
+        # void setProjectPoints (bool project_points)
+        # 
+        # /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+        # * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+        # * \param[out] inlier_indices a vector of inliers for each detected plane
+        # * \param[out] centroids a vector of centroids for each plane
+        # * \param[out] covariances a vector of covariance matricies for the inliers of each plane
+        # * \param[out] labels a point cloud for the connected component labels of each pixel
+        # * \param[out] label_indices a vector of PointIndices for each labeled component
+        # */
+        # void segment (
+        #         std::vector<ModelCoefficients>& model_coefficients, 
+        #         std::vector<PointIndices>& inlier_indices,
+        #         std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+        #         std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+        #         pcl::PointCloud<PointLT>& labels, 
+        #         std::vector<pcl::PointIndices>& label_indices);
+        # 
+        # /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+        # * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+        # * \param[out] inlier_indices a vector of inliers for each detected plane
+        # */
+        # void segment (
+        #         std::vector<ModelCoefficients>& model_coefficients, 
+        #         std::vector<PointIndices>& inlier_indices);
+        # 
+        # /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+        # * \param[out] regions a list of resultant planar polygonal regions
+        # */
+        # void segment (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+        # 
+        # /** \brief Perform a segmentation, as well as an additional refinement step.  This helps with including points whose normals may not match neighboring points well, but may match the planar model well.
+        # * \param[out] regions A list of regions generated by segmentation and refinement.
+        # */
+        # void segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+        # 
+        # /** \brief Perform a segmentation, as well as additional refinement step.  Returns intermediate data structures for use in
+        # * subsequent processing.
+        # * \param[out] regions A vector of PlanarRegions generated by segmentation
+        # * \param[out] model_coefficients A vector of model coefficients for each segmented plane
+        # * \param[out] inlier_indices A vector of PointIndices, indicating the inliers to each segmented plane
+        # * \param[out] labels A PointCloud<PointLT> corresponding to the resulting segmentation.
+        # * \param[out] label_indices A vector of PointIndices for each label
+        # * \param[out] boundary_indices A vector of PointIndices corresponding to the outer boundary / contour of each label
+        # */
+        # void segmentAndRefine (
+        #                 std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions,
+        #                 std::vector<ModelCoefficients>& model_coefficients,
+        #                 std::vector<PointIndices>& inlier_indices,
+        #                 PointCloudLPtr& labels,
+        #                 std::vector<pcl::PointIndices>& label_indices,
+        #                 std::vector<pcl::PointIndices>& boundary_indices);
+        # 
+        # /** \brief Perform a refinement of an initial segmentation, by comparing points to adjacent regions detected by the initial segmentation.
+        # * \param [in] model_coefficients The list of segmented model coefficients
+        # * \param [in] inlier_indices The list of segmented inlier indices, corresponding to each model
+        # * \param [in] centroids The list of centroids corresponding to each segmented plane
+        # * \param [in] covariances The list of covariances corresponding to each segemented plane
+        # * \param [in] labels The labels produced by the initial segmentation
+        # * \param [in] label_indices The list of indices corresponding to each label
+        # */
+        # void refine (std::vector<ModelCoefficients>& model_coefficients, 
+        #       std::vector<PointIndices>& inlier_indices,
+        #       std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+        #       std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+        #       PointCloudLPtr& labels,
+        #       std::vector<pcl::PointIndices>& label_indices);
+
+
+###
+
+#ifdef PCL_NO_PRECOMPILE
+#include <pcl/segmentation/impl/organized_multi_plane_segmentation.hpp>
+#endif
+
+#endif //#ifndef PCL_SEGMENTATION_ORGANIZED_MULTI_PLANE_SEGMENTATION_H_
+###
+
+# planar_polygon_fusion.h
+# namespace pcl
+# /** \brief PlanarPolygonFusion takes a list of 2D planar polygons and
+# * attempts to reduce them to a minimum set that best represents the scene,
+# * based on various given comparators.
+# */
+# template <typename PointT>
+# class PlanarPolygonFusion
+        # public:
+        # /** \brief Constructor */
+        # PlanarPolygonFusion () : regions_ () {}
+        # 
+        # /** \brief Destructor */
+        # virtual ~PlanarPolygonFusion () {}
+        # 
+        # /** \brief Reset the state (clean the list of planar models). */
+        # void reset ()
+        # 
+        # /** \brief Set the list of 2D planar polygons to refine.
+        # * \param[in] input the list of 2D planar polygons to refine
+        # */
+        # void addInputPolygons (const std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > > &input)
+
+
+###
+
+# planar_region.h
+# namespace pcl
+# /** \brief PlanarRegion represents a set of points that lie in a plane.  Inherits summary statistics about these points from Region3D, and  summary statistics of a 3D collection of points.
+# * \author Alex Trevor
+# */
+# template <typename PointT>
+# class PlanarRegion : public pcl::Region3D<PointT>, public pcl::PlanarPolygon<PointT>
+        # protected:
+        # using Region3D<PointT>::centroid_;
+        # using Region3D<PointT>::covariance_; 
+        # using Region3D<PointT>::count_;
+        # using PlanarPolygon<PointT>::contour_;
+        # using PlanarPolygon<PointT>::coefficients_;
+        # 
+        # public:
+        # /** \brief Empty constructor for PlanarRegion. */
+        # PlanarRegion () : contour_labels_ ()
+        # 
+        # /** \brief Constructor for Planar region from a Region3D and a PlanarPolygon. 
+        # * \param[in] region a Region3D for the input data
+        # * \param[in] polygon a PlanarPolygon for the input region
+        # */
+        # PlanarRegion (const pcl::Region3D<PointT>& region, const pcl::PlanarPolygon<PointT>& polygon) :
+        # 
+        # /** \brief Destructor. */
+        # virtual ~PlanarRegion () {}
+        # 
+        # /** \brief Constructor for PlanarRegion.
+        # * \param[in] centroid the centroid of the region.
+        # * \param[in] covariance the covariance of the region.
+        # * \param[in] count the number of points in the region.
+        # * \param[in] contour the contour / boudnary for the region
+        # * \param[in] coefficients the model coefficients (a,b,c,d) for the plane
+        # */
+        # PlanarRegion (const Eigen::Vector3f& centroid, const Eigen::Matrix3f& covariance, unsigned count,
+        #             const typename pcl::PointCloud<PointT>::VectorType& contour,
+        #             const Eigen::Vector4f& coefficients) :
+
+
+###
+
+
+# plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation.
+#  * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#  * \author Alex Trevor
+#  */
+# template<typename PointT, typename PointNT>
+# class PlaneCoefficientComparator: public Comparator<PointT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<PlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const PlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # /** \brief Empty constructor for PlaneCoefficientComparator. */
+        # PlaneCoefficientComparator ()
+        # : normals_ ()
+        # , plane_coeff_d_ ()
+        # , angular_threshold_ (pcl::deg2rad (2.0f))
+        # , distance_threshold_ (0.02f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0, 0.0, 1.0) )
+        # 
+        # /** \brief Constructor for PlaneCoefficientComparator.
+        #   * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+        #   */
+        # PlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+        # : normals_ ()
+        # , plane_coeff_d_ (plane_coeff_d)
+        # , angular_threshold_ (pcl::deg2rad (2.0f))
+        # , distance_threshold_ (0.02f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0f, 0.0f, 1.0f) )
+        # 
+        # /** \brief Destructor for PlaneCoefficientComparator. */
+        # virtual ~PlaneCoefficientComparator ()
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # 
+        # /** \brief Provide a pointer to the input normals.
+        #  * \param[in] normals the input normal cloud
+        #  */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # 
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        #   */
+        # void setPlaneCoeffD (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #  * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        #  */
+        # void setPlaneCoeffD (std::vector<float>& plane_coeff_d)
+        # 
+        # /** \brief Get a pointer to the vector of the d-coefficient of the planes' hessian normal form. */
+        # const std::vector<float>& getPlaneCoeffD () const
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #  * \param[in] angular_threshold the tolerance in radians
+        #  */
+        # virtual void setAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        # 
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters (at 1m)
+        #   * \param[in] depth_dependent whether to scale the threshold based on range from the sensor (default: false)
+        #   */
+        # void setDistanceThreshold (float distance_threshold, bool depth_dependent = false)
+        # 
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        # 
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        #   */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+
+# plane_refinement_comparator.h
+# namespace pcl
+# /** \brief PlaneRefinementComparator is a Comparator that operates on plane coefficients, 
+#  * for use in planar segmentation.
+#  * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#  *
+#  * \author Alex Trevor, Suat Gedikli
+#  */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class PlaneRefinementComparator: public PlaneCoefficientComparator<PointT, PointNT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # 
+        # typedef boost::shared_ptr<PlaneRefinementComparator<PointT, PointNT, PointLT> > Ptr;
+        # typedef boost::shared_ptr<const PlaneRefinementComparator<PointT, PointNT, PointLT> > ConstPtr;
+        # 
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+        # 
+        # /** \brief Empty constructor for PlaneCoefficientComparator. */
+        # PlaneRefinementComparator ()
+        # : models_ ()
+        # , labels_ ()
+        # , refine_labels_ ()
+        # , label_to_model_ ()
+        # , depth_dependent_ (false)
+        # 
+        # /** \brief Empty constructor for PlaneCoefficientComparator. 
+        #   * \param[in] models
+        #   * \param[in] refine_labels
+        #   */
+        # PlaneRefinementComparator (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models,
+        #                          boost::shared_ptr<std::vector<bool> >& refine_labels)
+        # : models_ (models)
+        # , labels_ ()
+        # , refine_labels_ (refine_labels)
+        # , label_to_model_ ()
+        # , depth_dependent_ (false)
+        # 
+        # /** \brief Destructor for PlaneCoefficientComparator. */
+        # virtual ~PlaneRefinementComparator ()
+        # 
+        # /** \brief Set the vector of model coefficients to which we will compare.
+        #   * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+        #   */
+        # void setModelCoefficients (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models)
+        # 
+        # /** \brief Set the vector of model coefficients to which we will compare.
+        #   * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+        #   */
+        # void setModelCoefficients (std::vector<pcl::ModelCoefficients>& models)
+        # 
+        # /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+        #   * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+        #   */
+        # void setRefineLabels (boost::shared_ptr<std::vector<bool> >& refine_labels)
+        # 
+        # /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+        #   * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+        #   */
+        # void setRefineLabels (std::vector<bool>& refine_labels)
+        # 
+        # /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+        #   * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+        #   */
+        # inline void setLabelToModel (boost::shared_ptr<std::vector<int> >& label_to_model)
+        # 
+        # /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+        #   * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+        #   */
+        # inline void setLabelToModel (std::vector<int>& label_to_model)
+        # 
+        # /** \brief Get the vector of model coefficients to which we will compare. */
+        # inline boost::shared_ptr<std::vector<pcl::ModelCoefficients> > getModelCoefficients () const
+        # 
+        # /** \brief ...
+        #   * \param[in] labels
+        # */
+        # inline void setLabels (PointCloudLPtr& labels)
+        # 
+        # /** \brief Compare two neighboring points
+        #   * \param[in] idx1 The index of the first point.
+        #   * \param[in] idx2 The index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# 1.7.2 NG
+# progressive_morphological_filter.h
+# namespace pcl
+# /** \brief
+#  * Implements the Progressive Morphological Filter for segmentation of ground points.
+#  * Description can be found in the article
+#  * "A Progressive Morphological Filter for Removing Nonground Measurements from
+#  * Airborne LIDAR Data"
+#  * by K. Zhang, S. Chen, D. Whitman, M. Shyu, J. Yan, and C. Zhang.
+#  */
+# template <typename PointT>
+# class PCL_EXPORTS ProgressiveMorphologicalFilter : public pcl::PCLBase<PointT>
+# cdef extern from "pcl/segmentation/progressive_morphological_filter.h" namespace "pcl":
+#     cdef cppclass ProgressiveMorphologicalFilter[PointT](PCLBase[PointT]):
+#         ProgressiveMorphologicalFilter()
+        # public:
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # 
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # /** \brief Constructor that sets default values for member variables. */
+        # ProgressiveMorphologicalFilter ();
+        # virtual ~ProgressiveMorphologicalFilter ();
+        # 
+        # /** \brief Get the maximum window size to be used in filtering ground returns. */
+        # inline int getMaxWindowSize () const { return (max_window_size_); }
+        # int getMaxWindowSize ()
+        # 
+        # /** \brief Set the maximum window size to be used in filtering ground returns. */
+        # inline void setMaxWindowSize (int max_window_size) { max_window_size_ = max_window_size; }
+        # void setMaxWindowSize (int max_window_size)
+        # 
+        # /** \brief Get the slope value to be used in computing the height threshold. */
+        # inline float getSlope () const { return (slope_); }
+        # float getSlope ()
+        # 
+        # /** \brief Set the slope value to be used in computing the height threshold. */
+        # inline void setSlope (float slope) { slope_ = slope; }
+        # void setSlope (float slope)
+        # 
+        # /** \brief Get the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline float getMaxDistance () const { return (max_distance_); }
+        # float getMaxDistance ()
+        # 
+        # /** \brief Set the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline void setMaxDistance (float max_distance) { max_distance_ = max_distance; }
+        # void setMaxDistance (float max_distance)
+        # 
+        # /** \brief Get the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline float getInitialDistance () const { return (initial_distance_); }
+        # float getInitialDistance ()
+        # 
+        # /** \brief Set the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline void setInitialDistance (float initial_distance) { initial_distance_ = initial_distance; }
+        # void setInitialDistance (float initial_distance)
+        # 
+        # /** \brief Get the cell size. */
+        # inline float getCellSize () const { return (cell_size_); }
+        # float getCellSize ()
+        # 
+        # /** \brief Set the cell size. */
+        # inline void setCellSize (float cell_size) { cell_size_ = cell_size; }
+        # void setCellSize (float cell_size)
+        # 
+        # /** \brief Get the base to be used in computing progressive window sizes. */
+        # inline float getBase () const { return (base_); }
+        # float getBase ()
+        # 
+        # /** \brief Set the base to be used in computing progressive window sizes. */
+        # inline void setBase (float base) { base_ = base; }
+        # setBase (float base)
+        # 
+        # /** \brief Get flag indicating whether or not to exponentially grow window sizes? */
+        # inline bool getExponential () const { return (exponential_); }
+        # bool getExponential ()
+        # 
+        # /** \brief Set flag indicating whether or not to exponentially grow window sizes? */
+        # inline void setExponential (bool exponential) { exponential_ = exponential; }
+        # void setExponential (bool exponential)
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns indices of
+        #   * points determined to be ground returns.
+        #   * \param[out] ground indices of points determined to be ground returns.
+        #   */
+        # virtual void extract (std::vector<int>& ground);
+        # void extract (vector[int]& ground)
+
+
+# ctypedef ProgressiveMorphologicalFilter[PointXYZ] ProgressiveMorphologicalFilter_t
+# ctypedef ProgressiveMorphologicalFilter[PointXYZI] ProgressiveMorphologicalFilter_PointXYZI_t
+# ctypedef ProgressiveMorphologicalFilter[PointXYZRGB] ProgressiveMorphologicalFilter_PointXYZRGB_t
+# ctypedef ProgressiveMorphologicalFilter[PointXYZRGBA] ProgressiveMorphologicalFilter_PointXYZRGBA_t
+###
+
+# region_3d.h
+# namespace pcl
+# /** \brief Region3D represents summary statistics of a 3D collection of points.
+#  * \author Alex Trevor
+#  */
+# template <typename PointT>
+# class Region3D
+        # public:
+        # /** \brief Empty constructor for Region3D. */
+        # Region3D () : centroid_ (Eigen::Vector3f::Zero ()), covariance_ (Eigen::Matrix3f::Identity ()), count_ (0)
+        # 
+        # /** \brief Constructor for Region3D. 
+        # * \param[in] centroid The centroid of the region.
+        # * \param[in] covariance The covariance of the region.
+        # * \param[in] count The number of points in the region.
+        # */
+        # Region3D (Eigen::Vector3f& centroid, Eigen::Matrix3f& covariance, unsigned count) 
+        # : centroid_ (centroid), covariance_ (covariance), count_ (count)
+        # 
+        # /** \brief Destructor. */
+        # virtual ~Region3D () {}
+        # 
+        # /** \brief Get the centroid of the region. */
+        # inline Eigen::Vector3f getCentroid () const
+        # 
+        # /** \brief Get the covariance of the region. */
+        # inline Eigen::Matrix3f getCovariance () const
+        # 
+        # /** \brief Get the number of points in the region. */
+        # unsigned getCount () const
+        # 
+        # /** \brief Get the curvature of the region. */
+        # float getCurvature () const
+        # 
+        # /** \brief Set the curvature of the region. */
+        # void setCurvature (float curvature)
+
+
+###
+
+# region_growing.h
+# namespace pcl
+# /** \brief
+#  * Implements the well known Region Growing algorithm used for segmentation.
+#  * Description can be found in the article
+#  * "Segmentation of point clouds using smoothness constraint"
+#  * by T. Rabbania, F. A. van den Heuvelb, G. Vosselmanc.
+#  * In addition to residual test, the possibility to test curvature is added.
+#  */
+# template <typename PointT, typename NormalT>
+# class PCL_EXPORTS RegionGrowing : public pcl::PCLBase<PointT>
+        # public:
+        # typedef pcl::search::Search <PointT> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::PointCloud <NormalT> Normal;
+        # typedef typename Normal::Ptr NormalPtr;
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # /** \brief Constructor that sets default values for member variables. */
+        # RegionGrowing ();
+        # 
+        # /** \brief This destructor destroys the cloud, normals and search method used for
+        #  * finding KNN. In other words it frees memory.
+        #  */
+        # virtual ~RegionGrowing ();
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMinClusterSize ();
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMinClusterSize (int min_cluster_size);
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMaxClusterSize ();
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMaxClusterSize (int max_cluster_size);
+        # 
+        # /** \brief Returns the flag value. This flag signalizes which mode of algorithm will be used.
+        #  * If it is set to true than it will work as said in the article. This means that
+        #  * it will be testing the angle between normal of the current point and it's neighbours normal.
+        #  * Otherwise, it will be testing the angle between normal of the current point
+        #  * and normal of the initial point that was chosen for growing new segment.
+        #  */
+        # bool getSmoothModeFlag () const;
+        # 
+        # /** \brief This function allows to turn on/off the smoothness constraint.
+        #   * \param[in] value new mode value, if set to true then the smooth version will be used.
+        #   */
+        # void setSmoothModeFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the curvature test is turned on/off. */
+        # bool getCurvatureTestFlag () const;
+        # 
+        # /** \brief Allows to turn on/off the curvature test. Note that at least one test
+        #   * (residual or curvature) must be turned on. If you are turning curvature test off
+        #   * then residual test will be turned on automatically.
+        #   *  \param[in] value new value for curvature test. If set to true then the test will be turned on
+        #   */
+        # virtual void setCurvatureTestFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the residual test is turned on/off. */
+        # bool getResidualTestFlag () const;
+        # 
+        # /** \brief
+        # * Allows to turn on/off the residual test. Note that at least one test
+        # * (residual or curvature) must be turned on. If you are turning residual test off
+        # * then curvature test will be turned on automatically.
+        # * \param[in] value new value for residual test. If set to true then the test will be turned on
+        # */
+        # virtual void setResidualTestFlag (bool value);
+        # 
+        # /** \brief Returns smoothness threshold. */
+        # float getSmoothnessThreshold () const;
+        # 
+        # /** \brief Allows to set smoothness threshold used for testing the points.
+        #   * \param[in] theta new threshold value for the angle between normals
+        #   */
+        # void setSmoothnessThreshold (float theta);
+        # 
+        # /** \brief Returns residual threshold. */
+        # float getResidualThreshold () const;
+        # 
+        # /** \brief Allows to set residual threshold used for testing the points.
+        # * \param[in] residual new threshold value for residual testing
+        # */
+        # void setResidualThreshold (float residual);
+        # 
+        # /** \brief Returns curvature threshold. */
+        # float getCurvatureThreshold () const;
+        # 
+        # /** \brief Allows to set curvature threshold used for testing the points.
+        #  * \param[in] curvature new threshold value for curvature testing
+        #  */
+        # void setCurvatureThreshold (float curvature);
+        # 
+        # /** \brief Returns the number of nearest neighbours used for KNN. */
+        # unsigned int getNumberOfNeighbours () const;
+        # 
+        # /** \brief Allows to set the number of neighbours. For more information check the article.
+        #  * \param[in] neighbour_number number of neighbours to use
+        #  */
+        # void setNumberOfNeighbours (unsigned int neighbour_number);
+        # 
+        # /** \brief Returns the pointer to the search method that is used for KNN. */
+        # KdTreePtr getSearchMethod () const;
+        # 
+        # /** \brief Allows to set search method that will be used for finding KNN.
+        #  * \param[in] tree pointer to a KdTree
+        #  */
+        # void setSearchMethod (const KdTreePtr& tree);
+        # 
+        # /** \brief Returns normals. */
+        # NormalPtr getInputNormals () const;
+        # 
+        # /** \brief This method sets the normals. They are needed for the algorithm, so if
+        #  * no normals will be set, the algorithm would not be able to segment the points.
+        #  * \param[in] norm normals that will be used in the algorithm
+        #  */
+        # void setInputNormals (const NormalPtr& norm);
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        #   * obtained during the segmentation.
+        #   * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        #   */
+        # virtual void extract (std::vector <pcl::PointIndices>& clusters);
+        # 
+        # /** \brief For a given point this function builds a segment to which it belongs and returns this segment.
+        #  * \param[in] index index of the initial point which will be the seed for growing a segment.
+        #  * \param[out] cluster cluster to which the point belongs.
+        #  */
+        # virtual void getSegmentFromPoint (int index, pcl::PointIndices& cluster);
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        #  * returns colored cloud. Otherwise it returns an empty pointer.
+        #  * Points that belong to the same segment have the same color.
+        #  * But this function doesn't guarantee that different segments will have different
+        #  * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        #  */
+        # pcl::PointCloud<pcl::PointXYZRGB>::Ptr getColoredCloud ();
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        # * returns colored cloud. Otherwise it returns an empty pointer.
+        # * Points that belong to the same segment have the same color.
+        # * But this function doesn't guarantee that different segments will have different
+        # * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        # */
+        # pcl::PointCloud<pcl::PointXYZRGBA>::Ptr getColoredCloudRGBA ();
+
+
+###
+
+# region_growing_rgb.h
+# namespace pcl
+# /** \brief
+# * Implements the well known Region Growing algorithm used for segmentation.
+# * Description can be found in the article
+# * "Segmentation of point clouds using smoothness constraint"
+# * by T. Rabbania, F. A. van den Heuvelb, G. Vosselmanc.
+# * In addition to residual test, the possibility to test curvature is added.
+# */
+# template <typename PointT, typename NormalT>
+# class PCL_EXPORTS RegionGrowing : public pcl::PCLBase<PointT>
+        # public:
+        # typedef pcl::search::Search <PointT> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::PointCloud <NormalT> Normal;
+        # typedef typename Normal::Ptr NormalPtr;
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # 
+        # /** \brief Constructor that sets default values for member variables. */
+        # RegionGrowing ();
+        # 
+        # /** \brief This destructor destroys the cloud, normals and search method used for
+        # * finding KNN. In other words it frees memory.
+        # */
+        # virtual ~RegionGrowing ();
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMinClusterSize ();
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMinClusterSize (int min_cluster_size);
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMaxClusterSize ();
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMaxClusterSize (int max_cluster_size);
+        # 
+        # /** \brief Returns the flag value. This flag signalizes which mode of algorithm will be used.
+        # * If it is set to true than it will work as said in the article. This means that
+        # * it will be testing the angle between normal of the current point and it's neighbours normal.
+        # * Otherwise, it will be testing the angle between normal of the current point
+        # * and normal of the initial point that was chosen for growing new segment.
+        # */
+        # bool getSmoothModeFlag () const;
+        # 
+        # /** \brief This function allows to turn on/off the smoothness constraint.
+        # * \param[in] value new mode value, if set to true then the smooth version will be used.
+        # */
+        # void setSmoothModeFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the curvature test is turned on/off. */
+        # bool getCurvatureTestFlag () const;
+        # 
+        # /** \brief Allows to turn on/off the curvature test. Note that at least one test
+        # * (residual or curvature) must be turned on. If you are turning curvature test off
+        # * then residual test will be turned on automatically.
+        # * \param[in] value new value for curvature test. If set to true then the test will be turned on
+        # */
+        # virtual void setCurvatureTestFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the residual test is turned on/off. */
+        # bool getResidualTestFlag () const;
+        # 
+        # /** \brief
+        # * Allows to turn on/off the residual test. Note that at least one test
+        # * (residual or curvature) must be turned on. If you are turning residual test off
+        # * then curvature test will be turned on automatically.
+        # * \param[in] value new value for residual test. If set to true then the test will be turned on
+        # */
+        # virtual void setResidualTestFlag (bool value);
+        # 
+        # /** \brief Returns smoothness threshold. */
+        # float getSmoothnessThreshold () const;
+        # 
+        # /** \brief Allows to set smoothness threshold used for testing the points.
+        # * \param[in] theta new threshold value for the angle between normals
+        # */
+        # void setSmoothnessThreshold (float theta);
+        # 
+        # /** \brief Returns residual threshold. */
+        # float getResidualThreshold () const;
+        # 
+        # /** \brief Allows to set residual threshold used for testing the points.
+        # * \param[in] residual new threshold value for residual testing
+        # */
+        # void setResidualThreshold (float residual);
+        # 
+        # /** \brief Returns curvature threshold. */
+        # float getCurvatureThreshold () const;
+        # 
+        # /** \brief Allows to set curvature threshold used for testing the points.
+        # * \param[in] curvature new threshold value for curvature testing
+        # */
+        # void setCurvatureThreshold (float curvature);
+        # 
+        # /** \brief Returns the number of nearest neighbours used for KNN. */
+        # unsigned int getNumberOfNeighbours () const;
+        # 
+        # /** \brief Allows to set the number of neighbours. For more information check the article.
+        # * \param[in] neighbour_number number of neighbours to use
+        # */
+        # void setNumberOfNeighbours (unsigned int neighbour_number);
+        # 
+        # /** \brief Returns the pointer to the search method that is used for KNN. */
+        # KdTreePtr getSearchMethod () const;
+        # 
+        # /** \brief Allows to set search method that will be used for finding KNN.
+        # * \param[in] tree pointer to a KdTree
+        # */
+        # void setSearchMethod (const KdTreePtr& tree);
+        # 
+        # /** \brief Returns normals. */
+        # NormalPtr getInputNormals () const;
+        # 
+        # /** \brief This method sets the normals. They are needed for the algorithm, so if
+        # * no normals will be set, the algorithm would not be able to segment the points.
+        # * \param[in] norm normals that will be used in the algorithm
+        # */
+        # void setInputNormals (const NormalPtr& norm);
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        # * obtained during the segmentation.
+        # * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        # */
+        # virtual void extract (std::vector <pcl::PointIndices>& clusters);
+        # 
+        # /** \brief For a given point this function builds a segment to which it belongs and returns this segment.
+        # * \param[in] index index of the initial point which will be the seed for growing a segment.
+        # * \param[out] cluster cluster to which the point belongs.
+        # */
+        # virtual void getSegmentFromPoint (int index, pcl::PointIndices& cluster);
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        # * returns colored cloud. Otherwise it returns an empty pointer.
+        # * Points that belong to the same segment have the same color.
+        # * But this function doesn't guarantee that different segments will have different
+        # * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        # */
+        # pcl::PointCloud<pcl::PointXYZRGB>::Ptr getColoredCloud ();
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        # * returns colored cloud. Otherwise it returns an empty pointer.
+        # * Points that belong to the same segment have the same color.
+        # * But this function doesn't guarantee that different segments will have different
+        # * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        # */
+        # pcl::PointCloud<pcl::PointXYZRGBA>::Ptr getColoredCloudRGBA ();
+        # 
+        # /** \brief This function is used as a comparator for sorting. */
+        # inline bool comparePair (std::pair<float, int> i, std::pair<float, int> j)
+
+
+###
+
+
+# rgb_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#  * for use in planar segmentation.  Also takes into account RGB, so we can segmented different colored co-planar regions.
+#  * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#  *
+#  * \author Alex Trevor
+#  */
+# template<typename PointT, typename PointNT>
+# class RGBPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<RGBPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const RGBPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # 
+        # using pcl::Comparator<PointT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Empty constructor for RGBPlaneCoefficientComparator. */
+        # RGBPlaneCoefficientComparator ()
+        # : color_threshold_ (50.0f)
+        # 
+        # /** \brief Constructor for RGBPlaneCoefficientComparator.
+        # * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+        # */
+        # RGBPlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+        # : PlaneCoefficientComparator<PointT, PointNT> (plane_coeff_d), color_threshold_ (50.0f)
+        # 
+        # /** \brief Destructor for RGBPlaneCoefficientComparator. */
+        # virtual ~RGBPlaneCoefficientComparator ()
+        # 
+        # /** \brief Set the tolerance in color space between neighboring points, to be considered part of the same plane.
+        # * \param[in] color_threshold The distance in color space
+        # */
+        # inline void setColorThreshold (float color_threshold)
+        # 
+        # /** \brief Get the color threshold between neighboring points, to be considered part of the same plane. */
+        # inline float getColorThreshold () const
+        # 
+        # /** \brief Compare two neighboring points, by using normal information, euclidean distance, and color information.
+        # * \param[in] idx1 The index of the first point.
+        # * \param[in] idx2 The index of the second point.
+        # */
+        # bool compare (int idx1, int idx2) const
+
+
+###
+
+# sac_segmentation.h
+# namespace pcl
+# /** \brief @b SACSegmentation represents the Nodelet segmentation class for
+#  * Sample Consensus methods and models, in the sense that it just creates a
+#  * Nodelet wrapper for generic-purpose SAC-based segmentation.
+#  * \author Radu Bogdan Rusu
+#  * \ingroup segmentation
+#  */
+# template <typename PointT>
+# class SACSegmentation : public PCLBase<PointT>
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # public:
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::search::Search<PointT>::Ptr SearchPtr;
+        # typedef typename SampleConsensus<PointT>::Ptr SampleConsensusPtr;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # 
+        # /** \brief Empty constructor. 
+        # * \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
+        # */
+        # SACSegmentation (bool random = false) 
+        # : model_ ()
+        # , sac_ ()
+        # , model_type_ (-1)
+        # , method_type_ (0)
+        # , threshold_ (0)
+        # , optimize_coefficients_ (true)
+        # , radius_min_ (-std::numeric_limits<double>::max ())
+        # , radius_max_ (std::numeric_limits<double>::max ())
+        # , samples_radius_ (0.0)
+        # , samples_radius_search_ ()
+        # , eps_angle_ (0.0)
+        # , axis_ (Eigen::Vector3f::Zero ())
+        # , max_iterations_ (50)
+        # , probability_ (0.99)
+        # , random_ (random)
+        # 
+        # /** \brief Empty destructor. */
+        # virtual ~SACSegmentation () { /*srv_.reset ();*/ };
+        # 
+        # /** \brief The type of model to use (user given parameter).
+        # * \param[in] model the model type (check \a model_types.h)
+        # */
+        # inline void setModelType (int model) { model_type_ = model; }
+        # 
+        # /** \brief Get the type of SAC model used. */
+        # inline int getModelType () const { return (model_type_); }
+        # 
+        # /** \brief Get a pointer to the SAC method used. */
+        # inline SampleConsensusPtr getMethod () const { return (sac_); }
+        # 
+        # /** \brief Get a pointer to the SAC model used. */
+        # inline SampleConsensusModelPtr getModel () const { return (model_); }
+        # 
+        # /** \brief The type of sample consensus method to use (user given parameter).
+        # * \param[in] method the method type (check \a method_types.h)
+        # */
+        # inline void setMethodType (int method) { method_type_ = method; }
+        # 
+        # /** \brief Get the type of sample consensus method used. */
+        # inline int getMethodType () const { return (method_type_); }
+        # 
+        # /** \brief Distance to the model threshold (user given parameter).
+        # * \param[in] threshold the distance threshold to use
+        # */
+        # inline void setDistanceThreshold (double threshold) { threshold_ = threshold; }
+        # 
+        # /** \brief Get the distance to the model threshold. */
+        # inline double getDistanceThreshold () const { return (threshold_); }
+        # 
+        # /** \brief Set the maximum number of iterations before giving up.
+        # * \param[in] max_iterations the maximum number of iterations the sample consensus method will run
+        # */
+        # inline void setMaxIterations (int max_iterations) { max_iterations_ = max_iterations; }
+        # 
+        # /** \brief Get maximum number of iterations before giving up. */
+        # inline int getMaxIterations () const { return (max_iterations_); }
+        # 
+        # /** \brief Set the probability of choosing at least one sample free from outliers.
+        # * \param[in] probability the model fitting probability
+        # */
+        # inline void setProbability (double probability) { probability_ = probability; }
+        # 
+        # /** \brief Get the probability of choosing at least one sample free from outliers. */
+        # inline double getProbability () const { return (probability_); }
+        # 
+        # /** \brief Set to true if a coefficient refinement is required.
+        # * \param[in] optimize true for enabling model coefficient refinement, false otherwise
+        # */
+        # inline void setOptimizeCoefficients (bool optimize) { optimize_coefficients_ = optimize; }
+        # 
+        # /** \brief Get the coefficient refinement internal flag. */
+        # inline bool getOptimizeCoefficients () const { return (optimize_coefficients_); }
+        # 
+        # /** \brief Set the minimum and maximum allowable radius limits for the model (applicable to models that estimate
+        # * a radius)
+        # * \param[in] min_radius the minimum radius model
+        # * \param[in] max_radius the maximum radius model
+        # */
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        # 
+        # /** \brief Get the minimum and maximum allowable radius limits for the model as set by the user.
+        # * \param[out] min_radius the resultant minimum radius model
+        # * \param[out] max_radius the resultant maximum radius model
+        # */
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        # 
+        # /** \brief Set the maximum distance allowed when drawing random samples
+        # * \param[in] radius the maximum distance (L2 norm)
+        # * \param search
+        # */
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        # 
+        # /** \brief Get maximum distance allowed when drawing random samples
+        # *
+        # * \param[out] radius the maximum distance (L2 norm)
+        # */
+        # inline void getSamplesMaxDist (double &radius)
+        # 
+        # /** \brief Set the axis along which we need to search for a model perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a model perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a model perpendicular to. */
+        # inline Eigen::Vector3f getAxis () const { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the model normal and the given axis in radians.
+        # */
+        # inline void setEpsAngle (double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the epsilon (delta) model angle threshold in radians. */
+        # inline double getEpsAngle () const { return (eps_angle_); }
+        # 
+        # /** \brief Base method for segmentation of a model in a PointCloud given by <setInputCloud (), setIndices ()>
+        # * \param[in] inliers the resultant point indices that support the model found (inliers)
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # virtual void segment (PointIndices &inliers, ModelCoefficients &model_coefficients);
+
+
+###
+
+# sac_segmentation.h
+# namespace pcl
+# /** \brief @b SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and
+#  * models that require the use of surface normals for estimation.
+#  * \ingroup segmentation
+#  */
+# template <typename PointT, typename PointNT>
+# class SACSegmentationFromNormals: public SACSegmentation<PointT>
+        # using SACSegmentation<PointT>::model_;
+        # using SACSegmentation<PointT>::model_type_;
+        # using SACSegmentation<PointT>::radius_min_;
+        # using SACSegmentation<PointT>::radius_max_;
+        # using SACSegmentation<PointT>::eps_angle_;
+        # using SACSegmentation<PointT>::axis_;
+        # using SACSegmentation<PointT>::random_;
+        # 
+        # public:
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # typedef typename SACSegmentation<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename SampleConsensus<PointT>::Ptr SampleConsensusPtr;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::Ptr SampleConsensusModelFromNormalsPtr;
+        # 
+        # /** \brief Empty constructor.
+        # * \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
+        # */
+        # SACSegmentationFromNormals (bool random = false) 
+        # : SACSegmentation<PointT> (random)
+        # , normals_ ()
+        # , distance_weight_ (0.1)
+        # , distance_from_origin_ (0)
+        # , min_angle_ ()
+        # , max_angle_ ()
+        # 
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        # * the XYZ dataset.
+        # * \param[in] normals the const boost shared pointer to a PointCloud message
+        # */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) { normals_ = normals; }
+        # 
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals () const { return (normals_); }
+        # 
+        # /** \brief Set the relative weight (between 0 and 1) to give to the angular 
+        # * distance (0 to pi/2) between point normals and the plane normal.
+        # * \param[in] distance_weight the distance/angular weight
+        # */
+        # inline void setNormalDistanceWeight (double distance_weight) { distance_weight_ = distance_weight; }
+        # 
+        # /** \brief Get the relative weight (between 0 and 1) to give to the angular distance (0 to pi/2) between point
+        # * normals and the plane normal. */
+        # inline double getNormalDistanceWeight () const { return (distance_weight_); }
+        # 
+        # /** \brief Set the minimum opning angle for a cone model.
+        # * \param min_angle the opening angle which we need minumum to validate a cone model.
+        # * \param max_angle the opening angle which we need maximum to validate a cone model.
+        # */
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        # 
+        # /** \brief Get the opening angle which we need minumum to validate a cone model. */
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle)
+        # 
+        # /** \brief Set the distance we expect a plane model to be from the origin
+        # * \param[in] d distance from the template plane modl to the origin
+        # */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        # 
+        # /** \brief Get the distance of a plane model from the origin. */
+        # inline double getDistanceFromOrigin () const { return (distance_from_origin_); }
+
+
+###
+
+# seeded_hue_segmentation.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#  * \param[in] cloud the point cloud message
+#  * \param[in] tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#  * \note the tree has to be created as a spatial locator on \a cloud
+#  * \param[in] tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#  * \param[in] indices_in the cluster containing the seed point indices (as a vector of PointIndices)
+#  * \param[out] indices_out 
+#  * \param[in] delta_hue
+#  * \todo look how to make this templated!
+#  * \ingroup segmentation
+#  */
+# void seededHueSegmentation (
+#                       const PointCloud<PointXYZRGB>                           &cloud, 
+#                         const boost::shared_ptr<search::Search<PointXYZRGB> >   &tree, 
+#                         float                                                   tolerance, 
+#                         PointIndices                                            &indices_in, 
+#                         PointIndices                                            &indices_out, 
+#                         float                                                   delta_hue = 0.0);
+###
+
+# seeded_hue_segmentation.h
+# namespace pcl
+#   /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#     * \param[in] cloud the point cloud message
+#     * \param[in] tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#     * \note the tree has to be created as a spatial locator on \a cloud
+#     * \param[in] tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#     * \param[in] indices_in the cluster containing the seed point indices (as a vector of PointIndices)
+#     * \param[out] indices_out 
+#     * \param[in] delta_hue
+#     * \todo look how to make this templated!
+#     * \ingroup segmentation
+#     */
+#   void 
+#   seededHueSegmentation (const PointCloud<PointXYZRGB>                           &cloud, 
+#                          const boost::shared_ptr<search::Search<PointXYZRGBL> >  &tree, 
+#                          float                                                   tolerance, 
+#                          PointIndices                                            &indices_in, 
+#                          PointIndices                                            &indices_out, 
+#                          float                                                   delta_hue = 0.0);
+# 
+###
+
+# seeded_hue_segmentation.h
+# namespace pcl
+#   /** \brief SeededHueSegmentation 
+#     * \author Koen Buys
+#     * \ingroup segmentation
+#     */
+#   class SeededHueSegmentation: public PCLBase<PointXYZRGB>
+#   {
+#     typedef PCLBase<PointXYZRGB> BasePCLBase;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointXYZRGB> PointCloud;
+#       typedef PointCloud::Ptr PointCloudPtr;
+#       typedef PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef pcl::search::Search<PointXYZRGB> KdTree;
+#       typedef pcl::search::Search<PointXYZRGB>::Ptr KdTreePtr;
+# 
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+# 
+#       //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#       /** \brief Empty constructor. */
+#       SeededHueSegmentation () : tree_ (), cluster_tolerance_ (0), delta_hue_ (0.0)
+#       {};
+# 
+#       /** \brief Provide a pointer to the search object.
+#         * \param[in] tree a pointer to the spatial search object.
+#         */
+#       inline void 
+#       setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+# 
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr 
+#       getSearchMethod () const { return (tree_); }
+# 
+#       /** \brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+#         * \param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#         */
+#       inline void 
+#       setClusterTolerance (double tolerance) { cluster_tolerance_ = tolerance; }
+# 
+#       /** \brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space. */
+#       inline double 
+#       getClusterTolerance () const { return (cluster_tolerance_); }
+# 
+#       /** \brief Set the tollerance on the hue
+#         * \param[in] delta_hue the new delta hue
+#         */
+#       inline void setDeltaHue (float delta_hue) { delta_hue_ = delta_hue; }
+#       
+#       /** \brief Get the tolerance on the hue */
+#       inline float getDeltaHue () const { return (delta_hue_); }
+#       
+#       /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+#         * \param[in] indices_in
+#         * \param[out] indices_out
+#         */
+#       void segment (PointIndices &indices_in, PointIndices &indices_out);
+
+
+###
+
+# segment_differences.h
+# namespace pcl
+# /** \brief Obtain the difference between two aligned point clouds as another point cloud, given a distance threshold.
+#   * \param src the input point cloud source
+#   * \param tgt the input point cloud target we need to obtain the difference against
+#   * \param threshold the distance threshold (tolerance) for point correspondences. (e.g., check if f a point p1 from 
+#   * src has a correspondence > threshold than a point p2 from tgt)
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching built over \a tgt
+#   * \param output the resultant output point cloud difference
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> 
+# void getPointCloudDifference (
+#     const pcl::PointCloud<PointT> &src, const pcl::PointCloud<PointT> &tgt, 
+#     double threshold, const boost::shared_ptr<pcl::search::Search<PointT> > &tree,
+#     pcl::PointCloud<PointT> &output);
+###
+
+# segment_differences.h
+# namespace pcl
+# /** \brief @b SegmentDifferences obtains the difference between two spatially
+#   * aligned point clouds and returns the difference between them for a maximum
+#   * given distance threshold.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class SegmentDifferences: public PCLBase<PointT>
+#       typedef PCLBase<PointT> BasePCLBase;
+#       
+#       public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       typedef typename pcl::search::Search<PointT> KdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+#       
+#       /** \brief Empty constructor. */
+#       SegmentDifferences () : 
+#         tree_ (), target_ (), distance_threshold_ (0)
+#       {};
+#       
+#       /** \brief Provide a pointer to the target dataset against which we
+#         * compare the input cloud given in setInputCloud
+#         *
+#         * \param cloud the target PointCloud dataset
+#         */
+#       inline void setTargetCloud (const PointCloudConstPtr &cloud) { target_ = cloud; }
+#       
+#       /** \brief Get a pointer to the input target point cloud dataset. */
+#       inline PointCloudConstPtr const getTargetCloud () { return (target_); }
+#       
+#       /** \brief Provide a pointer to the search object.
+#         * \param tree a pointer to the spatial search object.
+#         */
+#       inline void setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+#       
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr getSearchMethod () { return (tree_); }
+#       
+#       /** \brief Set the maximum distance tolerance (squared) between corresponding
+#         * points in the two input datasets.
+#         * \param sqr_threshold the squared distance tolerance as a measure in L2 Euclidean space
+#         */
+#       inline void setDistanceThreshold (double sqr_threshold) { distance_threshold_ = sqr_threshold; }
+#       
+#       /** \brief Get the squared distance tolerance between corresponding points as a
+#         * measure in the L2 Euclidean space.
+#         */
+#       inline double getDistanceThreshold () { return (distance_threshold_); }
+#       
+#       /** \brief Segment differences between two input point clouds.
+#         * \param output the resultant difference between the two point clouds as a PointCloud
+#         */
+#       void segment (PointCloud &output);
+
+
+###
+
+# supervoxel_clustering.h
+# namespace pcl
+# /** \brief Supervoxel container class - stores a cluster extracted using supervoxel clustering 
+#  */
+# template <typename PointT>
+# class Supervoxel
+#       public:
+#       Supervoxel () :
+#         voxels_ (new pcl::PointCloud<PointT> ()),
+#         normals_ (new pcl::PointCloud<Normal> ())
+#       
+#       typedef boost::shared_ptr<Supervoxel<PointT> > Ptr;
+#       typedef boost::shared_ptr<const Supervoxel<PointT> > ConstPtr;
+#       
+#       /** \brief Gets the centroid of the supervoxel
+#        *  \param[out] centroid_arg centroid of the supervoxel
+#        */ 
+#       void getCentroidPoint (PointXYZRGBA &centroid_arg)
+#       
+#       /** \brief Gets the point normal for the supervoxel 
+#        * \param[out] normal_arg Point normal of the supervoxel
+#        * \note This isn't an average, it is a normal computed using all of the voxels in the supervoxel as support
+#        */ 
+#       void getCentroidPointNormal (PointNormal &normal_arg)
+
+
+###
+
+# # supervoxel_clustering.h
+# namespace pcl
+#   /** \brief Implements a supervoxel algorithm based on voxel structure, normals, and rgb values
+#    *   \note Supervoxels are oversegmented volumetric patches (usually surfaces) 
+#    *   \note Usually, color isn't needed (and can be detrimental)- spatial structure is mainly used
+#     * - J. Papon, A. Abramov, M. Schoeler, F. Woergoetter
+#     *   Voxel Cloud Connectivity Segmentation - Supervoxels from PointClouds
+#     *   In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 2013 
+#     *  \author Jeremie Papon (jpapon@gmail.com)
+#     */
+#   template <typename PointT>
+#   class PCL_EXPORTS SupervoxelClustering : public pcl::PCLBase<PointT>
+#   {
+#     //Forward declaration of friended helper class
+#     class SupervoxelHelper;
+#     friend class SupervoxelHelper;
+#     public:
+#       /** \brief VoxelData is a structure used for storing data within a pcl::octree::OctreePointCloudAdjacencyContainer
+#        *  \note It stores xyz, rgb, normal, distance, an index, and an owner.
+#        */
+#       class VoxelData
+#       {
+#         public:
+#           VoxelData ():
+#             xyz_ (0.0f, 0.0f, 0.0f),
+#             rgb_ (0.0f, 0.0f, 0.0f),
+#             normal_ (0.0f, 0.0f, 0.0f, 0.0f),
+#             curvature_ (0.0f),
+#             owner_ (0)
+#             {}
+#             
+#           /** \brief Gets the data of in the form of a point
+#            *  \param[out] point_arg Will contain the point value of the voxeldata
+#            */  
+#           void
+#           getPoint (PointT &point_arg) const;
+#           
+#           /** \brief Gets the data of in the form of a normal
+#            *  \param[out] normal_arg Will contain the normal value of the voxeldata
+#            */            
+#           void
+#           getNormal (Normal &normal_arg) const;
+#           
+#           Eigen::Vector3f xyz_;
+#           Eigen::Vector3f rgb_;
+#           Eigen::Vector4f normal_;
+#           float curvature_;
+#           float distance_;
+#           int idx_;
+#           SupervoxelHelper* owner_;
+#           
+#         public:
+#           EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#       };
+#       
+#       typedef pcl::octree::OctreePointCloudAdjacencyContainer<PointT, VoxelData> LeafContainerT;
+#       typedef std::vector <LeafContainerT*> LeafVectorT;
+#       typedef typename pcl::PointCloud<PointT> PointCloudT;
+#       typedef typename pcl::PointCloud<Normal> NormalCloudT;
+#       typedef typename pcl::octree::OctreePointCloudAdjacency<PointT, LeafContainerT> OctreeAdjacencyT;
+#       typedef typename pcl::octree::OctreePointCloudSearch <PointT> OctreeSearchT;
+#       typedef typename pcl::search::KdTree<PointT> KdTreeT;
+#       typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+#       
+#       using PCLBase <PointT>::initCompute;
+#       using PCLBase <PointT>::deinitCompute;
+#       using PCLBase <PointT>::input_;
+#       
+#       typedef boost::adjacency_list<boost::setS, boost::setS, boost::undirectedS, uint32_t, float> VoxelAdjacencyList;
+#       typedef VoxelAdjacencyList::vertex_descriptor VoxelID;
+#       typedef VoxelAdjacencyList::edge_descriptor EdgeID;
+#       
+#       
+#       public:
+#       
+#       /** \brief Constructor that sets default values for member variables. 
+#        *  \param[in] voxel_resolution The resolution (in meters) of voxels used
+#        *  \param[in] seed_resolution The average size (in meters) of resulting supervoxels
+#        *  \param[in] use_single_camera_transform Set to true if point density in cloud falls off with distance from origin (such as with a cloud coming from one stationary camera), set false if input cloud is from multiple captures from multiple locations.
+#        */
+#       SupervoxelClustering (float voxel_resolution, float seed_resolution, bool use_single_camera_transform = true);
+#       
+#       /** \brief This destructor destroys the cloud, normals and search method used for
+#         * finding neighbors. In other words it frees memory.
+#         */
+#       virtual
+#       ~SupervoxelClustering ();
+#       
+#       /** \brief Set the resolution of the octree voxels */
+#       void
+#       setVoxelResolution (float resolution);
+#       
+#       /** \brief Get the resolution of the octree voxels */
+#       float 
+#       getVoxelResolution () const;
+#       
+#       /** \brief Set the resolution of the octree seed voxels */
+#       void
+#       setSeedResolution (float seed_resolution);
+#       
+#       /** \brief Get the resolution of the octree seed voxels */
+#       float 
+#       getSeedResolution () const;
+#         
+#       /** \brief Set the importance of color for supervoxels */
+#       void
+#       setColorImportance (float val);
+#       
+#       /** \brief Set the importance of spatial distance for supervoxels */
+#       void
+#       setSpatialImportance (float val);
+#             
+#       /** \brief Set the importance of scalar normal product for supervoxels */
+#       void
+#       setNormalImportance (float val);
+#       
+#       /** \brief This method launches the segmentation algorithm and returns the supervoxels that were
+#        * obtained during the segmentation.
+#        * \param[out] supervoxel_clusters A map of labels to pointers to supervoxel structures
+#        */
+#       virtual void
+#       extract (std::map<uint32_t,typename Supervoxel<PointT>::Ptr > &supervoxel_clusters);
+#       
+#       /** \brief This method sets the cloud to be supervoxelized
+#        * \param[in] cloud The cloud to be supervoxelize
+#        */
+#       virtual void
+#       setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr& cloud);
+#       
+#       /** \brief This method sets the normals to be used for supervoxels (should be same size as input cloud)
+#       * \param[in] normal_cloud The input normals                         
+#       */
+#       virtual void
+#       setNormalCloud (typename NormalCloudT::ConstPtr normal_cloud);
+#       
+#       /** \brief This method refines the calculated supervoxels - may only be called after extract
+#        * \param[in] num_itr The number of iterations of refinement to be done (2 or 3 is usually sufficient)
+#        * \param[out] supervoxel_clusters The resulting refined supervoxels
+#        */
+#       virtual void
+#       refineSupervoxels (int num_itr, std::map<uint32_t,typename Supervoxel<PointT>::Ptr > &supervoxel_clusters);
+#       
+#       ////////////////////////////////////////////////////////////
+#       /** \brief Returns an RGB colorized cloud showing superpixels
+#         * Otherwise it returns an empty pointer.
+#         * Points that belong to the same supervoxel have the same color.
+#         * But this function doesn't guarantee that different segments will have different
+#         * color(it's random). Points that are unlabeled will be black
+#         * \note This will expand the label_colors_ vector so that it can accomodate all labels
+#         */
+#       typename pcl::PointCloud<PointXYZRGBA>::Ptr
+#       getColoredCloud () const;
+#       
+#       /** \brief Returns a deep copy of the voxel centroid cloud */
+#       typename pcl::PointCloud<PointT>::Ptr
+#       getVoxelCentroidCloud () const;
+#       
+#       /** \brief Returns labeled cloud
+#         * Points that belong to the same supervoxel have the same label.
+#         * Labels for segments start from 1, unlabled points have label 0
+#         */
+#       typename pcl::PointCloud<PointXYZL>::Ptr
+#       getLabeledCloud () const;
+#       
+#       /** \brief Returns an RGB colorized voxelized cloud showing superpixels
+#        * Otherwise it returns an empty pointer.
+#        * Points that belong to the same supervoxel have the same color.
+#        * But this function doesn't guarantee that different segments will have different
+#        * color(it's random). Points that are unlabeled will be black
+#        * \note This will expand the label_colors_ vector so that it can accomodate all labels
+#        */
+#       pcl::PointCloud<pcl::PointXYZRGBA>::Ptr
+#       getColoredVoxelCloud () const;
+#       
+#       /** \brief Returns labeled voxelized cloud
+#        * Points that belong to the same supervoxel have the same label.
+#        * Labels for segments start from 1, unlabled points have label 0
+#        */      
+#       pcl::PointCloud<pcl::PointXYZL>::Ptr
+#       getLabeledVoxelCloud () const;
+# 
+#       /** \brief Gets the adjacency list (Boost Graph library) which gives connections between supervoxels
+#        *  \param[out] adjacency_list_arg BGL graph where supervoxel labels are vertices, edges are touching relationships
+#        */
+#       void
+#       getSupervoxelAdjacencyList (VoxelAdjacencyList &adjacency_list_arg) const;
+#       
+#       /** \brief Get a multimap which gives supervoxel adjacency
+#        *  \param[out] label_adjacency Multi-Map which maps a supervoxel label to all adjacent supervoxel labels
+#        */
+#       void getSupervoxelAdjacency (std::multimap<uint32_t, uint32_t> &label_adjacency) const;
+#             
+#       /** \brief Static helper function which returns a pointcloud of normals for the input supervoxels 
+#        *  \param[in] supervoxel_clusters Supervoxel cluster map coming from this class
+#        *  \returns Cloud of PointNormals of the supervoxels
+#        * 
+#        */
+#       static pcl::PointCloud<pcl::PointNormal>::Ptr
+#       makeSupervoxelNormalCloud (std::map<uint32_t,typename Supervoxel<PointT>::Ptr > &supervoxel_clusters);
+#       
+#       /** \brief Returns the current maximum (highest) label */
+#       int getMaxLabel () const;
+#   };
+# 
+# }
+
+
+###
+
+
diff --git a/pcl/pcl_segmentation_180.pxd b/pcl/pcl_segmentation_180.pxd
new file mode 100644
index 0000000..b8d0b88
--- /dev/null
+++ b/pcl/pcl_segmentation_180.pxd
@@ -0,0 +1,4053 @@
+# -*- coding: utf-8 -*-
+
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+from boost_shared_ptr cimport shared_ptr
+
+# main
+# cimport pcl_defs as cpp
+from pcl_defs cimport PointIndices
+from pcl_defs cimport ModelCoefficients
+from pcl_defs cimport PointCloud
+from pcl_defs cimport PointXYZ
+from pcl_defs cimport PointXYZI
+from pcl_defs cimport PointXYZRGB
+from pcl_defs cimport PointXYZRGBA
+from pcl_defs cimport Normal
+from pcl_defs cimport PCLBase
+from pcl_sample_consensus cimport SacModel
+cimport pcl_surface as pclsf
+cimport pcl_kdtree as pclkdt
+
+##
+
+from vector cimport vector as vector2
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+cdef extern from "pcl/segmentation/sac_segmentation.h" namespace "pcl":
+    cdef cppclass SACSegmentation[T](PCLBase[T]):
+        SACSegmentation()
+        void setModelType (SacModel)
+        # /** \brief Empty constructor. */
+        # SACSegmentation () :  model_ (), sac_ (), model_type_ (-1), method_type_ (0), 
+        #                       threshold_ (0), optimize_coefficients_ (true), 
+        #                       radius_min_ (-std::numeric_limits<double>::max()), radius_max_ (std::numeric_limits<double>::max()), samples_radius_ (0.0), eps_angle_ (0.0),
+        #                       axis_ (Eigen::Vector3f::Zero ()), max_iterations_ (50), probability_ (0.99)
+        # 
+        # /** \brief Get the type of SAC model used.
+        # inline int getModelType () const { return (model_type_); }
+        int getModelType ()
+        
+        # \brief Get a pointer to the SAC method used.
+        # inline SampleConsensusPtr getMethod () const { return (sac_); }
+        # 
+        # \brief Get a pointer to the SAC model used.
+        # inline SampleConsensusModelPtr getModel () const { return (model_); }
+        
+        void setMethodType (int)
+        # \brief Get the type of sample consensus method used.
+        # inline int getMethodType () const { return (method_type_); }
+        int getMethodType ()
+        
+        void setDistanceThreshold (float)
+        # \brief Get the distance to the model threshold.
+        # inline double getDistanceThreshold () const { return (threshold_); }
+        double getDistanceThreshold ()
+        
+        # use PCLBase class function
+        # void setInputCloud (shared_ptr[PointCloud[T]])
+        
+        void setMaxIterations (int)
+        # \brief Get maximum number of iterations before giving up.
+        # inline int getMaxIterations () const { return (max_iterations_); }
+        int getMaxIterations ()
+        
+        # \brief Set the probability of choosing at least one sample free from outliers.
+        # \param[in] probability the model fitting probability
+        # inline void setProbability (double probability) { probability_ = probability; }
+        void setProbability (double probability)
+        
+        # \brief Get the probability of choosing at least one sample free from outliers.
+        # inline double getProbability () const { return (probability_); }
+        double getProbability ()
+        
+        void setOptimizeCoefficients (bool)
+        
+        # \brief Get the coefficient refinement internal flag.
+        # inline bool getOptimizeCoefficients () const { return (optimize_coefficients_); }
+        bool getOptimizeCoefficients ()
+        
+        # \brief Set the minimum and maximum allowable radius limits for the model (applicable to models that estimate a radius)
+        # \param[in] min_radius the minimum radius model
+        # \param[in] max_radius the maximum radius model
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        void setRadiusLimits (const double &min_radius, const double &max_radius)
+        
+        # \brief Get the minimum and maximum allowable radius limits for the model as set by the user.
+        # \param[out] min_radius the resultant minimum radius model
+        # \param[out] max_radius the resultant maximum radius model
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        void getRadiusLimits (double &min_radius, double &max_radius)
+        
+        # \brief Set the maximum distance allowed when drawing random samples
+        # \param[in] radius the maximum distance (L2 norm)
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        # void setSamplesMaxDist (const double &radius, SearchPtr search)
+        
+        # \brief Get maximum distance allowed when drawing random samples
+        # \param[out] radius the maximum distance (L2 norm)
+        # inline void getSamplesMaxDist (double &radius)
+        void getSamplesMaxDist (double &radius)
+        
+        # \brief Set the axis along which we need to search for a model perpendicular to.
+        # \param[in] ax the axis along which we need to search for a model perpendicular to
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # void setAxis (const eigen3.Vector3f &ax)
+        
+        # \brief Get the axis along which we need to search for a model perpendicular to.
+        # inline Eigen::Vector3f getAxis () const { return (axis_); }
+        # eigen3.Vector3f getAxis ()
+        
+        # \brief Set the angle epsilon (delta) threshold.
+        # \param[in] ea the maximum allowed difference between the model normal and the given axis in radians.
+        # inline void setEpsAngle (double ea) { eps_angle_ = ea; }
+        void setEpsAngle (double ea)
+        
+        # /** \brief Get the epsilon (delta) model angle threshold in radians. */
+        # inline double getEpsAngle () const { return (eps_angle_); }
+        double getEpsAngle ()
+
+        void segment (PointIndices, ModelCoefficients)
+
+
+ctypedef SACSegmentation[PointXYZ] SACSegmentation_t
+ctypedef SACSegmentation[PointXYZI] SACSegmentation_PointXYZI_t
+ctypedef SACSegmentation[PointXYZRGB] SACSegmentation_PointXYZRGB_t
+ctypedef SACSegmentation[PointXYZRGBA] SACSegmentation_PointXYZRGBA_t
+###
+
+# \brief @b SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and
+# models that require the use of surface normals for estimation.
+# \ingroup segmentation
+cdef extern from "pcl/segmentation/sac_segmentation.h" namespace "pcl":
+    # cdef cppclass SACSegmentationFromNormals[T, N](SACSegmentation[T])
+    cdef cppclass SACSegmentationFromNormals[T, N]:
+        SACSegmentationFromNormals()
+        void setOptimizeCoefficients (bool)
+        void setModelType (SacModel)
+        void setMethodType (int)
+        void setNormalDistanceWeight (float)
+        void setMaxIterations (int)
+        void setDistanceThreshold (float)
+        void setRadiusLimits (float, float)
+        void setInputCloud (shared_ptr[PointCloud[T]])
+        void setInputNormals (shared_ptr[PointCloud[N]])
+        void setEpsAngle (double ea)
+        void segment (PointIndices, ModelCoefficients)
+        void setMinMaxOpeningAngle(double, double)
+        void getMinMaxOpeningAngle(double, double)
+        # Add
+        # /** \brief Empty constructor. */
+        # SACSegmentationFromNormals () : 
+        #   normals_ (), 
+        #   distance_weight_ (0.1), 
+        #   distance_from_origin_ (0), 
+        #   min_angle_ (), 
+        #   max_angle_ ()
+        # {};
+        # 
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        #   * the XYZ dataset.
+        #   * \param[in] normals the const boost shared pointer to a PointCloud message
+        #   */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) { normals_ = normals; }
+        # 
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals () const { return (normals_); }
+        # 
+        # /** \brief Set the relative weight (between 0 and 1) to give to the angular 
+        #   * distance (0 to pi/2) between point normals and the plane normal.
+        #   * \param[in] distance_weight the distance/angular weight
+        #   */
+        # inline void setNormalDistanceWeight (double distance_weight) { distance_weight_ = distance_weight; }
+        # 
+        # /** \brief Get the relative weight (between 0 and 1) to give to the angular distance (0 to pi/2) between point
+        #   * normals and the plane normal. */
+        # inline double getNormalDistanceWeight () const { return (distance_weight_); }
+        # 
+        # /** \brief Set the minimum opning angle for a cone model.
+        #   * \param oa the opening angle which we need minumum to validate a cone model.
+        #   */
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        # 
+        # /** \brief Get the opening angle which we need minumum to validate a cone model. */
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle)
+        # 
+        # /** \brief Set the distance we expect a plane model to be from the origin
+        #   * \param[in] d distance from the template plane modl to the origin
+        #   */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        # 
+        # /** \brief Get the distance of a plane model from the origin. */
+        # inline double getDistanceFromOrigin () const { return (distance_from_origin_); }
+
+
+ctypedef SACSegmentationFromNormals[PointXYZ,Normal] SACSegmentationFromNormals_t
+ctypedef SACSegmentationFromNormals[PointXYZI,Normal] SACSegmentationFromNormals_PointXYZI_t
+ctypedef SACSegmentationFromNormals[PointXYZRGB,Normal] SACSegmentationFromNormals_PointXYZRGB_t
+ctypedef SACSegmentationFromNormals[PointXYZRGBA,Normal] SACSegmentationFromNormals_PointXYZRGBA_t
+###
+
+# comparator.h
+# namespace pcl
+# brief Comparator is the base class for comparators that compare two points given some function.
+# Currently intended for use with OrganizedConnectedComponentSegmentation
+# author Alex Trevor
+# template <typename PointT> class Comparator
+cdef extern from "pcl/segmentation/comparator.h" namespace "pcl":
+    cdef cppclass Comparator[T]:
+        Comparator()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<Comparator<PointT> > Ptr;
+        # typedef boost::shared_ptr<const Comparator<PointT> > ConstPtr;
+        # 
+        # /** \brief Set the input cloud for the comparator.
+        #   * \param[in] cloud the point cloud this comparator will operate on
+        #   */
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # 
+        # /** \brief Get the input cloud this comparator operates on. */
+        # virtual PointCloudConstPtr getInputCloud () const
+        # 
+        # /** \brief Compares the two points in the input cloud designated by these two indices.
+        #   * This is pure virtual and must be implemented by subclasses with some comparison function.
+        #   * \param[in] idx1 the index of the first point.
+        #   * \param[in] idx2 the index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const = 0;
+        # 
+        # protected:
+        #   PointCloudConstPtr input_;
+###
+
+# plane_coefficient_comparator.h
+# namespace pcl
+# brief PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation.
+# In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+# author Alex Trevor
+# template<typename PointT, typename PointNT> class PlaneCoefficientComparator: public Comparator<PointT>
+cdef extern from "pcl/segmentation/plane_coefficient_comparator.h" namespace "pcl":
+    cdef cppclass PlaneCoefficientComparator[T, NT](Comparator[T]):
+        PlaneCoefficientComparator()
+        # PlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<PlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const PlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # /** \brief Provide a pointer to the input normals.
+        #   * \param[in] normals the input normal cloud
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # void setPlaneCoeffD (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # void setPlaneCoeffD (std::vector<float>& plane_coeff_d)
+        # /** \brief Get a pointer to the vector of the d-coefficient of the planes' hessian normal form. */
+        # const std::vector<float>& getPlaneCoeffD () const
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #   * \param[in] angular_threshold the tolerance in radians
+        # virtual void setAngularThreshold (float angular_threshold)
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters (at 1m)
+        #   * \param[in] depth_dependent whether to scale the threshold based on range from the sensor (default: false)
+        # void setDistanceThreshold (float distance_threshold, bool depth_dependent = false)
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+### Inheritance class ###
+
+# edge_aware_plane_comparator.h
+# namespace pcl
+# /** \brief EdgeAwarePlaneComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Stefan Holzer, Alex Trevor
+#   */
+# template<typename PointT, typename PointNT>
+# class EdgeAwarePlaneComparator: public PlaneCoefficientComparator<PointT, PointNT>
+cdef extern from "pcl/segmentation/edge_aware_plane_comparator.h" namespace "pcl":
+    cdef cppclass EdgeAwarePlaneComparator[T, NT](PlaneCoefficientComparator[T, NT]):
+        EdgeAwarePlaneComparator()
+        # EdgeAwarePlaneComparator (const float *distance_map)
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<EdgeAwarePlaneComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const EdgeAwarePlaneComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Set a distance map to use. For an example of a valid distance map see 
+        #   * \ref OrganizedIntegralImageNormalEstimation
+        #   * \param[in] distance_map the distance map to use
+        #   */
+        # inline void setDistanceMap (const float *distance_map)
+        # /** \brief Return the distance map used. */
+        # const float* getDistanceMap () const
+
+
+###
+
+# euclidean_cluster_comparator.h
+# namespace pcl
+# /** \brief EuclideanClusterComparator is a comparator used for finding clusters supported by planar surfaces.
+#   * This needs to be run as a second pass after extracting planar surfaces, using MultiPlaneSegmentation for example.
+#   * \author Alex Trevor
+# template<typename PointT, typename PointNT, typename PointLT>
+# class EuclideanClusterComparator: public Comparator<PointT>
+cdef extern from "pcl/segmentation/euclidean_cluster_comparator.h" namespace "pcl":
+    cdef cppclass EuclideanClusterComparator[T, NT, LT](Comparator[T]):
+        EuclideanClusterComparator()
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # typedef boost::shared_ptr<EuclideanClusterComparator<PointT, PointNT, PointLT> > Ptr;
+        # typedef boost::shared_ptr<const EuclideanClusterComparator<PointT, PointNT, PointLT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        
+        # /** \brief Provide a pointer to the input normals.
+        #   * \param[in] normals the input normal cloud
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        void setInputNormals (const shared_ptr[PointCloud[NT]] &normals)
+        
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        const shared_ptr[PointCloud[NT]] getInputNormals ()
+        
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #   * \param[in] angular_threshold the tolerance in radians
+        # virtual inline void setAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        float getAngularThreshold ()
+        
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters
+        # inline void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        void setDistanceThreshold (float distance_threshold, bool depth_dependent)
+        
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        float getDistanceThreshold ()
+        
+        # /** \brief Set label cloud
+        #   * \param[in] labels The label cloud
+        # void setLabels (PointCloudLPtr& labels)
+        void setLabels (shared_ptr[PointCloud[LT]] &labels)
+        
+        # 
+        # /** \brief Set labels in the label cloud to exclude.
+        #   * \param exclude_labels a vector of bools corresponding to whether or not a given label should be considered
+        # void setExcludeLabels (std::vector<bool>& exclude_labels)
+        void setExcludeLabels (vector[bool]& exclude_labels)
+        
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        # virtual bool compare (int idx1, int idx2) const
+
+
+ctypedef EuclideanClusterComparator[PointXYZ, Normal, PointXYZ] EuclideanClusterComparator_t
+ctypedef EuclideanClusterComparator[PointXYZI, Normal, PointXYZ] EuclideanClusterComparator_PointXYZI_t
+ctypedef EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGB_t
+ctypedef EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ] EuclideanClusterComparator_PointXYZRGBA_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZ, Normal, PointXYZ]] EuclideanClusterComparatorPtr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZI, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZI_Ptr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGB, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[EuclideanClusterComparator[PointXYZRGBA, Normal, PointXYZ]] EuclideanClusterComparator_PointXYZRGBA_Ptr_t
+###
+
+# euclidean_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief EuclideanPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Alex Trevor
+# template<typename PointT, typename PointNT>
+# class EuclideanPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+cdef extern from "pcl/segmentation/euclidean_plane_coefficient_comparator.h" namespace "pcl":
+    cdef cppclass EuclideanPlaneCoefficientComparator[T, NT](PlaneCoefficientComparator[T, NT]):
+        EuclideanPlaneCoefficientComparator()
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<EuclideanPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const EuclideanPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Compare two neighboring points, by using normal information, and euclidean distance information.
+        #   * \param[in] idx1 The index of the first point.
+        #   * \param[in] idx2 The index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# extract_clusters.h
+# namespace pcl
+# brief Decompose a region of space into clusters based on the Euclidean distance between points
+# param cloud the point cloud message
+# param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+# note the tree has to be created as a spatial locator on \a cloud
+# param tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+# param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+# param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+# param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+# ingroup segmentation
+# template <typename PointT> void extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const boost::shared_ptr<search::Search<PointT> > &tree, 
+#       float tolerance, std::vector<PointIndices> &clusters, 
+#       unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ());
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#   * \param cloud the point cloud message
+#   * \param indices a list of point indices to use from \a cloud
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud and \a indices
+#   * \param tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> void 
+# extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const std::vector<int> &indices, 
+#       const boost::shared_ptr<search::Search<PointT> > &tree, float tolerance, std::vector<PointIndices> &clusters, 
+#       unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ());
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the euclidean distance between points, and the normal
+#   * angular deviation
+#   * \param cloud the point cloud message
+#   * \param normals the point cloud message containing normal information
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param eps_angle the maximum allowed difference between normals in radians for cluster/region growing
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT, typename Normal> void 
+# extractEuclideanClusters (
+#       const PointCloud<PointT> &cloud, const PointCloud<Normal> &normals, 
+#       float tolerance, const boost::shared_ptr<KdTree<PointT> > &tree, 
+#       std::vector<PointIndices> &clusters, double eps_angle, 
+#       unsigned int min_pts_per_cluster = 1, 
+#       unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ())
+###
+
+# extract_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the euclidean distance between points, and the normal
+#   * angular deviation
+#   * \param cloud the point cloud message
+#   * \param normals the point cloud message containing normal information
+#   * \param indices a list of point indices to use from \a cloud
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#   * \param clusters the resultant clusters containing point indices (as PointIndices)
+#   * \param eps_angle the maximum allowed difference between normals in degrees for cluster/region growing
+#   * \param min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \ingroup segmentation
+#   */
+# template <typename PointT, typename Normal> 
+# void extractEuclideanClusters (
+#     const PointCloud<PointT> &cloud, const PointCloud<Normal> &normals, 
+#     const std::vector<int> &indices, const boost::shared_ptr<KdTree<PointT> > &tree, 
+#     float tolerance, std::vector<PointIndices> &clusters, double eps_angle, 
+#     unsigned int min_pts_per_cluster = 1, 
+#     unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) ())
+###
+
+# extract_clusters.h
+# namespace pcl
+# EuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense.
+# author Radu Bogdan Rusu
+# ingroup segmentation
+# template <typename PointT>
+# class EuclideanClusterExtraction: public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_clusters.h" namespace "pcl":
+    cdef cppclass EuclideanClusterExtraction[T](PCLBase[T]):
+        EuclideanClusterExtraction()
+        # public:
+        # EuclideanClusterExtraction () : tree_ (), 
+        #                                 cluster_tolerance_ (0),
+        #                                 min_pts_per_cluster_ (1), 
+        #                                 max_pts_per_cluster_ (std::numeric_limits<int>::max ())
+        
+        # brief Provide a pointer to the search object.
+        # param[in] tree a pointer to the spatial search object.
+        # inline void setSearchMethod (const KdTreePtr &tree) 
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # brief Get a pointer to the search method used. 
+        # @todo fix this for a generic search tree
+        # inline KdTreePtr getSearchMethod () const 
+        pclkdt.KdTreePtr_t getSearchMethod ()
+        
+        # brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+        # param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+        # inline void setClusterTolerance (double tolerance) 
+        void setClusterTolerance (double tolerance) 
+        
+        # brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space.
+        # inline double getClusterTolerance () const 
+        double getClusterTolerance ()
+        
+        # brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # param[in] min_cluster_size the minimum cluster size
+        # inline void setMinClusterSize (int min_cluster_size) 
+        void setMinClusterSize (int min_cluster_size) 
+        
+        # brief Get the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # inline int getMinClusterSize () const 
+        int getMinClusterSize ()
+        
+        # brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # param[in] max_cluster_size the maximum cluster size
+        # inline void setMaxClusterSize (int max_cluster_size) 
+        void setMaxClusterSize (int max_cluster_size) 
+        
+        # brief Get the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # inline int getMaxClusterSize () const 
+        int getMaxClusterSize ()
+        
+        # brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        # param[out] clusters the resultant point clusters
+        # void extract (std::vector<PointIndices> &clusters);
+        void extract (vector[PointIndices] &clusters)
+
+
+ctypedef EuclideanClusterExtraction[PointXYZ] EuclideanClusterExtraction_t
+ctypedef EuclideanClusterExtraction[PointXYZI] EuclideanClusterExtraction_PointXYZI_t
+ctypedef EuclideanClusterExtraction[PointXYZRGB] EuclideanClusterExtraction_PointXYZRGB_t
+ctypedef EuclideanClusterExtraction[PointXYZRGBA] EuclideanClusterExtraction_PointXYZRGBA_t
+###
+
+
+# extract_labeled_clusters.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#   * \param[in] cloud the point cloud message
+#   * \param[in] tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#   * \note the tree has to be created as a spatial locator on \a cloud
+#   * \param[in] tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#   * \param[out] labeled_clusters the resultant clusters containing point indices (as a vector of PointIndices)
+#   * \param[in] min_pts_per_cluster minimum number of points that a cluster may contain (default: 1)
+#   * \param[in] max_pts_per_cluster maximum number of points that a cluster may contain (default: max int)
+#   * \param[in] max_label
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> void 
+# extractLabeledEuclideanClusters (
+#     const PointCloud<PointT> &cloud, const boost::shared_ptr<search::Search<PointT> > &tree, 
+#     float tolerance, std::vector<std::vector<PointIndices> > &labeled_clusters, 
+#     unsigned int min_pts_per_cluster = 1, unsigned int max_pts_per_cluster = (std::numeric_limits<int>::max) (), 
+#     unsigned int max_label = (std::numeric_limits<int>::max));
+
+
+# extract_labeled_clusters.h
+# namespace pcl
+# brief @b LabeledEuclideanClusterExtraction represents a segmentation class for cluster extraction in an Euclidean sense, with label info.
+# author Koen Buys
+# ingroup segmentation
+# template <typename PointT>
+# class LabeledEuclideanClusterExtraction: public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_labeled_clusters.h" namespace "pcl":
+    cdef cppclass LabeledEuclideanClusterExtraction[T](PCLBase[T]):
+        LabeledEuclideanClusterExtraction()
+        # typedef PCLBase<PointT> BasePCLBase;
+        # 
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::search::Search<PointT> KdTree;
+        # typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # /** \brief Empty constructor. */
+        # LabeledEuclideanClusterExtraction () : 
+        #   tree_ (), 
+        #   cluster_tolerance_ (0),
+        #   min_pts_per_cluster_ (1), 
+        #   max_pts_per_cluster_ (std::numeric_limits<int>::max ()),
+        #   max_label_ (std::numeric_limits<int>::max ())
+        # {};
+        # 
+        # /** \brief Provide a pointer to the search object.
+        #   * \param[in] tree a pointer to the spatial search object.
+        #   */
+        # inline void setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+        # 
+        # /** \brief Get a pointer to the search method used. */
+        # inline KdTreePtr getSearchMethod () const { return (tree_); }
+        # 
+        # /** \brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+        #   * \param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+        #   */
+        # inline void setClusterTolerance (double tolerance) { cluster_tolerance_ = tolerance; }
+        # 
+        # /** \brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space. */
+        # inline double getClusterTolerance () const { return (cluster_tolerance_); }
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        #   * \param[in] min_cluster_size the minimum cluster size
+        #   */
+        # inline void setMinClusterSize (int min_cluster_size) { min_pts_per_cluster_ = min_cluster_size; }
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # inline int getMinClusterSize () const { return (min_pts_per_cluster_); }
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        #   * \param[in] max_cluster_size the maximum cluster size
+        #   */
+        # inline void setMaxClusterSize (int max_cluster_size) { max_pts_per_cluster_ = max_cluster_size; }
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # inline int getMaxClusterSize () const { return (max_pts_per_cluster_); }
+        # 
+        # /** \brief Set the maximum number of labels in the cloud.
+        #   * \param[in] max_label the maximum
+        #   */
+        # inline void setMaxLabels (unsigned int max_label) { max_label_ = max_label; }
+        # 
+        # /** \brief Get the maximum number of labels */
+        # inline unsigned int getMaxLabels () const { return (max_label_); }
+        # 
+        # /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        #   * \param[out] labeled_clusters the resultant point clusters
+        #   */
+        # void extract (std::vector<std::vector<PointIndices> > &labeled_clusters);
+        # 
+        # protected:
+        #     // Members derived from the base class
+        #     using BasePCLBase::input_;
+        #     using BasePCLBase::indices_;
+        #     using BasePCLBase::initCompute;
+        #     using BasePCLBase::deinitCompute;
+        # 
+        # /** \brief A pointer to the spatial search object. */
+        # KdTreePtr tree_;
+        # /** \brief The spatial cluster tolerance as a measure in the L2 Euclidean space. */
+        # double cluster_tolerance_;
+        # /** \brief The minimum number of points that a cluster needs to contain in order to be considered valid (default = 1). */
+        # int min_pts_per_cluster_;
+        # /** \brief The maximum number of points that a cluster needs to contain in order to be considered valid (default = MAXINT). */
+        # int max_pts_per_cluster_;
+        # /** \brief The maximum number of labels we can find in this pointcloud (default = MAXINT)*/
+        # unsigned int max_label_;
+        # /** \brief Class getName method. */
+        # virtual std::string getClassName () const { return ("LabeledEuclideanClusterExtraction"); }
+        # 
+
+        #   brief Sort clusters method (for std::sort). 
+        #   ingroup segmentation
+        #   inline bool compareLabeledPointClusters (const pcl::PointIndices &a, const pcl::PointIndices &b)
+        #   {
+        #     return (a.indices.size () < b.indices.size ());
+        #   }
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief General purpose method for checking if a 3D point is inside or
+#   * outside a given 2D polygon. 
+#   * \note this method accepts any general 3D point that is projected onto the
+#   * 2D polygon, but performs an internal XY projection of both the polygon and the point. 
+#   * \param point a 3D point projected onto the same plane as the polygon
+#   * \param polygon a polygon
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> bool isPointIn2DPolygon (const PointT &point, const pcl::PointCloud<PointT> &polygon);
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief Check if a 2d point (X and Y coordinates considered only!) is
+#   * inside or outside a given polygon. This method assumes that both the point
+#   * and the polygon are projected onto the XY plane.
+#   *
+#   * \note (This is highly optimized code taken from http://www.visibone.com/inpoly/)
+#   *       Copyright (c) 1995-1996 Galacticomm, Inc.  Freeware source code.
+#   * \param point a 3D point projected onto the same plane as the polygon
+#   * \param polygon a polygon
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> bool 
+# isXYPointIn2DXYPolygon (const PointT &point, const pcl::PointCloud<PointT> &polygon);
+###
+
+# extract_polygonal_prism_data.h
+# namespace pcl
+# /** \brief @b ExtractPolygonalPrismData uses a set of point indices that
+#   * represent a planar model, and together with a given height, generates a 3D
+#   * polygonal prism. The polygonal prism is then used to segment all points
+#   * lying inside it.
+#   * An example of its usage is to extract the data lying within a set of 3D
+#   * boundaries (e.g., objects supported by a plane).
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class ExtractPolygonalPrismData : public PCLBase<PointT>
+cdef extern from "pcl/segmentation/extract_polygonal_prism_data.h" namespace "pcl":
+    cdef cppclass ExtractPolygonalPrismData[T](PCLBase[T]):
+        ExtractPolygonalPrismData()
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef PointIndices::Ptr PointIndicesPtr;
+        # typedef PointIndices::ConstPtr PointIndicesConstPtr;
+        # 
+        # brief Empty constructor.
+        # ExtractPolygonalPrismData () : planar_hull_ (), min_pts_hull_ (3), 
+        #                                height_limit_min_ (0), height_limit_max_ (FLT_MAX),
+        #                                vpx_ (0), vpy_ (0), vpz_ (0)
+        # {};
+        # 
+        # brief Provide a pointer to the input planar hull dataset.
+        # param[in] hull the input planar hull dataset
+        # inline void setInputPlanarHull (const PointCloudConstPtr &hull) { planar_hull_ = hull; }
+        # 
+        # brief Get a pointer the input planar hull dataset.
+        # inline PointCloudConstPtr getInputPlanarHull () const { return (planar_hull_); }
+        # 
+        # brief Set the height limits. All points having distances to the
+        # model outside this interval will be discarded.
+        # param[in] height_min the minimum allowed distance to the plane model value
+        # param[in] height_max the maximum allowed distance to the plane model value
+        # inline void setHeightLimits (double height_min, double height_max)
+        # 
+        # brief Get the height limits (min/max) as set by the user. The
+        # default values are -FLT_MAX, FLT_MAX. 
+        # param[out] height_min the resultant min height limit
+        # param[out] height_max the resultant max height limit
+        # inline void getHeightLimits (double &height_min, double &height_max) const
+        # 
+        # brief Set the viewpoint.
+        # param[in] vpx the X coordinate of the viewpoint
+        # param[in] vpy the Y coordinate of the viewpoint
+        # param[in] vpz the Z coordinate of the viewpoint
+        # inline void setViewPoint (float vpx, float vpy, float vpz)
+        # 
+        # brief Get the viewpoint.
+        # inline void getViewPoint (float &vpx, float &vpy, float &vpz) const
+        # 
+        # /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+        #   * \param[out] output the resultant point indices that support the model found (inliers)
+        # void segment (PointIndices &output);
+        # 
+        # protected:
+        # brief A pointer to the input planar hull dataset.
+        # PointCloudConstPtr planar_hull_;
+        # 
+        # brief The minimum number of points needed on the convex hull.
+        # int min_pts_hull_;
+        # 
+        # brief The minimum allowed height (distance to the model) a point
+        # will be considered from. 
+        # double height_limit_min_;
+        # 
+        # brief The maximum allowed height (distance to the model) a point will be considered from. 
+        # double height_limit_max_;
+        # 
+        # brief Values describing the data acquisition viewpoint. Default: 0,0,0.
+        # float vpx_, vpy_, vpz_;
+        # 
+        # brief Class getName method.
+        # virtual std::string getClassName () const { return ("ExtractPolygonalPrismData"); }
+
+
+###
+
+# organized_connected_component_segmentation.h
+# namespace pcl
+# /** \brief OrganizedConnectedComponentSegmentation allows connected
+#   * components to be found within organized point cloud data, given a
+#   * comparison function.  Given an input cloud and a comparator, it will
+#   * output a PointCloud of labels, giving each connected component a unique
+#   * id, along with a vector of PointIndices corresponding to each component.
+#   * See OrganizedMultiPlaneSegmentation for an example application.
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template <typename PointT, typename PointLT>
+# class OrganizedConnectedComponentSegmentation : public PCLBase<PointT>
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::indices_;
+#     using PCLBase<PointT>::initCompute;
+#     using PCLBase<PointT>::deinitCompute;
+# 
+#     public:
+#       typedef typename pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+# 
+#       typedef typename pcl::Comparator<PointT> Comparator;
+#       typedef typename Comparator::Ptr ComparatorPtr;
+#       typedef typename Comparator::ConstPtr ComparatorConstPtr;
+#       
+#       /** \brief Constructor for OrganizedConnectedComponentSegmentation
+#         * \param[in] compare A pointer to the comparator to be used for segmentation.  Must be an instance of pcl::Comparator.
+#         */
+#       OrganizedConnectedComponentSegmentation (const ComparatorConstPtr& compare)
+#         : compare_ (compare)
+#       {
+#       }
+# 
+#       /** \brief Destructor for OrganizedConnectedComponentSegmentation. */
+#       virtual
+#       ~OrganizedConnectedComponentSegmentation ()
+#       {
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for segmentation.
+#         * \param[in] compare the comparator
+#         */
+#       void
+#       setComparator (const ComparatorConstPtr& compare)
+#       {
+#         compare_ = compare;
+#       }
+#       
+#       /** \brief Get the comparator.*/
+#       ComparatorConstPtr
+#       getComparator () const { return (compare_); }
+# 
+#       /** \brief Perform the connected component segmentation.
+#         * \param[out] labels a PointCloud of labels: each connected component will have a unique id.
+#         * \param[out] label_indices a vector of PointIndices corresponding to each label / component id.
+#         */
+#       void
+#       segment (pcl::PointCloud<PointLT>& labels, std::vector<pcl::PointIndices>& label_indices) const;
+#       
+#       /** \brief Find the boundary points / contour of a connected component
+#         * \param[in] start_idx the first (lowest) index of the connected component for which a boundary shoudl be returned
+#         * \param[in] labels the Label cloud produced by segmentation
+#         * \param[out] boundary_indices the indices of the boundary points for the label corresponding to start_idx
+#         */
+#       static void
+#       findLabeledRegionBoundary (int start_idx, PointCloudLPtr labels, pcl::PointIndices& boundary_indices);      
+#       
+# 
+#     protected:
+#       ComparatorConstPtr compare_;
+#       
+#       inline unsigned
+#       findRoot (const std::vector<unsigned>& runs, unsigned index) const
+#       {
+#         register unsigned idx = index;
+#         while (runs[idx] != idx)
+#           idx = runs[idx];
+# 
+#         return (idx);
+#       }
+###
+
+# organized_multi_plane_segmentation.h
+# namespace pcl
+# /** \brief OrganizedMultiPlaneSegmentation finds all planes present in the
+#   * input cloud, and outputs a vector of plane equations, as well as a vector
+#   * of point clouds corresponding to the inliers of each detected plane.  Only
+#   * planes with more than min_inliers points are detected.
+#   * Templated on point type, normal type, and label type
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class OrganizedMultiPlaneSegmentation : public PCLBase<PointT>
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::indices_;
+#     using PCLBase<PointT>::initCompute;
+#     using PCLBase<PointT>::deinitCompute;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+# 
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+# 
+#       typedef typename pcl::PlaneCoefficientComparator<PointT, PointNT> PlaneComparator;
+#       typedef typename PlaneComparator::Ptr PlaneComparatorPtr;
+#       typedef typename PlaneComparator::ConstPtr PlaneComparatorConstPtr;
+# 
+#       typedef typename pcl::PlaneRefinementComparator<PointT, PointNT, PointLT> PlaneRefinementComparator;
+#       typedef typename PlaneRefinementComparator::Ptr PlaneRefinementComparatorPtr;
+#       typedef typename PlaneRefinementComparator::ConstPtr PlaneRefinementComparatorConstPtr;
+# 
+#       /** \brief Constructor for OrganizedMultiPlaneSegmentation. */
+#       OrganizedMultiPlaneSegmentation () :
+#         normals_ (), 
+#         min_inliers_ (1000), 
+#         angular_threshold_ (pcl::deg2rad (3.0)), 
+#         distance_threshold_ (0.02),
+#         maximum_curvature_ (0.001),
+#         project_points_ (false), 
+#         compare_ (new PlaneComparator ()), refinement_compare_ (new PlaneRefinementComparator ())
+#       {
+#       }
+# 
+#       /** \brief Destructor for OrganizedMultiPlaneSegmentation. */
+#       virtual
+#       ~OrganizedMultiPlaneSegmentation ()
+#       {
+#       }
+# 
+#       /** \brief Provide a pointer to the input normals.
+#         * \param[in] normals the input normal cloud
+#         */
+#       inline void
+#       setInputNormals (const PointCloudNConstPtr &normals) 
+#       {
+#         normals_ = normals;
+#       }
+# 
+#       /** \brief Get the input normals. */
+#       inline PointCloudNConstPtr
+#       getInputNormals () const
+#       {
+#         return (normals_);
+#       }
+# 
+#       /** \brief Set the minimum number of inliers required for a plane
+#         * \param[in] min_inliers the minimum number of inliers required per plane
+#         */
+#       inline void
+#       setMinInliers (unsigned min_inliers)
+#       {
+#         min_inliers_ = min_inliers;
+#       }
+# 
+#       /** \brief Get the minimum number of inliers required per plane. */
+#       inline unsigned
+#       getMinInliers () const
+#       {
+#         return (min_inliers_);
+#       }
+# 
+#       /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+#         * \param[in] angular_threshold the tolerance in radians
+#         */
+#       inline void
+#       setAngularThreshold (double angular_threshold)
+#       {
+#         angular_threshold_ = angular_threshold;
+#       }
+# 
+#       /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+#       inline double
+#       getAngularThreshold () const
+#       {
+#         return (angular_threshold_);
+#       }
+# 
+#       /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+#         * \param[in] distance_threshold the tolerance in meters
+#         */
+#       inline void
+#       setDistanceThreshold (double distance_threshold)
+#       {
+#         distance_threshold_ = distance_threshold;
+#       }
+# 
+#       /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+#       inline double
+#       getDistanceThreshold () const
+#       {
+#         return (distance_threshold_);
+#       }
+# 
+#       /** \brief Set the maximum curvature allowed for a planar region.
+#         * \param[in] maximum_curvature the maximum curvature
+#         */
+#       inline void
+#       setMaximumCurvature (double maximum_curvature)
+#       {
+#         maximum_curvature_ = maximum_curvature;
+#       }
+# 
+#       /** \brief Get the maximum curvature allowed for a planar region. */
+#       inline double
+#       getMaximumCurvature () const
+#       {
+#         return (maximum_curvature_);
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for segmentation.
+#         * \param[in] compare A pointer to the comparator to be used for segmentation.
+#         */
+#       void
+#       setComparator (const PlaneComparatorPtr& compare)
+#       {
+#         compare_ = compare;
+#       }
+# 
+#       /** \brief Provide a pointer to the comparator to be used for refinement.
+#         * \param[in] compare A pointer to the comparator to be used for refinement.
+#         */
+#       void
+#       setRefinementComparator (const PlaneRefinementComparatorPtr& compare)
+#       {
+#         refinement_compare_ = compare;
+#       }
+# 
+#       /** \brief Set whether or not to project boundary points to the plane, or leave them in the original 3D space.
+#         * \param[in] project_points true if points should be projected, false if not.
+#         */
+#       void
+#       setProjectPoints (bool project_points)
+#       {
+#         project_points_ = project_points;
+#       }
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+#         * \param[out] inlier_indices a vector of inliers for each detected plane
+#         * \param[out] centroids a vector of centroids for each plane
+#         * \param[out] covariances a vector of covariance matricies for the inliers of each plane
+#         * \param[out] labels a point cloud for the connected component labels of each pixel
+#         * \param[out] label_indices a vector of PointIndices for each labeled component
+#         */
+#       void
+#       segment (std::vector<ModelCoefficients>& model_coefficients, 
+#                std::vector<PointIndices>& inlier_indices,
+#                std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+#                std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+#                pcl::PointCloud<PointLT>& labels, 
+#                std::vector<pcl::PointIndices>& label_indices);
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+#         * \param[out] inlier_indices a vector of inliers for each detected plane
+#         */
+#       void
+#       segment (std::vector<ModelCoefficients>& model_coefficients, 
+#                std::vector<PointIndices>& inlier_indices);
+# 
+#       /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+#         * \param[out] regions a list of resultant planar polygonal regions
+#         */
+#       void
+#       segment (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+#       
+#       /** \brief Perform a segmentation, as well as an additional refinement step.  This helps with including points whose normals may not match neighboring points well, but may match the planar model well.
+#         * \param[out] regions A list of regions generated by segmentation and refinement.
+#         */
+#       void
+#       segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+# 
+#       /** \brief Perform a segmentation, as well as additional refinement step.  Returns intermediate data structures for use in
+#         * subsequent processing.
+#         * \param[out] regions A vector of PlanarRegions generated by segmentation
+#         * \param[out] model_coefficients A vector of model coefficients for each segmented plane
+#         * \param[out] inlier_indices A vector of PointIndices, indicating the inliers to each segmented plane
+#         * \param[out] labels A PointCloud<PointLT> corresponding to the resulting segmentation.
+#         * \param[out] label_indices A vector of PointIndices for each label
+#         * \param[out] boundary_indices A vector of PointIndices corresponding to the outer boundary / contour of each label
+#         */
+#       void
+#       segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions,
+#                         std::vector<ModelCoefficients>& model_coefficients,
+#                         std::vector<PointIndices>& inlier_indices,
+#                         PointCloudLPtr& labels,
+#                         std::vector<pcl::PointIndices>& label_indices,
+#                         std::vector<pcl::PointIndices>& boundary_indices);
+#       
+#       /** \brief Perform a refinement of an initial segmentation, by comparing points to adjacent regions detected by the initial segmentation.
+#         * \param [in] model_coefficients The list of segmented model coefficients
+#         * \param [in] inlier_indices The list of segmented inlier indices, corresponding to each model
+#         * \param [in] centroids The list of centroids corresponding to each segmented plane
+#         * \param [in] covariances The list of covariances corresponding to each segemented plane
+#         * \param [in] labels The labels produced by the initial segmentation
+#         * \param [in] label_indices The list of indices corresponding to each label
+#         */
+#       void
+#       refine (std::vector<ModelCoefficients>& model_coefficients, 
+#               std::vector<PointIndices>& inlier_indices,
+#               std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+#               std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+#               PointCloudLPtr& labels,
+#               std::vector<pcl::PointIndices>& label_indices);
+
+
+###
+
+# planar_polygon_fusion.h
+# namespace pcl
+# /** \brief PlanarPolygonFusion takes a list of 2D planar polygons and
+#   * attempts to reduce them to a minimum set that best represents the scene,
+#   * based on various given comparators.
+#   */
+# template <typename PointT>
+# class PlanarPolygonFusion
+#     public:
+#       /** \brief Constructor */
+#       PlanarPolygonFusion () : regions_ () {}
+#      
+#       /** \brief Destructor */
+#       virtual ~PlanarPolygonFusion () {}
+# 
+#       /** \brief Reset the state (clean the list of planar models). */
+#       void 
+#       reset ()
+#       {
+#         regions_.clear ();
+#       }
+#       
+#       /** \brief Set the list of 2D planar polygons to refine.
+#         * \param[in] input the list of 2D planar polygons to refine
+#         */
+#       void
+#       addInputPolygons (const std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > > &input)
+#       {
+#         int start = static_cast<int> (regions_.size ());
+#         regions_.resize (regions_.size () + input.size ());
+#         for(size_t i = 0; i < input.size (); i++)
+#           regions_[start+i] = input[i];
+#       }
+
+
+###
+
+# planar_region.h
+# namespace pcl
+# /** \brief PlanarRegion represents a set of points that lie in a plane.  Inherits summary statistics about these points from Region3D, and  summary statistics of a 3D collection of points.
+#   * \author Alex Trevor
+#   */
+# template <typename PointT>
+# class PlanarRegion : public pcl::Region3D<PointT>, public pcl::PlanarPolygon<PointT>
+#     protected:
+#       using Region3D<PointT>::centroid_;
+#       using Region3D<PointT>::covariance_; 
+#       using Region3D<PointT>::count_;
+#       using PlanarPolygon<PointT>::contour_;
+#       using PlanarPolygon<PointT>::coefficients_;
+# 
+#     public:
+#       /** \brief Empty constructor for PlanarRegion. */
+#       PlanarRegion () : contour_labels_ ()
+#       {}
+# 
+#       /** \brief Constructor for Planar region from a Region3D and a PlanarPolygon. 
+#         * \param[in] region a Region3D for the input data
+#         * \param[in] polygon a PlanarPolygon for the input region
+#         */
+#       PlanarRegion (const pcl::Region3D<PointT>& region, const pcl::PlanarPolygon<PointT>& polygon) :
+#         contour_labels_ ()
+#       {
+#         centroid_ = region.centroid;
+#         covariance_ = region.covariance;
+#         count_ = region.count;
+#         contour_ = polygon.contour;
+#         coefficients_ = polygon.coefficients;
+#       }
+#       
+#       /** \brief Destructor. */
+#       virtual ~PlanarRegion () {}
+# 
+#       /** \brief Constructor for PlanarRegion.
+#         * \param[in] centroid the centroid of the region.
+#         * \param[in] covariance the covariance of the region.
+#         * \param[in] count the number of points in the region.
+#         * \param[in] contour the contour / boudnary for the region
+#         * \param[in] coefficients the model coefficients (a,b,c,d) for the plane
+#         */
+#       PlanarRegion (const Eigen::Vector3f& centroid, const Eigen::Matrix3f& covariance, unsigned count,
+#                     const typename pcl::PointCloud<PointT>::VectorType& contour,
+#                     const Eigen::Vector4f& coefficients) :
+#         contour_labels_ ()
+#       {
+#         centroid_ = centroid;
+#         covariance_ = covariance;
+#         count_ = count;
+#         contour_ = contour;
+#         coefficients_ = coefficients;
+#       }
+
+
+###
+
+# plane_refinement_comparator.h
+# namespace pcl
+# /** \brief PlaneRefinementComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   *
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class PlaneRefinementComparator: public PlaneCoefficientComparator<PointT, PointNT>
+#     public:
+#       typedef typename Comparator<PointT>::PointCloud PointCloud;
+#       typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+#       typedef typename pcl::PointCloud<PointLT> PointCloudL;
+#       typedef typename PointCloudL::Ptr PointCloudLPtr;
+#       typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+#       typedef boost::shared_ptr<PlaneRefinementComparator<PointT, PointNT, PointLT> > Ptr;
+#       typedef boost::shared_ptr<const PlaneRefinementComparator<PointT, PointNT, PointLT> > ConstPtr;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+# 
+#       /** \brief Empty constructor for PlaneCoefficientComparator. */
+#      PlaneRefinementComparator ()
+#         : models_ ()
+#         , labels_ ()
+#         , refine_labels_ ()
+#         , label_to_model_ ()
+#         , depth_dependent_ (false)
+#       
+#       /** \brief Empty constructor for PlaneCoefficientComparator. 
+#         * \param[in] models
+#         * \param[in] refine_labels
+#         */
+#       PlaneRefinementComparator (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models,
+#                                  boost::shared_ptr<std::vector<bool> >& refine_labels)
+#         : models_ (models)
+#         , labels_ ()
+#         , refine_labels_ (refine_labels)
+#         , label_to_model_ ()
+#         , depth_dependent_ (false)
+#       
+#       /** \brief Destructor for PlaneCoefficientComparator. */
+#       virtual
+#       ~PlaneRefinementComparator ()
+#       
+#       /** \brief Set the vector of model coefficients to which we will compare.
+#         * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+#         */
+#       void setModelCoefficients (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models)
+#       
+#       /** \brief Set the vector of model coefficients to which we will compare.
+#         * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+#         */
+#       void setModelCoefficients (std::vector<pcl::ModelCoefficients>& models)
+#       
+#       /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+#         * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+#         */
+#       void setRefineLabels (boost::shared_ptr<std::vector<bool> >& refine_labels)
+#       
+#       /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+#         * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+#         */
+#       void setRefineLabels (std::vector<bool>& refine_labels)
+#       
+#       /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+#         * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+#         */
+#       inline void setLabelToModel (boost::shared_ptr<std::vector<int> >& label_to_model)
+#       
+#       /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+#         * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+#         */
+#       inline void setLabelToModel (std::vector<int>& label_to_model)
+#       
+#       /** \brief Get the vector of model coefficients to which we will compare. */
+#       inline boost::shared_ptr<std::vector<pcl::ModelCoefficients> > getModelCoefficients () const
+#       
+#       /** \brief ...
+#         * \param[in] labels
+#         */
+#       inline void setLabels (PointCloudLPtr& labels)
+#       
+#       /** \brief Compare two neighboring points
+#         * \param[in] idx1 The index of the first point.
+#         * \param[in] idx2 The index of the second point.
+#         */
+#       virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# region_3d.h
+# namespace pcl
+# /** \brief Region3D represents summary statistics of a 3D collection of points.
+#   * \author Alex Trevor
+#   */
+# template <typename PointT>
+# class Region3D
+#     public:
+#       /** \brief Empty constructor for Region3D. */
+#       Region3D () : centroid_ (Eigen::Vector3f::Zero ()), covariance_ (Eigen::Matrix3f::Identity ()), count_ (0)
+#       {
+#       }
+#       
+#       /** \brief Constructor for Region3D. 
+#         * \param[in] centroid The centroid of the region.
+#         * \param[in] covariance The covariance of the region.
+#         * \param[in] count The number of points in the region.
+#         */
+#       Region3D (Eigen::Vector3f& centroid, Eigen::Matrix3f& covariance, unsigned count) 
+#         : centroid_ (centroid), covariance_ (covariance), count_ (count)
+#       {
+#       }
+#      
+#       /** \brief Destructor. */
+#       virtual ~Region3D () {}
+# 
+#       /** \brief Get the centroid of the region. */
+#       inline Eigen::Vector3f getCentroid () const
+#       
+#       /** \brief Get the covariance of the region. */
+#       inline Eigen::Matrix3f getCovariance () const
+#       
+#       /** \brief Get the number of points in the region. */
+#       unsigned getCount () const
+
+
+###
+
+# rgb_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#   * for use in planar segmentation.  Also takes into account RGB, so we can segmented different colored co-planar regions.
+#   * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#   * \author Alex Trevor
+#   */
+# template<typename PointT, typename PointNT>
+# class RGBPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+#     public:
+#       typedef typename Comparator<PointT>::PointCloud PointCloud;
+#       typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+#       
+#       typedef typename pcl::PointCloud<PointNT> PointCloudN;
+#       typedef typename PointCloudN::Ptr PointCloudNPtr;
+#       typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+#       
+#       typedef boost::shared_ptr<RGBPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+#       typedef boost::shared_ptr<const RGBPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+# 
+#       using pcl::Comparator<PointT>::input_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+#       using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+# 
+#       /** \brief Empty constructor for RGBPlaneCoefficientComparator. */
+#       RGBPlaneCoefficientComparator ()
+#         : color_threshold_ (50.0f)
+#       {
+#       }
+# 
+#       /** \brief Constructor for RGBPlaneCoefficientComparator.
+#         * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+#         */
+#       RGBPlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+#         : PlaneCoefficientComparator<PointT, PointNT> (plane_coeff_d), color_threshold_ (50.0f)
+#       {
+#       }
+#       
+#       /** \brief Destructor for RGBPlaneCoefficientComparator. */
+#       virtual
+#       ~RGBPlaneCoefficientComparator ()
+#       {
+#       }
+# 
+#       /** \brief Set the tolerance in color space between neighboring points, to be considered part of the same plane.
+#         * \param[in] color_threshold The distance in color space
+#         */
+#       inline void
+#       setColorThreshold (float color_threshold)
+#       {
+#         color_threshold_ = color_threshold * color_threshold;
+#       }
+# 
+#       /** \brief Get the color threshold between neighboring points, to be considered part of the same plane. */
+#       inline float
+#       getColorThreshold () const
+#       {
+#         return (color_threshold_);
+#       }
+# 
+#       /** \brief Compare two neighboring points, by using normal information, euclidean distance, and color information.
+#         * \param[in] idx1 The index of the first point.
+#         * \param[in] idx2 The index of the second point.
+#         */
+#       bool
+#       compare (int idx1, int idx2) const
+#       {
+#         float dx = input_->points[idx1].x - input_->points[idx2].x;
+#         float dy = input_->points[idx1].y - input_->points[idx2].y;
+#         float dz = input_->points[idx1].z - input_->points[idx2].z;
+#         float dist = sqrtf (dx*dx + dy*dy + dz*dz);
+#         int dr = input_->points[idx1].r - input_->points[idx2].r;
+#         int dg = input_->points[idx1].g - input_->points[idx2].g;
+#         int db = input_->points[idx1].b - input_->points[idx2].b;
+#         //Note: This is not the best metric for color comparisons, we should probably use HSV space.
+#         float color_dist = static_cast<float> (dr*dr + dg*dg + db*db);
+#         return ( (dist < distance_threshold_)
+#                  && (normals_->points[idx1].getNormalVector3fMap ().dot (normals_->points[idx2].getNormalVector3fMap () ) > angular_threshold_ )
+#                  && (color_dist < color_threshold_));
+#       }
+
+
+###
+
+# segment_differences.h
+# namespace pcl
+# /** \brief Obtain the difference between two aligned point clouds as another point cloud, given a distance threshold.
+#   * \param src the input point cloud source
+#   * \param tgt the input point cloud target we need to obtain the difference against
+#   * \param threshold the distance threshold (tolerance) for point correspondences. (e.g., check if f a point p1 from 
+#   * src has a correspondence > threshold than a point p2 from tgt)
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching built over \a tgt
+#   * \param output the resultant output point cloud difference
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> 
+# void getPointCloudDifference (
+#     const pcl::PointCloud<PointT> &src, const pcl::PointCloud<PointT> &tgt, 
+#     double threshold, const boost::shared_ptr<pcl::search::Search<PointT> > &tree,
+#     pcl::PointCloud<PointT> &output);
+
+# segment_differences.h
+# namespace pcl
+# /** \brief @b SegmentDifferences obtains the difference between two spatially
+#   * aligned point clouds and returns the difference between them for a maximum
+#   * given distance threshold.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class SegmentDifferences: public PCLBase<PointT>
+#     typedef PCLBase<PointT> BasePCLBase;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef typename pcl::search::Search<PointT> KdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+# 
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+# 
+#       /** \brief Empty constructor. */
+#       SegmentDifferences ()
+# 
+#       /** \brief Provide a pointer to the target dataset against which we
+#         * compare the input cloud given in setInputCloud
+#         * \param cloud the target PointCloud dataset
+#       inline void setTargetCloud (const PointCloudConstPtr &cloud)
+# 
+#       /** \brief Get a pointer to the input target point cloud dataset. */
+#       inline PointCloudConstPtr const getTargetCloud ()
+#       /** \brief Provide a pointer to the search object.
+#         * \param tree a pointer to the spatial search object.
+#       inline void setSearchMethod (const KdTreePtr &tree)
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr getSearchMethod ()
+#       /** \brief Set the maximum distance tolerance (squared) between corresponding
+#         * points in the two input datasets.
+#         * \param sqr_threshold the squared distance tolerance as a measure in L2 Euclidean space
+#       inline void setDistanceThreshold (double sqr_threshold)
+#       /** \brief Get the squared distance tolerance between corresponding points as a
+#         * measure in the L2 Euclidean space.
+#       inline double getDistanceThreshold ()
+# 
+#       /** \brief Segment differences between two input point clouds.
+#         * \param output the resultant difference between the two point clouds as a PointCloud
+#         */
+#       void segment (PointCloud &output);
+#       protected:
+#       // Members derived from the base class
+#       using BasePCLBase::input_;
+#       using BasePCLBase::indices_;
+#       using BasePCLBase::initCompute;
+#       using BasePCLBase::deinitCompute;
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+#       /** \brief The input target point cloud dataset. */
+#       PointCloudConstPtr target_;
+#       /** \brief The distance tolerance (squared) as a measure in the L2
+#         * Euclidean space between corresponding points. 
+#         */
+#       double distance_threshold_;
+#       /** \brief Class getName method. */
+#       virtual std::string getClassName () const { return ("SegmentDifferences"); }
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+###############################################################################
+# Activation
+###############################################################################
+
+
+### pcl 1.7.2 ###
+# approximate_progressive_morphological_filter.h
+# namespace pcl
+# /** \brief
+# * Implements the Progressive Morphological Filter for segmentation of ground points.
+# * Description can be found in the article
+# * "A Progressive Morphological Filter for Removing Nonground Measurements from
+# * Airborne LIDAR Data"
+# * by K. Zhang, S. Chen, D. Whitman, M. Shyu, J. Yan, and C. Zhang.
+# */
+# template <typename PointT>
+# class PCL_EXPORTS ApproximateProgressiveMorphologicalFilter : public pcl::PCLBase<PointT>
+        # public:
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # /** \brief Constructor that sets default values for member variables. */
+        # ApproximateProgressiveMorphologicalFilter ();
+        # 
+        # virtual ~ApproximateProgressiveMorphologicalFilter ();
+        # 
+        # /** \brief Get the maximum window size to be used in filtering ground returns. */
+        # inline int getMaxWindowSize () const { return (max_window_size_); }
+        # 
+        # /** \brief Set the maximum window size to be used in filtering ground returns. */
+        # inline void setMaxWindowSize (int max_window_size) { max_window_size_ = max_window_size; }
+        # 
+        # /** \brief Get the slope value to be used in computing the height threshold. */
+        # inline float getSlope () const { return (slope_); }
+        # 
+        # /** \brief Set the slope value to be used in computing the height threshold. */
+        # inline void setSlope (float slope) { slope_ = slope; }
+        # 
+        # /** \brief Get the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline float getMaxDistance () const { return (max_distance_); }
+        # 
+        # /** \brief Set the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline void setMaxDistance (float max_distance) { max_distance_ = max_distance; }
+        # 
+        # /** \brief Get the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline float getInitialDistance () const { return (initial_distance_); }
+        # 
+        # /** \brief Set the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline void setInitialDistance (float initial_distance) { initial_distance_ = initial_distance; }
+        # 
+        # /** \brief Get the cell size. */
+        # inline float getCellSize () const { return (cell_size_); }
+        # 
+        # /** \brief Set the cell size. */
+        # inline void setCellSize (float cell_size) { cell_size_ = cell_size; }
+        # 
+        # /** \brief Get the base to be used in computing progressive window sizes. */
+        # inline float getBase () const { return (base_); }
+        # 
+        # /** \brief Set the base to be used in computing progressive window sizes. */
+        # inline void setBase (float base) { base_ = base; }
+        # 
+        # /** \brief Get flag indicating whether or not to exponentially grow window sizes? */
+        # inline bool getExponential () const { return (exponential_); }
+        # 
+        # /** \brief Set flag indicating whether or not to exponentially grow window sizes? */
+        # inline void setExponential (bool exponential) { exponential_ = exponential; }
+        # 
+        # /** \brief Initialize the scheduler and set the number of threads to use.
+        # * \param nr_threads the number of hardware threads to use (0 sets the value back to automatic)
+        # */
+        # inline void setNumberOfThreads (unsigned int nr_threads = 0) { threads_ = nr_threads; }
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns indices of
+        # * points determined to be ground returns.
+        # * \param[out] ground indices of points determined to be ground returns.
+        # */
+        # virtual void extract (std::vector<int>& ground);
+
+
+###
+
+# boost.h
+###
+
+# conditional_euclidean_clustering.h
+# namespace pcl
+# typedef std::vector<pcl::PointIndices> IndicesClusters;
+# typedef boost::shared_ptr<std::vector<pcl::PointIndices> > IndicesClustersPtr;
+# 
+# /** \brief @b ConditionalEuclideanClustering performs segmentation based on Euclidean distance and a user-defined clustering condition.
+#   * \details The condition that need to hold is currently passed using a function pointer.
+#   * For more information check the documentation of setConditionFunction() or the usage example below:
+#   * \code
+#   * bool
+#   * enforceIntensitySimilarity (const pcl::PointXYZI& point_a, const pcl::PointXYZI& point_b, float squared_distance)
+#   * {
+#   *   if (fabs (point_a.intensity - point_b.intensity) < 0.1f)
+#   *     return (true);
+#   *   else
+#   *     return (false);
+#   * }
+#   * // ...
+#   * // Somewhere down to the main code
+#   * // ...
+#   * pcl::ConditionalEuclideanClustering<pcl::PointXYZI> cec (true);
+#   * cec.setInputCloud (cloud_in);
+#   * cec.setConditionFunction (&enforceIntensitySimilarity);
+#   * // Points within this distance from one another are going to need to validate the enforceIntensitySimilarity function to be part of the same cluster:
+#   * cec.setClusterTolerance (0.09f);
+#   * // Size constraints for the clusters:
+#   * cec.setMinClusterSize (5);
+#   * cec.setMaxClusterSize (30);
+#   * // The resulting clusters (an array of pointindices):
+#   * cec.segment (*clusters);
+#   * // The clusters that are too small or too large in size can also be extracted separately:
+#   * cec.getRemovedClusters (small_clusters, large_clusters);
+#   * \endcode
+#   * \author Frits Florentinus
+#   * \ingroup segmentation
+#   */
+# template<typename PointT>
+# class ConditionalEuclideanClustering : public PCLBase<PointT>
+        # protected:
+        # typedef typename pcl::search::Search<PointT>::Ptr SearcherPtr;
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # 
+        # public:
+        # /** \brief Constructor.
+        # * \param[in] extract_removed_clusters Set to true if you want to be able to extract the clusters that are too large or too small (default = false)
+        # */
+        # ConditionalEuclideanClustering (bool extract_removed_clusters = false) :
+        #   searcher_ (),
+        #   condition_function_ (),
+        #   cluster_tolerance_ (0.0f),
+        #   min_cluster_size_ (1),
+        #   max_cluster_size_ (std::numeric_limits<int>::max ()),
+        #   extract_removed_clusters_ (extract_removed_clusters),
+        #   small_clusters_ (new pcl::IndicesClusters),
+        #   large_clusters_ (new pcl::IndicesClusters)
+		# 
+        # 
+        # /** \brief Set the condition that needs to hold for neighboring points to be considered part of the same cluster.
+        # * \details Any two points within a certain distance from one another will need to evaluate this condition in order to be made part of the same cluster.
+        # * The distance can be set using setClusterTolerance().
+        # * <br>
+        # * Note that for a point to be part of a cluster, the condition only needs to hold for at least 1 point pair.
+        # * To clarify, the following statement is false:
+        # * Any two points within a cluster always evaluate this condition function to true.
+        # * <br><br>
+        # * The input arguments of the condition function are:
+        # * <ul>
+        # *  <li>PointT The first point of the point pair</li>
+        # *  <li>PointT The second point of the point pair</li>
+        # *  <li>float The squared distance between the points</li>
+        # * </ul>
+        # * The output argument is a boolean, returning true will merge the second point into the cluster of the first point.
+        # * \param[in] condition_function The condition function that needs to hold for clustering
+        # */
+        # inline void setConditionFunction (bool (*condition_function) (const PointT&, const PointT&, float)) 
+        # 
+        # /** \brief Set the spatial tolerance for new cluster candidates.
+        # * \details Any two points within this distance from one another will need to evaluate a certain condition in order to be made part of the same cluster.
+        # * The condition can be set using setConditionFunction().
+        # * \param[in] cluster_tolerance The distance to scan for cluster candidates (default = 0.0)
+        # */
+        # inline void setClusterTolerance (float cluster_tolerance)
+        # 
+        # /** \brief Get the spatial tolerance for new cluster candidates.*/
+        # inline float getClusterTolerance ()
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid.
+        # * \param[in] min_cluster_size The minimum cluster size (default = 1)
+        # */
+        # inline void setMinClusterSize (int min_cluster_size)
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid.*/
+        # inline int getMinClusterSize ()
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid.
+        # * \param[in] max_cluster_size The maximum cluster size (default = unlimited)
+        # */
+        # inline void setMaxClusterSize (int max_cluster_size)
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid.*/
+        # inline int getMaxClusterSize ()
+        # 
+        # /** \brief Segment the input into separate clusters.
+        # * \details The input can be set using setInputCloud() and setIndices().
+        # * <br>
+        # * The size constraints for the resulting clusters can be set using setMinClusterSize() and setMaxClusterSize().
+        # * <br>
+        # * The region growing parameters can be set using setConditionFunction() and setClusterTolerance().
+        # * <br>
+        # * \param[out] clusters The resultant set of indices, indexing the points of the input cloud that correspond to the clusters
+        # */
+        # void segment (IndicesClusters &clusters);
+        # 
+        # /** \brief Get the clusters that are invalidated due to size constraints.
+        # * \note The constructor of this class needs to be initialized with true, and the segment method needs to have been called prior to using this method.
+        # * \param[out] small_clusters The resultant clusters that contain less than min_cluster_size points
+        # * \param[out] large_clusters The resultant clusters that contain more than max_cluster_size points
+        # */
+        # inline void getRemovedClusters (IndicesClustersPtr &small_clusters, IndicesClustersPtr &large_clusters)
+
+
+###
+
+# crf_normal_segmentation.h
+# namespace pcl
+# /** \brief
+# * \author Christian Potthast
+# * 
+# */
+# template <typename PointT>
+# class PCL_EXPORTS CrfNormalSegmentation
+        # public:
+        # 
+        # /** \brief Constructor that sets default values for member variables. */
+        # CrfNormalSegmentation ();
+        # 
+        # /** \brief Destructor that frees memory. */
+        # ~CrfNormalSegmentation ();
+        # 
+        # /** \brief This method sets the input cloud.
+        # * \param[in] input_cloud input point cloud
+        # */
+        # void setCloud (typename pcl::PointCloud<PointT>::Ptr input_cloud);
+        # 
+        # /** \brief This method simply launches the segmentation algorithm */
+        # void segmentPoints ();
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+# /** boost implementation of Boykov and Kolmogorov's maxflow algorithm doesn't support
+# * negative flows which makes it inappropriate for this conext.
+# * This implementation of Boykov and Kolmogorov's maxflow algorithm by Stephen Gould
+# * <stephen.gould@anu.edu.au> in DARWIN under BSD does the trick however solwer than original
+# * implementation.
+# */
+# class PCL_EXPORTS BoykovKolmogorov
+        # public:
+        # typedef int vertex_descriptor;
+        # typedef double edge_capacity_type;
+        # 
+        # /// construct a maxflow/mincut problem with estimated max_nodes
+        # BoykovKolmogorov (std::size_t max_nodes = 0);
+        # 
+        # /// destructor
+        # virtual ~BoykovKolmogorov () {}
+        # 
+        # /// get number of nodes in the graph
+        # size_t numNodes () const { return nodes_.size (); }
+        # 
+        # /// reset all edge capacities to zero (but don't free the graph)
+        # void reset ();
+        # 
+        # /// clear the graph and internal datastructures
+        # void clear ();
+        # 
+        # /// add nodes to the graph (returns the id of the first node added)
+        # int addNodes (std::size_t n = 1);
+        # 
+        # /// add constant flow to graph
+        # void addConstant (double c) { flow_value_ += c; }
+        # 
+        # /// add edge from s to nodeId
+        # void addSourceEdge (int u, double cap);
+        # 
+        # /// add edge from nodeId to t
+        # void addTargetEdge (int u, double cap);
+        # 
+        # /// add edge from u to v and edge from v to u
+        # /// (requires cap_uv + cap_vu >= 0)
+        # void addEdge (int u, int v, double cap_uv, double cap_vu = 0.0);
+        # 
+        # /// solve the max-flow problem and return the flow
+        # double solve ();
+        # 
+        # /// return true if \p u is in the s-set after calling \ref solve.
+        # bool inSourceTree (int u) const { return (cut_[u] == SOURCE); }
+        # 
+        # /// return true if \p u is in the t-set after calling \ref solve
+        # bool inSinkTree (int u) const { return (cut_[u] == TARGET); }
+        # 
+        # /// returns the residual capacity for an edge (use -1 for terminal (-1,-1) is the current flow
+        # double operator() (int u, int v) const;
+        # 
+        # double getSourceEdgeCapacity (int u) const;
+        # 
+        # double getTargetEdgeCapacity (int u) const;
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+      	# /**\brief Structure to save RGB colors into floats */
+      	# struct Color
+      	# {
+      	#   Color () : r (0), g (0), b (0) {}
+      	#   Color (float _r, float _g, float _b) : r(_r), g(_g), b(_b) {}
+      	#   Color (const pcl::RGB& color) : r (color.r), g (color.g), b (color.b) {}
+		# 
+        # template<typename PointT> Color (const PointT& p);
+		# 
+        # template<typename PointT> operator PointT () const;
+		# 
+        # float r, g, b;
+      	# };
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+        # /// An Image is a point cloud of Color
+        # typedef pcl::PointCloud<Color> Image;
+        # 
+        # /** \brief Compute squared distance between two colors
+        # * \param[in] c1 first color
+        # * \param[in] c2 second color
+        # * \return the squared distance measure in RGB space
+        # */
+        # float colorDistance (const Color& c1, const Color& c2);
+        # 
+        # /// User supplied Trimap values
+        # enum TrimapValue { TrimapUnknown = -1, TrimapForeground, TrimapBackground };
+        # 
+        # /// Grabcut derived hard segementation values
+        # enum SegmentationValue { SegmentationForeground = 0, SegmentationBackground };
+        # 
+        # /// Gaussian structure
+        # struct Gaussian
+        # {
+        #     Gaussian () {}
+        #     /// mean of the gaussian
+        #     Color mu;
+        #     /// covariance matrix of the gaussian
+        #     Eigen::Matrix3f covariance;
+        #     /// determinant of the covariance matrix
+        #     float determinant;
+        #     /// inverse of the covariance matrix
+        #     Eigen::Matrix3f inverse;
+        #     /// weighting of this gaussian in the GMM.
+        #     float pi;
+        #     /// heighest eigenvalue of covariance matrix
+        #     float eigenvalue;
+        #     /// eigenvector corresponding to the heighest eigenvector
+        #     Eigen::Vector3f eigenvector;
+        # };
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+# class PCL_EXPORTS GMM
+        # public:
+        #   /// Initialize GMM with ddesired number of gaussians.
+        #   GMM () : gaussians_ (0) {}
+        #   /// Initialize GMM with ddesired number of gaussians.
+        #   GMM (std::size_t K) : gaussians_ (K) {}
+        #   /// Destructor
+        #   ~GMM () {}
+        # 
+        # /// \return K
+        # std::size_t getK () const { return gaussians_.size (); }
+        # 
+        #   /// resize gaussians
+        #   void resize (std::size_t K) { gaussians_.resize (K); }
+        #   
+        #   /// \return a reference to the gaussian at a given position
+        #   Gaussian& operator[] (std::size_t pos) { return (gaussians_[pos]); }
+        # 
+        #   /// \return a const reference to the gaussian at a given position
+        #   const Gaussian& operator[] (std::size_t pos) const { return (gaussians_[pos]); }
+        # 
+        #   /// \brief \return the computed probability density of a color in this GMM
+        #   float probabilityDensity (const Color &c);
+        # 
+        #   /// \brief \return the computed probability density of a color in just one Gaussian
+        #   float probabilityDensity(std::size_t i, const Color &c);
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+# /** Helper class that fits a single Gaussian to color samples */
+# class GaussianFitter
+        # public:
+        # GaussianFitter (float epsilon = 0.0001)
+        #   : sum_ (Eigen::Vector3f::Zero ())
+        #   , accumulator_ (Eigen::Matrix3f::Zero ())
+        #   , count_ (0)
+        #   , epsilon_ (epsilon)
+        # { }
+		# 
+        # /// Add a color sample
+        # void add (const Color &c);
+        # 
+        # /// Build the gaussian out of all the added color samples
+        # void fit (Gaussian& g, std::size_t total_count, bool compute_eigens = false) const;
+        # 
+        # /// \return epsilon
+        # float getEpsilon () { return (epsilon_); }
+        # 
+        # /** set epsilon which will be added to the covariance matrix diagonal which avoids singular
+        #   * covariance matrix
+        #   * \param[in] epsilon user defined epsilon
+        #   */
+        # void setEpsilon (float epsilon) { epsilon_ = epsilon; }
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+      	# /** Build the initial GMMs using the Orchard and Bouman color clustering algorithm */
+      	# PCL_EXPORTS void buildGMMs (const Image &image,
+        #          const std::vector<int>& indices,
+        #          const std::vector<SegmentationValue> &hardSegmentation,
+        #          std::vector<std::size_t> &components,
+        #          GMM &background_GMM, GMM &foreground_GMM);
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# namespace grabcut
+		# /** Iteratively learn GMMs using GrabCut updating algorithm */
+      	# PCL_EXPORTS void learnGMMs (const Image& image,
+        #          				const std::vector<int>& indices,
+        #          				const std::vector<SegmentationValue>& hard_segmentation,
+        #          				std::vector<std::size_t>& components,
+        #          				GMM& background_GMM, GMM& foreground_GMM);
+
+
+###
+
+# grabcut_segmentation.h
+# namespace pcl
+# namespace segmentation
+# /** \brief Implementation of the GrabCut segmentation in
+# * "GrabCut — Interactive Foreground Extraction using Iterated Graph Cuts" by
+# * Carsten Rother, Vladimir Kolmogorov and Andrew Blake.
+# * \author Justin Talbot, jtalbot@stanford.edu placed in Public Domain, 2010
+# * \author Nizar Sallem port to PCL and adaptation of original code.
+# * \ingroup segmentation
+# */
+# template <typename PointT>
+# class GrabCut : public pcl::PCLBase<PointT>
+        # public:
+        # typedef typename pcl::search::Search<PointT> KdTree;
+        # typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+        # typedef typename PCLBase<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename PCLBase<PointT>::PointCloudPtr PointCloudPtr;
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::fake_indices_;
+        # 
+        # /// Constructor
+        # GrabCut (uint32_t K = 5, float lambda = 50.f)
+        # : K_ (K)
+        # , lambda_ (lambda)
+        # , nb_neighbours_ (9)
+        # , initialized_ (false)
+        # {}
+        # 
+        # /// Desctructor
+        # virtual ~GrabCut () {};
+        # 
+        # // /// Set input cloud
+        # void setInputCloud (const PointCloudConstPtr& cloud);
+        # 
+        # /// Set background points, foreground points = points \ background points
+        # void setBackgroundPoints (const PointCloudConstPtr& background_points);
+        # 
+        # /// Set background indices, foreground indices = indices \ background indices
+        # void setBackgroundPointsIndices (int x1, int y1, int x2, int y2);
+        # 
+        # /// Set background indices, foreground indices = indices \ background indices
+        # void setBackgroundPointsIndices (const PointIndicesConstPtr& indices);
+        # 
+        # /// Run Grabcut refinement on the hard segmentation
+        # virtual void refine ();
+        # 
+        # /// \return the number of pixels that have changed from foreground to background or vice versa
+        # virtual int refineOnce ();
+        # 
+        # /// \return lambda
+        # float getLambda () { return (lambda_); }
+        # 
+        # /** Set lambda parameter to user given value. Suggested value by the authors is 50
+        # * \param[in] lambda
+        # */
+        # void setLambda (float lambda) { lambda_ = lambda; }
+        # 
+        # /// \return the number of components in the GMM
+        # uint32_t getK () { return (K_); }
+        # 
+        # /** Set K parameter to user given value. Suggested value by the authors is 5
+        # * \param[in] K the number of components used in GMM
+        # */
+        # void setK (uint32_t K) { K_ = K; }
+        # 
+        # /** \brief Provide a pointer to the search object.
+        # * \param tree a pointer to the spatial search object.
+        # */
+        # inline void setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+        # 
+        # /** \brief Get a pointer to the search method used. */
+        # inline KdTreePtr getSearchMethod () { return (tree_); }
+        # 
+        # /** \brief Allows to set the number of neighbours to find.
+        # * \param[in] nb_neighbours new number of neighbours
+        # */
+        # void setNumberOfNeighbours (int nb_neighbours) { nb_neighbours_ = nb_neighbours; }
+        # 
+        # /** \brief Returns the number of neighbours to find. */
+        # int getNumberOfNeighbours () const { return (nb_neighbours_); }
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        # * obtained during the segmentation. The indices of points belonging to the object will be stored
+        # * in the cluster with index 1, other indices will be stored in the cluster with index 0.
+        # * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        # */
+        # void extract (std::vector<pcl::PointIndices>& clusters);
+
+
+###
+
+# ground_plane_comparator.h
+# namespace pcl
+# /** \brief GroundPlaneComparator is a Comparator for detecting smooth surfaces suitable for driving.
+# * In conjunction with OrganizedConnectedComponentSegmentation, this allows smooth groundplanes / road surfaces to be segmented from point clouds.
+# * \author Alex Trevor
+# */
+# template<typename PointT, typename PointNT>
+# class GroundPlaneComparator: public Comparator<PointT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<GroundPlaneComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const GroundPlaneComparator<PointT, PointNT> > ConstPtr;
+        # 
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # /** \brief Empty constructor for GroundPlaneComparator. */
+        # GroundPlaneComparator ()
+        # : normals_ ()
+        # , plane_coeff_d_ ()
+        # , angular_threshold_ (cosf (pcl::deg2rad (2.0f)))
+        # , road_angular_threshold_ ( cosf(pcl::deg2rad (10.0f)))
+        # , distance_threshold_ (0.1f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0, 0.0, 1.0) )
+        # , desired_road_axis_ (Eigen::Vector3f(0.0, -1.0, 0.0))
+        # 
+        # /** \brief Constructor for GroundPlaneComparator.
+        # * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+        # */
+        # GroundPlaneComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+        # : normals_ ()
+        # , plane_coeff_d_ (plane_coeff_d)
+        # , angular_threshold_ (cosf (pcl::deg2rad (3.0f)))
+        # , distance_threshold_ (0.1f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0f, 0.0f, 1.0f))
+        # , road_angular_threshold_ ( cosf(pcl::deg2rad (40.0f)))
+        # , desired_road_axis_ (Eigen::Vector3f(0.0, -1.0, 0.0))
+        # 
+        # /** \brief Destructor for GroundPlaneComparator. */
+        # virtual ~GroundPlaneComparator ()
+        # 
+        # /** \brief Provide the input cloud.
+        # * \param[in] cloud the input point cloud.
+        # */
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # 
+        # /** \brief Provide a pointer to the input normals.
+        # * \param[in] normals the input normal cloud.
+        # */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # 
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        # * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # */
+        # void setPlaneCoeffD (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        # * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        # */
+        # void setPlaneCoeffD (std::vector<float>& plane_coeff_d)
+        # 
+        # /** \brief Get a pointer to the vector of the d-coefficient of the planes' hessian normal form. */
+        # const std::vector<float>& getPlaneCoeffD () const
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        # * \param[in] angular_threshold the tolerance in radians
+        # */
+        # virtual void setAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between a point and the expected ground normal.
+        # * \param[in] angular_threshold the
+        # */
+        # virtual void setGroundAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Set the expected ground plane normal with respect to the sensor.  Pixels labeled as ground must be within ground_angular_threshold radians of this normal to be labeled as ground.
+        # * \param[in] normal The normal direction of the expected ground plane.
+        # */
+        # void setExpectedGroundNormal (Eigen::Vector3f normal)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        # 
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        # * \param[in] distance_threshold the tolerance in meters (at 1m)
+        # * \param[in] depth_dependent whether to scale the threshold based on range from the sensor (default: false)
+        # */
+        # void setDistanceThreshold (float distance_threshold, bool depth_dependent = false)
+        # 
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        # 
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        # * and the difference between the d component of the normals is less than distance threshold, else false
+        # * \param idx1 The first index for the comparison
+        # * \param idx2 The second index for the comparison
+        # */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# min_cut_segmentation.h
+# namespace pcl
+# template <typename PointT>
+# class PCL_EXPORTS MinCutSegmentation : public pcl::PCLBase<PointT>
+cdef extern from "pcl/segmentation/min_cut_segmentation.h" namespace "pcl":
+    cdef cppclass MinCutSegmentation[T](PCLBase[T]):
+        MinCutSegmentation()
+        # public:
+        # typedef pcl::search::Search <PointT> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::PointCloud< PointT > PointCloud;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # typedef boost::adjacency_list_traits< boost::vecS, boost::vecS, boost::directedS > Traits;
+        # typedef boost::adjacency_list< boost::vecS, boost::vecS, boost::directedS,
+        #                              boost::property< boost::vertex_name_t, std::string,
+        #                                boost::property< boost::vertex_index_t, long,
+        #                                  boost::property< boost::vertex_color_t, boost::default_color_type,
+        #                                    boost::property< boost::vertex_distance_t, long,
+        #                                      boost::property< boost::vertex_predecessor_t, Traits::edge_descriptor > > > > >,
+        #                              boost::property< boost::edge_capacity_t, double,
+        #                                boost::property< boost::edge_residual_capacity_t, double,
+        #                                  boost::property< boost::edge_reverse_t, Traits::edge_descriptor > > > > mGraph;
+        # typedef boost::property_map< mGraph, boost::edge_capacity_t >::type CapacityMap;
+        # typedef boost::property_map< mGraph, boost::edge_reverse_t>::type ReverseEdgeMap;
+        # typedef Traits::vertex_descriptor VertexDescriptor;
+        # typedef boost::graph_traits< mGraph >::edge_descriptor EdgeDescriptor;
+        # typedef boost::graph_traits< mGraph >::out_edge_iterator OutEdgeIterator;
+        # typedef boost::graph_traits< mGraph >::vertex_iterator VertexIterator;
+        # typedef boost::property_map< mGraph, boost::edge_residual_capacity_t >::type ResidualCapacityMap;
+        # typedef boost::property_map< mGraph, boost::vertex_index_t >::type IndexMap;
+        # typedef boost::graph_traits< mGraph >::in_edge_iterator InEdgeIterator;
+        # public:
+        # /** \brief This method simply sets the input point cloud.
+        #   * \param[in] cloud the const boost shared pointer to a PointCloud
+        # virtual void setInputCloud (const PointCloudConstPtr &cloud);
+        # /** \brief Returns normalization value for binary potentials. For more information see the article. */
+        double getSigma ()
+        # /** \brief Allows to set the normalization value for the binary potentials as described in the article.
+        #   * \param[in] sigma new normalization value
+        void setSigma (double sigma)
+        # /** \brief Returns radius to the background. */
+        double getRadius ()
+        # /** \brief Allows to set the radius to the background.
+        #   * \param[in] radius new radius to the background
+        void setRadius (double radius)
+        # /** \brief Returns weight that every edge from the source point has. */
+        double getSourceWeight ()
+        # /** \brief Allows to set weight for source edges. Every edge that comes from the source point will have that weight.
+        #   * \param[in] weight new weight
+        void setSourceWeight (double weight)
+        # /** \brief Returns search method that is used for finding KNN.
+        #   * The graph is build such way that it contains the edges that connect point and its KNN.
+        # KdTreePtr getSearchMethod () const;
+        # /** \brief Allows to set search method for finding KNN.
+        #   * The graph is build such way that it contains the edges that connect point and its KNN.
+        #   * \param[in] search search method that will be used for finding KNN.
+        # void setSearchMethod (const KdTreePtr& tree);
+        # /** \brief Returns the number of neighbours to find. */
+        unsigned int getNumberOfNeighbours ()
+        # /** \brief Allows to set the number of neighbours to find.
+        #   * \param[in] number_of_neighbours new number of neighbours
+        void setNumberOfNeighbours (unsigned int neighbour_number)
+        # /** \brief Returns the points that must belong to foreground. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > getForegroundPoints () const;
+        # /** \brief Allows to specify points which are known to be the points of the object.
+        #   * \param[in] foreground_points point cloud that contains foreground points. At least one point must be specified.
+        # void setForegroundPoints (typename pcl::PointCloud<PointT>::Ptr foreground_points);
+        # /** \brief Returns the points that must belong to background. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > getBackgroundPoints () const;
+        # /** \brief Allows to specify points which are known to be the points of the background.
+        #   * \param[in] background_points point cloud that contains background points.
+        # void setBackgroundPoints (typename pcl::PointCloud<PointT>::Ptr background_points);
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        #   * obtained during the segmentation. The indices of points that belong to the object will be stored
+        #   * in the cluster with index 1, other indices will be stored in the cluster with index 0.
+        #   * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        # void extract (vector <pcl::PointIndices>& clusters);
+        # /** \brief Returns that flow value that was calculated during the segmentation. */
+        double getMaxFlow ()
+        # /** \brief Returns the graph that was build for finding the minimum cut. */
+        # typename boost::shared_ptr<typename pcl::MinCutSegmentation<PointT>::mGraph> getGraph () const;
+        # /** \brief Returns the colored cloud. Points that belong to the object have the same color. */
+        # pcl::PointCloud<pcl::PointXYZRGB>::Ptr getColoredCloud ();
+        # protected:
+        # /** \brief This method simply builds the graph that will be used during the segmentation. */
+        bool buildGraph ()
+        # /** \brief Returns unary potential(data cost) for the given point index.
+        #   * In other words it calculates weights for (source, point) and (point, sink) edges.
+        #   * \param[in] point index of the point for which weights will be calculated
+        #   * \param[out] source_weight calculated weight for the (source, point) edge
+        #   * \param[out] sink_weight calculated weight for the (point, sink) edge
+        void calculateUnaryPotential (int point, double& source_weight, double& sink_weight)
+        # /** \brief This method simply adds the edge from the source point to the target point with a given weight.
+        #   * \param[in] source index of the source point of the edge
+        #   * \param[in] target index of the target point of the edge
+        #   * \param[in] weight weight that will be assigned to the (source, target) edge
+        bool addEdge (int source, int target, double weight)
+        # /** \brief Returns the binary potential(smooth cost) for the given indices of points.
+        #   * In other words it returns weight that must be assigned to the edge from source to target point.
+        #   * \param[in] source index of the source point of the edge
+        #   * \param[in] target index of the target point of the edge
+        double calculateBinaryPotential (int source, int target)
+        # brief This method recalculates unary potentials(data cost) if some changes were made, instead of creating new graph. */
+        bool recalculateUnaryPotentials ()
+        # brief This method recalculates binary potentials(smooth cost) if some changes were made, instead of creating new graph. */
+        bool recalculateBinaryPotentials ()
+        # /** \brief This method analyzes the residual network and assigns a label to every point in the cloud.
+        #   * \param[in] residual_capacity residual network that was obtained during the segmentation
+        # void assembleLabels (ResidualCapacityMap& residual_capacity);
+        # protected:
+        # /** \brief Stores the sigma coefficient. It is used for finding smooth costs. More information can be found in the article. */
+        # double inverse_sigma_;
+        # /** \brief Signalizes if the binary potentials are valid. */
+        # bool binary_potentials_are_valid_;
+        # /** \brief Used for comparison of the floating point numbers. */
+        # double epsilon_;
+        # /** \brief Stores the distance to the background. */
+        # double radius_;
+        # /** \brief Signalizes if the unary potentials are valid. */
+        # bool unary_potentials_are_valid_;
+        # /** \brief Stores the weight for every edge that comes from source point. */
+        # double source_weight_;
+        # /** \brief Stores the search method that will be used for finding K nearest neighbors. Neighbours are used for building the graph. */
+        # KdTreePtr search_;
+        # /** \brief Stores the number of neighbors to find. */
+        # unsigned int number_of_neighbours_;
+        # /** \brief Signalizes if the graph is valid. */
+        # bool graph_is_valid_;
+        # /** \brief Stores the points that are known to be in the foreground. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > foreground_points_;
+        # /** \brief Stores the points that are known to be in the background. */
+        # std::vector<PointT, Eigen::aligned_allocator<PointT> > background_points_;
+        # /** \brief After the segmentation it will contain the segments. */
+        # std::vector <pcl::PointIndices> clusters_;
+        # /** \brief Stores the graph for finding the maximum flow. */
+        # boost::shared_ptr<mGraph> graph_;
+        # /** \brief Stores the capacity of every edge in the graph. */
+        # boost::shared_ptr<CapacityMap> capacity_;
+        # /** \brief Stores reverse edges for every edge in the graph. */
+        # boost::shared_ptr<ReverseEdgeMap> reverse_edges_;
+        # /** \brief Stores the vertices of the graph. */
+        # std::vector< VertexDescriptor > vertices_;
+        # /** \brief Stores the information about the edges that were added to the graph. It is used to avoid the duplicate edges. */
+        # std::vector< std::set<int> > edge_marker_;
+        # /** \brief Stores the vertex that serves as source. */
+        # VertexDescriptor source_;
+        # /** \brief Stores the vertex that serves as sink. */
+        # VertexDescriptor sink_;
+        # /** \brief Stores the maximum flow value that was calculated during the segmentation. */
+        # double max_flow_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+
+
+# organized_connected_component_segmentation.h
+# namespace pcl
+# /** \brief OrganizedConnectedComponentSegmentation allows connected
+#   * components to be found within organized point cloud data, given a
+#   * comparison function.  Given an input cloud and a comparator, it will
+#   * output a PointCloud of labels, giving each connected component a unique
+#   * id, along with a vector of PointIndices corresponding to each component.
+#   * See OrganizedMultiPlaneSegmentation for an example application.
+#   * \author Alex Trevor, Suat Gedikli
+#   */
+# template <typename PointT, typename PointLT>
+# class OrganizedConnectedComponentSegmentation : public PCLBase<PointT>
+# {
+cdef extern from "pcl/segmentation/organized_connected_component_segmentation.h" namespace "pcl":
+    cdef cppclass OrganizedConnectedComponentSegmentation[T, LT](PCLBase[T]):
+        OrganizedConnectedComponentSegmentation()
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # 
+        # public:
+        # typedef typename pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # 
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # typedef typename pcl::Comparator<PointT> Comparator;
+        # typedef typename Comparator::Ptr ComparatorPtr;
+        # typedef typename Comparator::ConstPtr ComparatorConstPtr;
+        # 
+        # /** \brief Constructor for OrganizedConnectedComponentSegmentation
+        #  * \param[in] compare A pointer to the comparator to be used for segmentation.  Must be an instance of pcl::Comparator.
+        # */
+        # OrganizedConnectedComponentSegmentation (const ComparatorConstPtr& compare) : compare_ (compare)
+        # /** \brief Destructor for OrganizedConnectedComponentSegmentation. */
+        # virtual ~OrganizedConnectedComponentSegmentation ()
+        # 
+        # /** \brief Provide a pointer to the comparator to be used for segmentation.
+        #  * \param[in] compare the comparator
+        # */
+        # void setComparator (const ComparatorConstPtr& compare)
+        # 
+        # /** \brief Get the comparator.*/
+        # ComparatorConstPtr getComparator () const { return (compare_); }
+        # 
+        # /** \brief Perform the connected component segmentation.
+        #  * \param[out] labels a PointCloud of labels: each connected component will have a unique id.
+        #  * \param[out] label_indices a vector of PointIndices corresponding to each label / component id.
+        # */
+        # void segment (pcl::PointCloud<PointLT>& labels, std::vector<pcl::PointIndices>& label_indices) const;
+        # 
+        # /** \brief Find the boundary points / contour of a connected component
+        #  * \param[in] start_idx the first (lowest) index of the connected component for which a boundary shoudl be returned
+        #  * \param[in] labels the Label cloud produced by segmentation
+        #  * \param[out] boundary_indices the indices of the boundary points for the label corresponding to start_idx
+        # */
+        # static void findLabeledRegionBoundary (int start_idx, PointCloudLPtr labels, pcl::PointIndices& boundary_indices);      
+
+
+###
+
+# organized_multi_plane_segmentation.h
+# namespace pcl
+# {
+# /** \brief OrganizedMultiPlaneSegmentation finds all planes present in the
+# * input cloud, and outputs a vector of plane equations, as well as a vector
+# * of point clouds corresponding to the inliers of each detected plane.  Only
+# * planes with more than min_inliers points are detected.
+# * Templated on point type, normal type, and label type
+# *
+# * \author Alex Trevor, Suat Gedikli
+# */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class OrganizedMultiPlaneSegmentation : public PCLBase<PointT>
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # 
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # typedef typename pcl::PlaneCoefficientComparator<PointT, PointNT> PlaneComparator;
+        # typedef typename PlaneComparator::Ptr PlaneComparatorPtr;
+        # typedef typename PlaneComparator::ConstPtr PlaneComparatorConstPtr;
+        # typedef typename pcl::PlaneRefinementComparator<PointT, PointNT, PointLT> PlaneRefinementComparator;
+        # typedef typename PlaneRefinementComparator::Ptr PlaneRefinementComparatorPtr;
+        # typedef typename PlaneRefinementComparator::ConstPtr PlaneRefinementComparatorConstPtr;
+        # 
+        # /** \brief Constructor for OrganizedMultiPlaneSegmentation. */
+        # OrganizedMultiPlaneSegmentation () :
+        # normals_ (), 
+        # min_inliers_ (1000), 
+        # angular_threshold_ (pcl::deg2rad (3.0)), 
+        # distance_threshold_ (0.02),
+        # maximum_curvature_ (0.001),
+        # project_points_ (false), 
+        # compare_ (new PlaneComparator ()), refinement_compare_ (new PlaneRefinementComparator ())
+        # 
+        # /** \brief Destructor for OrganizedMultiPlaneSegmentation. */
+        # virtual ~OrganizedMultiPlaneSegmentation ()
+        # 
+        # /** \brief Provide a pointer to the input normals.
+        # * \param[in] normals the input normal cloud
+        # */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) 
+        # 
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        # 
+        # /** \brief Set the minimum number of inliers required for a plane
+        # * \param[in] min_inliers the minimum number of inliers required per plane
+        # */
+        # inline void setMinInliers (unsigned min_inliers)
+        # 
+        # /** \brief Get the minimum number of inliers required per plane. */
+        # inline unsigned getMinInliers () const
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        # * \param[in] angular_threshold the tolerance in radians
+        # */
+        # inline void setAngularThreshold (double angular_threshold)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline double getAngularThreshold () const
+        # 
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        # * \param[in] distance_threshold the tolerance in meters
+        # */
+        # inline void setDistanceThreshold (double distance_threshold)
+        # 
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline double getDistanceThreshold () const
+        # 
+        # /** \brief Set the maximum curvature allowed for a planar region.
+        # * \param[in] maximum_curvature the maximum curvature
+        # */
+        # inline void setMaximumCurvature (double maximum_curvature)
+        # 
+        # /** \brief Get the maximum curvature allowed for a planar region. */
+        # inline double getMaximumCurvature () const
+        # 
+        # /** \brief Provide a pointer to the comparator to be used for segmentation.
+        # * \param[in] compare A pointer to the comparator to be used for segmentation.
+        # */
+        # void setComparator (const PlaneComparatorPtr& compare)
+        # 
+        # /** \brief Provide a pointer to the comparator to be used for refinement.
+        # * \param[in] compare A pointer to the comparator to be used for refinement.
+        # */
+        # void setRefinementComparator (const PlaneRefinementComparatorPtr& compare)
+        # 
+        # /** \brief Set whether or not to project boundary points to the plane, or leave them in the original 3D space.
+        # * \param[in] project_points true if points should be projected, false if not.
+        # */
+        # void setProjectPoints (bool project_points)
+        # 
+        # /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+        # * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+        # * \param[out] inlier_indices a vector of inliers for each detected plane
+        # * \param[out] centroids a vector of centroids for each plane
+        # * \param[out] covariances a vector of covariance matricies for the inliers of each plane
+        # * \param[out] labels a point cloud for the connected component labels of each pixel
+        # * \param[out] label_indices a vector of PointIndices for each labeled component
+        # */
+        # void segment (
+        #         std::vector<ModelCoefficients>& model_coefficients, 
+        #         std::vector<PointIndices>& inlier_indices,
+        #         std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+        #         std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+        #         pcl::PointCloud<PointLT>& labels, 
+        #         std::vector<pcl::PointIndices>& label_indices);
+        # 
+        # /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+        # * \param[out] model_coefficients a vector of model_coefficients for each plane found in the input cloud
+        # * \param[out] inlier_indices a vector of inliers for each detected plane
+        # */
+        # void segment (
+        #         std::vector<ModelCoefficients>& model_coefficients, 
+        #         std::vector<PointIndices>& inlier_indices);
+        # 
+        # /** \brief Segmentation of all planes in a point cloud given by setInputCloud(), setIndices()
+        # * \param[out] regions a list of resultant planar polygonal regions
+        # */
+        # void segment (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+        # 
+        # /** \brief Perform a segmentation, as well as an additional refinement step.  This helps with including points whose normals may not match neighboring points well, but may match the planar model well.
+        # * \param[out] regions A list of regions generated by segmentation and refinement.
+        # */
+        # void segmentAndRefine (std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions);
+        # 
+        # /** \brief Perform a segmentation, as well as additional refinement step.  Returns intermediate data structures for use in
+        # * subsequent processing.
+        # * \param[out] regions A vector of PlanarRegions generated by segmentation
+        # * \param[out] model_coefficients A vector of model coefficients for each segmented plane
+        # * \param[out] inlier_indices A vector of PointIndices, indicating the inliers to each segmented plane
+        # * \param[out] labels A PointCloud<PointLT> corresponding to the resulting segmentation.
+        # * \param[out] label_indices A vector of PointIndices for each label
+        # * \param[out] boundary_indices A vector of PointIndices corresponding to the outer boundary / contour of each label
+        # */
+        # void segmentAndRefine (
+        #                 std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > >& regions,
+        #                 std::vector<ModelCoefficients>& model_coefficients,
+        #                 std::vector<PointIndices>& inlier_indices,
+        #                 PointCloudLPtr& labels,
+        #                 std::vector<pcl::PointIndices>& label_indices,
+        #                 std::vector<pcl::PointIndices>& boundary_indices);
+        # 
+        # /** \brief Perform a refinement of an initial segmentation, by comparing points to adjacent regions detected by the initial segmentation.
+        # * \param [in] model_coefficients The list of segmented model coefficients
+        # * \param [in] inlier_indices The list of segmented inlier indices, corresponding to each model
+        # * \param [in] centroids The list of centroids corresponding to each segmented plane
+        # * \param [in] covariances The list of covariances corresponding to each segemented plane
+        # * \param [in] labels The labels produced by the initial segmentation
+        # * \param [in] label_indices The list of indices corresponding to each label
+        # */
+        # void refine (std::vector<ModelCoefficients>& model_coefficients, 
+        #       std::vector<PointIndices>& inlier_indices,
+        #       std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& centroids,
+        #       std::vector <Eigen::Matrix3f, Eigen::aligned_allocator<Eigen::Matrix3f> >& covariances,
+        #       PointCloudLPtr& labels,
+        #       std::vector<pcl::PointIndices>& label_indices);
+
+
+###
+
+#ifdef PCL_NO_PRECOMPILE
+#include <pcl/segmentation/impl/organized_multi_plane_segmentation.hpp>
+#endif
+
+#endif //#ifndef PCL_SEGMENTATION_ORGANIZED_MULTI_PLANE_SEGMENTATION_H_
+###
+
+# planar_polygon_fusion.h
+# namespace pcl
+# /** \brief PlanarPolygonFusion takes a list of 2D planar polygons and
+# * attempts to reduce them to a minimum set that best represents the scene,
+# * based on various given comparators.
+# */
+# template <typename PointT>
+# class PlanarPolygonFusion
+        # public:
+        # /** \brief Constructor */
+        # PlanarPolygonFusion () : regions_ () {}
+        # 
+        # /** \brief Destructor */
+        # virtual ~PlanarPolygonFusion () {}
+        # 
+        # /** \brief Reset the state (clean the list of planar models). */
+        # void reset ()
+        # 
+        # /** \brief Set the list of 2D planar polygons to refine.
+        # * \param[in] input the list of 2D planar polygons to refine
+        # */
+        # void addInputPolygons (const std::vector<PlanarRegion<PointT>, Eigen::aligned_allocator<PlanarRegion<PointT> > > &input)
+
+
+###
+
+# planar_region.h
+# namespace pcl
+# /** \brief PlanarRegion represents a set of points that lie in a plane.  Inherits summary statistics about these points from Region3D, and  summary statistics of a 3D collection of points.
+# * \author Alex Trevor
+# */
+# template <typename PointT>
+# class PlanarRegion : public pcl::Region3D<PointT>, public pcl::PlanarPolygon<PointT>
+        # protected:
+        # using Region3D<PointT>::centroid_;
+        # using Region3D<PointT>::covariance_; 
+        # using Region3D<PointT>::count_;
+        # using PlanarPolygon<PointT>::contour_;
+        # using PlanarPolygon<PointT>::coefficients_;
+        # 
+        # public:
+        # /** \brief Empty constructor for PlanarRegion. */
+        # PlanarRegion () : contour_labels_ ()
+        # 
+        # /** \brief Constructor for Planar region from a Region3D and a PlanarPolygon. 
+        # * \param[in] region a Region3D for the input data
+        # * \param[in] polygon a PlanarPolygon for the input region
+        # */
+        # PlanarRegion (const pcl::Region3D<PointT>& region, const pcl::PlanarPolygon<PointT>& polygon) :
+        # 
+        # /** \brief Destructor. */
+        # virtual ~PlanarRegion () {}
+        # 
+        # /** \brief Constructor for PlanarRegion.
+        # * \param[in] centroid the centroid of the region.
+        # * \param[in] covariance the covariance of the region.
+        # * \param[in] count the number of points in the region.
+        # * \param[in] contour the contour / boudnary for the region
+        # * \param[in] coefficients the model coefficients (a,b,c,d) for the plane
+        # */
+        # PlanarRegion (const Eigen::Vector3f& centroid, const Eigen::Matrix3f& covariance, unsigned count,
+        #             const typename pcl::PointCloud<PointT>::VectorType& contour,
+        #             const Eigen::Vector4f& coefficients) :
+
+
+###
+
+
+# plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief PlaneCoefficientComparator is a Comparator that operates on plane coefficients, for use in planar segmentation.
+#  * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#  * \author Alex Trevor
+#  */
+# template<typename PointT, typename PointNT>
+# class PlaneCoefficientComparator: public Comparator<PointT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<PlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const PlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # using pcl::Comparator<PointT>::input_;
+        # 
+        # /** \brief Empty constructor for PlaneCoefficientComparator. */
+        # PlaneCoefficientComparator ()
+        # : normals_ ()
+        # , plane_coeff_d_ ()
+        # , angular_threshold_ (pcl::deg2rad (2.0f))
+        # , distance_threshold_ (0.02f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0, 0.0, 1.0) )
+        # 
+        # /** \brief Constructor for PlaneCoefficientComparator.
+        #   * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+        #   */
+        # PlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+        # : normals_ ()
+        # , plane_coeff_d_ (plane_coeff_d)
+        # , angular_threshold_ (pcl::deg2rad (2.0f))
+        # , distance_threshold_ (0.02f)
+        # , depth_dependent_ (true)
+        # , z_axis_ (Eigen::Vector3f (0.0f, 0.0f, 1.0f) )
+        # 
+        # /** \brief Destructor for PlaneCoefficientComparator. */
+        # virtual ~PlaneCoefficientComparator ()
+        # 
+        # virtual void setInputCloud (const PointCloudConstPtr& cloud)
+        # 
+        # /** \brief Provide a pointer to the input normals.
+        #  * \param[in] normals the input normal cloud
+        #  */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals)
+        # 
+        # /** \brief Get the input normals. */
+        # inline PointCloudNConstPtr getInputNormals () const
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #   * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        #   */
+        # void setPlaneCoeffD (boost::shared_ptr<std::vector<float> >& plane_coeff_d)
+        # 
+        # /** \brief Provide a pointer to a vector of the d-coefficient of the planes' hessian normal form.  a, b, and c are provided by the normal cloud.
+        #  * \param[in] plane_coeff_d a pointer to the plane coefficients.
+        #  */
+        # void setPlaneCoeffD (std::vector<float>& plane_coeff_d)
+        # 
+        # /** \brief Get a pointer to the vector of the d-coefficient of the planes' hessian normal form. */
+        # const std::vector<float>& getPlaneCoeffD () const
+        # 
+        # /** \brief Set the tolerance in radians for difference in normal direction between neighboring points, to be considered part of the same plane.
+        #  * \param[in] angular_threshold the tolerance in radians
+        #  */
+        # virtual void setAngularThreshold (float angular_threshold)
+        # 
+        # /** \brief Get the angular threshold in radians for difference in normal direction between neighboring points, to be considered part of the same plane. */
+        # inline float getAngularThreshold () const
+        # 
+        # /** \brief Set the tolerance in meters for difference in perpendicular distance (d component of plane equation) to the plane between neighboring points, to be considered part of the same plane.
+        #   * \param[in] distance_threshold the tolerance in meters (at 1m)
+        #   * \param[in] depth_dependent whether to scale the threshold based on range from the sensor (default: false)
+        #   */
+        # void setDistanceThreshold (float distance_threshold, bool depth_dependent = false)
+        # 
+        # /** \brief Get the distance threshold in meters (d component of plane equation) between neighboring points, to be considered part of the same plane. */
+        # inline float getDistanceThreshold () const
+        # 
+        # /** \brief Compare points at two indices by their plane equations.  True if the angle between the normals is less than the angular threshold,
+        #   * and the difference between the d component of the normals is less than distance threshold, else false
+        #   * \param idx1 The first index for the comparison
+        #   * \param idx2 The second index for the comparison
+        #   */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+
+# plane_refinement_comparator.h
+# namespace pcl
+# /** \brief PlaneRefinementComparator is a Comparator that operates on plane coefficients, 
+#  * for use in planar segmentation.
+#  * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#  *
+#  * \author Alex Trevor, Suat Gedikli
+#  */
+# template<typename PointT, typename PointNT, typename PointLT>
+# class PlaneRefinementComparator: public PlaneCoefficientComparator<PointT, PointNT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename pcl::PointCloud<PointLT> PointCloudL;
+        # typedef typename PointCloudL::Ptr PointCloudLPtr;
+        # typedef typename PointCloudL::ConstPtr PointCloudLConstPtr;
+        # 
+        # typedef boost::shared_ptr<PlaneRefinementComparator<PointT, PointNT, PointLT> > Ptr;
+        # typedef boost::shared_ptr<const PlaneRefinementComparator<PointT, PointNT, PointLT> > ConstPtr;
+        # 
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::plane_coeff_d_;
+        # 
+        # /** \brief Empty constructor for PlaneCoefficientComparator. */
+        # PlaneRefinementComparator ()
+        # : models_ ()
+        # , labels_ ()
+        # , refine_labels_ ()
+        # , label_to_model_ ()
+        # , depth_dependent_ (false)
+        # 
+        # /** \brief Empty constructor for PlaneCoefficientComparator. 
+        #   * \param[in] models
+        #   * \param[in] refine_labels
+        #   */
+        # PlaneRefinementComparator (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models,
+        #                          boost::shared_ptr<std::vector<bool> >& refine_labels)
+        # : models_ (models)
+        # , labels_ ()
+        # , refine_labels_ (refine_labels)
+        # , label_to_model_ ()
+        # , depth_dependent_ (false)
+        # 
+        # /** \brief Destructor for PlaneCoefficientComparator. */
+        # virtual ~PlaneRefinementComparator ()
+        # 
+        # /** \brief Set the vector of model coefficients to which we will compare.
+        #   * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+        #   */
+        # void setModelCoefficients (boost::shared_ptr<std::vector<pcl::ModelCoefficients> >& models)
+        # 
+        # /** \brief Set the vector of model coefficients to which we will compare.
+        #   * \param[in] models a vector of model coefficients produced by the initial segmentation step.
+        #   */
+        # void setModelCoefficients (std::vector<pcl::ModelCoefficients>& models)
+        # 
+        # /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+        #   * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+        #   */
+        # void setRefineLabels (boost::shared_ptr<std::vector<bool> >& refine_labels)
+        # 
+        # /** \brief Set which labels should be refined.  This is a vector of bools 0-max_label, true if the label should be refined.
+        #   * \param[in] refine_labels A vector of bools 0-max_label, true if the label should be refined.
+        #   */
+        # void setRefineLabels (std::vector<bool>& refine_labels)
+        # 
+        # /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+        #   * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+        #   */
+        # inline void setLabelToModel (boost::shared_ptr<std::vector<int> >& label_to_model)
+        # 
+        # /** \brief A mapping from label to index in the vector of models, allowing the model coefficients of a label to be accessed.
+        #   * \param[in] label_to_model A vector of size max_label, with the index of each corresponding model in models
+        #   */
+        # inline void setLabelToModel (std::vector<int>& label_to_model)
+        # 
+        # /** \brief Get the vector of model coefficients to which we will compare. */
+        # inline boost::shared_ptr<std::vector<pcl::ModelCoefficients> > getModelCoefficients () const
+        # 
+        # /** \brief ...
+        #   * \param[in] labels
+        # */
+        # inline void setLabels (PointCloudLPtr& labels)
+        # 
+        # /** \brief Compare two neighboring points
+        #   * \param[in] idx1 The index of the first point.
+        #   * \param[in] idx2 The index of the second point.
+        #   */
+        # virtual bool compare (int idx1, int idx2) const
+
+
+###
+
+# progressive_morphological_filter.h
+# namespace pcl
+# /** \brief
+#  * Implements the Progressive Morphological Filter for segmentation of ground points.
+#  * Description can be found in the article
+#  * "A Progressive Morphological Filter for Removing Nonground Measurements from
+#  * Airborne LIDAR Data"
+#  * by K. Zhang, S. Chen, D. Whitman, M. Shyu, J. Yan, and C. Zhang.
+#  */
+# template <typename PointT>
+# class PCL_EXPORTS ProgressiveMorphologicalFilter : public pcl::PCLBase<PointT>
+cdef extern from "pcl/segmentation/progressive_morphological_filter.h" namespace "pcl":
+    cdef cppclass ProgressiveMorphologicalFilter[PointT](PCLBase[PointT]):
+        ProgressiveMorphologicalFilter()
+        # public:
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # 
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # /** \brief Constructor that sets default values for member variables. */
+        # ProgressiveMorphologicalFilter ();
+        # virtual ~ProgressiveMorphologicalFilter ();
+        # 
+        # /** \brief Get the maximum window size to be used in filtering ground returns. */
+        # inline int getMaxWindowSize () const { return (max_window_size_); }
+        int getMaxWindowSize ()
+        
+        # /** \brief Set the maximum window size to be used in filtering ground returns. */
+        # inline void setMaxWindowSize (int max_window_size) { max_window_size_ = max_window_size; }
+        void setMaxWindowSize (int max_window_size)
+        
+        # /** \brief Get the slope value to be used in computing the height threshold. */
+        # inline float getSlope () const { return (slope_); }
+        float getSlope ()
+        
+        # /** \brief Set the slope value to be used in computing the height threshold. */
+        # inline void setSlope (float slope) { slope_ = slope; }
+        void setSlope (float slope)
+        
+        # /** \brief Get the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline float getMaxDistance () const { return (max_distance_); }
+        float getMaxDistance ()
+        
+        # /** \brief Set the maximum height above the parameterized ground surface to be considered a ground return. */
+        # inline void setMaxDistance (float max_distance) { max_distance_ = max_distance; }
+        void setMaxDistance (float max_distance)
+        
+        # /** \brief Get the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline float getInitialDistance () const { return (initial_distance_); }
+        float getInitialDistance ()
+        
+        # /** \brief Set the initial height above the parameterized ground surface to be considered a ground return. */
+        # inline void setInitialDistance (float initial_distance) { initial_distance_ = initial_distance; }
+        void setInitialDistance (float initial_distance)
+        
+        # /** \brief Get the cell size. */
+        # inline float getCellSize () const { return (cell_size_); }
+        float getCellSize ()
+        
+        # /** \brief Set the cell size. */
+        # inline void setCellSize (float cell_size) { cell_size_ = cell_size; }
+        void setCellSize (float cell_size)
+        
+        # /** \brief Get the base to be used in computing progressive window sizes. */
+        # inline float getBase () const { return (base_); }
+        float getBase ()
+        
+        # /** \brief Set the base to be used in computing progressive window sizes. */
+        # inline void setBase (float base) { base_ = base; }
+        setBase (float base)
+        
+        # /** \brief Get flag indicating whether or not to exponentially grow window sizes? */
+        # inline bool getExponential () const { return (exponential_); }
+        bool getExponential ()
+        
+        # /** \brief Set flag indicating whether or not to exponentially grow window sizes? */
+        # inline void setExponential (bool exponential) { exponential_ = exponential; }
+        void setExponential (bool exponential)
+        
+        # /** \brief This method launches the segmentation algorithm and returns indices of
+        #   * points determined to be ground returns.
+        #   * \param[out] ground indices of points determined to be ground returns.
+        #   */
+        # virtual void extract (std::vector<int>& ground);
+        # void extract (vector[int]& ground)
+
+
+ctypedef ProgressiveMorphologicalFilter[PointXYZ] ProgressiveMorphologicalFilter_t
+ctypedef ProgressiveMorphologicalFilter[PointXYZI] ProgressiveMorphologicalFilter_PointXYZI_t
+ctypedef ProgressiveMorphologicalFilter[PointXYZRGB] ProgressiveMorphologicalFilter_PointXYZRGB_t
+ctypedef ProgressiveMorphologicalFilter[PointXYZRGBA] ProgressiveMorphologicalFilter_PointXYZRGBA_t
+###
+
+# region_3d.h
+# namespace pcl
+# /** \brief Region3D represents summary statistics of a 3D collection of points.
+#  * \author Alex Trevor
+#  */
+# template <typename PointT>
+# class Region3D
+        # public:
+        # /** \brief Empty constructor for Region3D. */
+        # Region3D () : centroid_ (Eigen::Vector3f::Zero ()), covariance_ (Eigen::Matrix3f::Identity ()), count_ (0)
+        # 
+        # /** \brief Constructor for Region3D. 
+        # * \param[in] centroid The centroid of the region.
+        # * \param[in] covariance The covariance of the region.
+        # * \param[in] count The number of points in the region.
+        # */
+        # Region3D (Eigen::Vector3f& centroid, Eigen::Matrix3f& covariance, unsigned count) 
+        # : centroid_ (centroid), covariance_ (covariance), count_ (count)
+        # 
+        # /** \brief Destructor. */
+        # virtual ~Region3D () {}
+        # 
+        # /** \brief Get the centroid of the region. */
+        # inline Eigen::Vector3f getCentroid () const
+        # 
+        # /** \brief Get the covariance of the region. */
+        # inline Eigen::Matrix3f getCovariance () const
+        # 
+        # /** \brief Get the number of points in the region. */
+        # unsigned getCount () const
+        # 
+        # /** \brief Get the curvature of the region. */
+        # float getCurvature () const
+        # 
+        # /** \brief Set the curvature of the region. */
+        # void setCurvature (float curvature)
+
+
+###
+
+# region_growing.h
+# namespace pcl
+# /** \brief
+#  * Implements the well known Region Growing algorithm used for segmentation.
+#  * Description can be found in the article
+#  * "Segmentation of point clouds using smoothness constraint"
+#  * by T. Rabbania, F. A. van den Heuvelb, G. Vosselmanc.
+#  * In addition to residual test, the possibility to test curvature is added.
+#  */
+# template <typename PointT, typename NormalT>
+# class PCL_EXPORTS RegionGrowing : public pcl::PCLBase<PointT>
+        # public:
+        # typedef pcl::search::Search <PointT> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::PointCloud <NormalT> Normal;
+        # typedef typename Normal::Ptr NormalPtr;
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # /** \brief Constructor that sets default values for member variables. */
+        # RegionGrowing ();
+        # 
+        # /** \brief This destructor destroys the cloud, normals and search method used for
+        #  * finding KNN. In other words it frees memory.
+        #  */
+        # virtual ~RegionGrowing ();
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMinClusterSize ();
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMinClusterSize (int min_cluster_size);
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMaxClusterSize ();
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMaxClusterSize (int max_cluster_size);
+        # 
+        # /** \brief Returns the flag value. This flag signalizes which mode of algorithm will be used.
+        #  * If it is set to true than it will work as said in the article. This means that
+        #  * it will be testing the angle between normal of the current point and it's neighbours normal.
+        #  * Otherwise, it will be testing the angle between normal of the current point
+        #  * and normal of the initial point that was chosen for growing new segment.
+        #  */
+        # bool getSmoothModeFlag () const;
+        # 
+        # /** \brief This function allows to turn on/off the smoothness constraint.
+        #   * \param[in] value new mode value, if set to true then the smooth version will be used.
+        #   */
+        # void setSmoothModeFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the curvature test is turned on/off. */
+        # bool getCurvatureTestFlag () const;
+        # 
+        # /** \brief Allows to turn on/off the curvature test. Note that at least one test
+        #   * (residual or curvature) must be turned on. If you are turning curvature test off
+        #   * then residual test will be turned on automatically.
+        #   *  \param[in] value new value for curvature test. If set to true then the test will be turned on
+        #   */
+        # virtual void setCurvatureTestFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the residual test is turned on/off. */
+        # bool getResidualTestFlag () const;
+        # 
+        # /** \brief
+        # * Allows to turn on/off the residual test. Note that at least one test
+        # * (residual or curvature) must be turned on. If you are turning residual test off
+        # * then curvature test will be turned on automatically.
+        # * \param[in] value new value for residual test. If set to true then the test will be turned on
+        # */
+        # virtual void setResidualTestFlag (bool value);
+        # 
+        # /** \brief Returns smoothness threshold. */
+        # float getSmoothnessThreshold () const;
+        # 
+        # /** \brief Allows to set smoothness threshold used for testing the points.
+        #   * \param[in] theta new threshold value for the angle between normals
+        #   */
+        # void setSmoothnessThreshold (float theta);
+        # 
+        # /** \brief Returns residual threshold. */
+        # float getResidualThreshold () const;
+        # 
+        # /** \brief Allows to set residual threshold used for testing the points.
+        # * \param[in] residual new threshold value for residual testing
+        # */
+        # void setResidualThreshold (float residual);
+        # 
+        # /** \brief Returns curvature threshold. */
+        # float getCurvatureThreshold () const;
+        # 
+        # /** \brief Allows to set curvature threshold used for testing the points.
+        #  * \param[in] curvature new threshold value for curvature testing
+        #  */
+        # void setCurvatureThreshold (float curvature);
+        # 
+        # /** \brief Returns the number of nearest neighbours used for KNN. */
+        # unsigned int getNumberOfNeighbours () const;
+        # 
+        # /** \brief Allows to set the number of neighbours. For more information check the article.
+        #  * \param[in] neighbour_number number of neighbours to use
+        #  */
+        # void setNumberOfNeighbours (unsigned int neighbour_number);
+        # 
+        # /** \brief Returns the pointer to the search method that is used for KNN. */
+        # KdTreePtr getSearchMethod () const;
+        # 
+        # /** \brief Allows to set search method that will be used for finding KNN.
+        #  * \param[in] tree pointer to a KdTree
+        #  */
+        # void setSearchMethod (const KdTreePtr& tree);
+        # 
+        # /** \brief Returns normals. */
+        # NormalPtr getInputNormals () const;
+        # 
+        # /** \brief This method sets the normals. They are needed for the algorithm, so if
+        #  * no normals will be set, the algorithm would not be able to segment the points.
+        #  * \param[in] norm normals that will be used in the algorithm
+        #  */
+        # void setInputNormals (const NormalPtr& norm);
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        #   * obtained during the segmentation.
+        #   * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        #   */
+        # virtual void extract (std::vector <pcl::PointIndices>& clusters);
+        # 
+        # /** \brief For a given point this function builds a segment to which it belongs and returns this segment.
+        #  * \param[in] index index of the initial point which will be the seed for growing a segment.
+        #  * \param[out] cluster cluster to which the point belongs.
+        #  */
+        # virtual void getSegmentFromPoint (int index, pcl::PointIndices& cluster);
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        #  * returns colored cloud. Otherwise it returns an empty pointer.
+        #  * Points that belong to the same segment have the same color.
+        #  * But this function doesn't guarantee that different segments will have different
+        #  * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        #  */
+        # pcl::PointCloud<pcl::PointXYZRGB>::Ptr getColoredCloud ();
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        # * returns colored cloud. Otherwise it returns an empty pointer.
+        # * Points that belong to the same segment have the same color.
+        # * But this function doesn't guarantee that different segments will have different
+        # * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        # */
+        # pcl::PointCloud<pcl::PointXYZRGBA>::Ptr getColoredCloudRGBA ();
+
+
+###
+
+# region_growing_rgb.h
+# namespace pcl
+# /** \brief
+# * Implements the well known Region Growing algorithm used for segmentation.
+# * Description can be found in the article
+# * "Segmentation of point clouds using smoothness constraint"
+# * by T. Rabbania, F. A. van den Heuvelb, G. Vosselmanc.
+# * In addition to residual test, the possibility to test curvature is added.
+# */
+# template <typename PointT, typename NormalT>
+# class PCL_EXPORTS RegionGrowing : public pcl::PCLBase<PointT>
+        # public:
+        # typedef pcl::search::Search <PointT> KdTree;
+        # typedef typename KdTree::Ptr KdTreePtr;
+        # typedef pcl::PointCloud <NormalT> Normal;
+        # typedef typename Normal::Ptr NormalPtr;
+        # typedef pcl::PointCloud <PointT> PointCloud;
+        # using PCLBase <PointT>::input_;
+        # using PCLBase <PointT>::indices_;
+        # using PCLBase <PointT>::initCompute;
+        # using PCLBase <PointT>::deinitCompute;
+        # public:
+        # 
+        # /** \brief Constructor that sets default values for member variables. */
+        # RegionGrowing ();
+        # 
+        # /** \brief This destructor destroys the cloud, normals and search method used for
+        # * finding KNN. In other words it frees memory.
+        # */
+        # virtual ~RegionGrowing ();
+        # 
+        # /** \brief Get the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMinClusterSize ();
+        # 
+        # /** \brief Set the minimum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMinClusterSize (int min_cluster_size);
+        # 
+        # /** \brief Get the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # int getMaxClusterSize ();
+        # 
+        # /** \brief Set the maximum number of points that a cluster needs to contain in order to be considered valid. */
+        # void setMaxClusterSize (int max_cluster_size);
+        # 
+        # /** \brief Returns the flag value. This flag signalizes which mode of algorithm will be used.
+        # * If it is set to true than it will work as said in the article. This means that
+        # * it will be testing the angle between normal of the current point and it's neighbours normal.
+        # * Otherwise, it will be testing the angle between normal of the current point
+        # * and normal of the initial point that was chosen for growing new segment.
+        # */
+        # bool getSmoothModeFlag () const;
+        # 
+        # /** \brief This function allows to turn on/off the smoothness constraint.
+        # * \param[in] value new mode value, if set to true then the smooth version will be used.
+        # */
+        # void setSmoothModeFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the curvature test is turned on/off. */
+        # bool getCurvatureTestFlag () const;
+        # 
+        # /** \brief Allows to turn on/off the curvature test. Note that at least one test
+        # * (residual or curvature) must be turned on. If you are turning curvature test off
+        # * then residual test will be turned on automatically.
+        # * \param[in] value new value for curvature test. If set to true then the test will be turned on
+        # */
+        # virtual void setCurvatureTestFlag (bool value);
+        # 
+        # /** \brief Returns the flag that signalize if the residual test is turned on/off. */
+        # bool getResidualTestFlag () const;
+        # 
+        # /** \brief
+        # * Allows to turn on/off the residual test. Note that at least one test
+        # * (residual or curvature) must be turned on. If you are turning residual test off
+        # * then curvature test will be turned on automatically.
+        # * \param[in] value new value for residual test. If set to true then the test will be turned on
+        # */
+        # virtual void setResidualTestFlag (bool value);
+        # 
+        # /** \brief Returns smoothness threshold. */
+        # float getSmoothnessThreshold () const;
+        # 
+        # /** \brief Allows to set smoothness threshold used for testing the points.
+        # * \param[in] theta new threshold value for the angle between normals
+        # */
+        # void setSmoothnessThreshold (float theta);
+        # 
+        # /** \brief Returns residual threshold. */
+        # float getResidualThreshold () const;
+        # 
+        # /** \brief Allows to set residual threshold used for testing the points.
+        # * \param[in] residual new threshold value for residual testing
+        # */
+        # void setResidualThreshold (float residual);
+        # 
+        # /** \brief Returns curvature threshold. */
+        # float getCurvatureThreshold () const;
+        # 
+        # /** \brief Allows to set curvature threshold used for testing the points.
+        # * \param[in] curvature new threshold value for curvature testing
+        # */
+        # void setCurvatureThreshold (float curvature);
+        # 
+        # /** \brief Returns the number of nearest neighbours used for KNN. */
+        # unsigned int getNumberOfNeighbours () const;
+        # 
+        # /** \brief Allows to set the number of neighbours. For more information check the article.
+        # * \param[in] neighbour_number number of neighbours to use
+        # */
+        # void setNumberOfNeighbours (unsigned int neighbour_number);
+        # 
+        # /** \brief Returns the pointer to the search method that is used for KNN. */
+        # KdTreePtr getSearchMethod () const;
+        # 
+        # /** \brief Allows to set search method that will be used for finding KNN.
+        # * \param[in] tree pointer to a KdTree
+        # */
+        # void setSearchMethod (const KdTreePtr& tree);
+        # 
+        # /** \brief Returns normals. */
+        # NormalPtr getInputNormals () const;
+        # 
+        # /** \brief This method sets the normals. They are needed for the algorithm, so if
+        # * no normals will be set, the algorithm would not be able to segment the points.
+        # * \param[in] norm normals that will be used in the algorithm
+        # */
+        # void setInputNormals (const NormalPtr& norm);
+        # 
+        # /** \brief This method launches the segmentation algorithm and returns the clusters that were
+        # * obtained during the segmentation.
+        # * \param[out] clusters clusters that were obtained. Each cluster is an array of point indices.
+        # */
+        # virtual void extract (std::vector <pcl::PointIndices>& clusters);
+        # 
+        # /** \brief For a given point this function builds a segment to which it belongs and returns this segment.
+        # * \param[in] index index of the initial point which will be the seed for growing a segment.
+        # * \param[out] cluster cluster to which the point belongs.
+        # */
+        # virtual void getSegmentFromPoint (int index, pcl::PointIndices& cluster);
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        # * returns colored cloud. Otherwise it returns an empty pointer.
+        # * Points that belong to the same segment have the same color.
+        # * But this function doesn't guarantee that different segments will have different
+        # * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        # */
+        # pcl::PointCloud<pcl::PointXYZRGB>::Ptr getColoredCloud ();
+        # 
+        # /** \brief If the cloud was successfully segmented, then function
+        # * returns colored cloud. Otherwise it returns an empty pointer.
+        # * Points that belong to the same segment have the same color.
+        # * But this function doesn't guarantee that different segments will have different
+        # * color(it all depends on RNG). Points that were not listed in the indices array will have red color.
+        # */
+        # pcl::PointCloud<pcl::PointXYZRGBA>::Ptr getColoredCloudRGBA ();
+        # 
+        # /** \brief This function is used as a comparator for sorting. */
+        # inline bool comparePair (std::pair<float, int> i, std::pair<float, int> j)
+
+
+###
+
+
+# rgb_plane_coefficient_comparator.h
+# namespace pcl
+# /** \brief RGBPlaneCoefficientComparator is a Comparator that operates on plane coefficients, 
+#  * for use in planar segmentation.  Also takes into account RGB, so we can segmented different colored co-planar regions.
+#  * In conjunction with OrganizedConnectedComponentSegmentation, this allows planes to be segmented from organized data.
+#  *
+#  * \author Alex Trevor
+#  */
+# template<typename PointT, typename PointNT>
+# class RGBPlaneCoefficientComparator: public PlaneCoefficientComparator<PointT, PointNT>
+        # public:
+        # typedef typename Comparator<PointT>::PointCloud PointCloud;
+        # typedef typename Comparator<PointT>::PointCloudConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef boost::shared_ptr<RGBPlaneCoefficientComparator<PointT, PointNT> > Ptr;
+        # typedef boost::shared_ptr<const RGBPlaneCoefficientComparator<PointT, PointNT> > ConstPtr;
+        # 
+        # using pcl::Comparator<PointT>::input_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::normals_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::angular_threshold_;
+        # using pcl::PlaneCoefficientComparator<PointT, PointNT>::distance_threshold_;
+        # 
+        # /** \brief Empty constructor for RGBPlaneCoefficientComparator. */
+        # RGBPlaneCoefficientComparator ()
+        # : color_threshold_ (50.0f)
+        # 
+        # /** \brief Constructor for RGBPlaneCoefficientComparator.
+        # * \param[in] plane_coeff_d a reference to a vector of d coefficients of plane equations.  Must be the same size as the input cloud and input normals.  a, b, and c coefficients are in the input normals.
+        # */
+        # RGBPlaneCoefficientComparator (boost::shared_ptr<std::vector<float> >& plane_coeff_d) 
+        # : PlaneCoefficientComparator<PointT, PointNT> (plane_coeff_d), color_threshold_ (50.0f)
+        # 
+        # /** \brief Destructor for RGBPlaneCoefficientComparator. */
+        # virtual ~RGBPlaneCoefficientComparator ()
+        # 
+        # /** \brief Set the tolerance in color space between neighboring points, to be considered part of the same plane.
+        # * \param[in] color_threshold The distance in color space
+        # */
+        # inline void setColorThreshold (float color_threshold)
+        # 
+        # /** \brief Get the color threshold between neighboring points, to be considered part of the same plane. */
+        # inline float getColorThreshold () const
+        # 
+        # /** \brief Compare two neighboring points, by using normal information, euclidean distance, and color information.
+        # * \param[in] idx1 The index of the first point.
+        # * \param[in] idx2 The index of the second point.
+        # */
+        # bool compare (int idx1, int idx2) const
+
+
+###
+
+# sac_segmentation.h
+# namespace pcl
+# /** \brief @b SACSegmentation represents the Nodelet segmentation class for
+#  * Sample Consensus methods and models, in the sense that it just creates a
+#  * Nodelet wrapper for generic-purpose SAC-based segmentation.
+#  * \author Radu Bogdan Rusu
+#  * \ingroup segmentation
+#  */
+# template <typename PointT>
+# class SACSegmentation : public PCLBase<PointT>
+        # using PCLBase<PointT>::initCompute;
+        # using PCLBase<PointT>::deinitCompute;
+        # public:
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::search::Search<PointT>::Ptr SearchPtr;
+        # typedef typename SampleConsensus<PointT>::Ptr SampleConsensusPtr;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # 
+        # /** \brief Empty constructor. 
+        # * \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
+        # */
+        # SACSegmentation (bool random = false) 
+        # : model_ ()
+        # , sac_ ()
+        # , model_type_ (-1)
+        # , method_type_ (0)
+        # , threshold_ (0)
+        # , optimize_coefficients_ (true)
+        # , radius_min_ (-std::numeric_limits<double>::max ())
+        # , radius_max_ (std::numeric_limits<double>::max ())
+        # , samples_radius_ (0.0)
+        # , samples_radius_search_ ()
+        # , eps_angle_ (0.0)
+        # , axis_ (Eigen::Vector3f::Zero ())
+        # , max_iterations_ (50)
+        # , probability_ (0.99)
+        # , random_ (random)
+        # 
+        # /** \brief Empty destructor. */
+        # virtual ~SACSegmentation () { /*srv_.reset ();*/ };
+        # 
+        # /** \brief The type of model to use (user given parameter).
+        # * \param[in] model the model type (check \a model_types.h)
+        # */
+        # inline void setModelType (int model) { model_type_ = model; }
+        # 
+        # /** \brief Get the type of SAC model used. */
+        # inline int getModelType () const { return (model_type_); }
+        # 
+        # /** \brief Get a pointer to the SAC method used. */
+        # inline SampleConsensusPtr getMethod () const { return (sac_); }
+        # 
+        # /** \brief Get a pointer to the SAC model used. */
+        # inline SampleConsensusModelPtr getModel () const { return (model_); }
+        # 
+        # /** \brief The type of sample consensus method to use (user given parameter).
+        # * \param[in] method the method type (check \a method_types.h)
+        # */
+        # inline void setMethodType (int method) { method_type_ = method; }
+        # 
+        # /** \brief Get the type of sample consensus method used. */
+        # inline int getMethodType () const { return (method_type_); }
+        # 
+        # /** \brief Distance to the model threshold (user given parameter).
+        # * \param[in] threshold the distance threshold to use
+        # */
+        # inline void setDistanceThreshold (double threshold) { threshold_ = threshold; }
+        # 
+        # /** \brief Get the distance to the model threshold. */
+        # inline double getDistanceThreshold () const { return (threshold_); }
+        # 
+        # /** \brief Set the maximum number of iterations before giving up.
+        # * \param[in] max_iterations the maximum number of iterations the sample consensus method will run
+        # */
+        # inline void setMaxIterations (int max_iterations) { max_iterations_ = max_iterations; }
+        # 
+        # /** \brief Get maximum number of iterations before giving up. */
+        # inline int getMaxIterations () const { return (max_iterations_); }
+        # 
+        # /** \brief Set the probability of choosing at least one sample free from outliers.
+        # * \param[in] probability the model fitting probability
+        # */
+        # inline void setProbability (double probability) { probability_ = probability; }
+        # 
+        # /** \brief Get the probability of choosing at least one sample free from outliers. */
+        # inline double getProbability () const { return (probability_); }
+        # 
+        # /** \brief Set to true if a coefficient refinement is required.
+        # * \param[in] optimize true for enabling model coefficient refinement, false otherwise
+        # */
+        # inline void setOptimizeCoefficients (bool optimize) { optimize_coefficients_ = optimize; }
+        # 
+        # /** \brief Get the coefficient refinement internal flag. */
+        # inline bool getOptimizeCoefficients () const { return (optimize_coefficients_); }
+        # 
+        # /** \brief Set the minimum and maximum allowable radius limits for the model (applicable to models that estimate
+        # * a radius)
+        # * \param[in] min_radius the minimum radius model
+        # * \param[in] max_radius the maximum radius model
+        # */
+        # inline void setRadiusLimits (const double &min_radius, const double &max_radius)
+        # 
+        # /** \brief Get the minimum and maximum allowable radius limits for the model as set by the user.
+        # * \param[out] min_radius the resultant minimum radius model
+        # * \param[out] max_radius the resultant maximum radius model
+        # */
+        # inline void getRadiusLimits (double &min_radius, double &max_radius)
+        # 
+        # /** \brief Set the maximum distance allowed when drawing random samples
+        # * \param[in] radius the maximum distance (L2 norm)
+        # * \param search
+        # */
+        # inline void setSamplesMaxDist (const double &radius, SearchPtr search)
+        # 
+        # /** \brief Get maximum distance allowed when drawing random samples
+        # *
+        # * \param[out] radius the maximum distance (L2 norm)
+        # */
+        # inline void getSamplesMaxDist (double &radius)
+        # 
+        # /** \brief Set the axis along which we need to search for a model perpendicular to.
+        # * \param[in] ax the axis along which we need to search for a model perpendicular to
+        # */
+        # inline void setAxis (const Eigen::Vector3f &ax) { axis_ = ax; }
+        # 
+        # /** \brief Get the axis along which we need to search for a model perpendicular to. */
+        # inline Eigen::Vector3f getAxis () const { return (axis_); }
+        # 
+        # /** \brief Set the angle epsilon (delta) threshold.
+        # * \param[in] ea the maximum allowed difference between the model normal and the given axis in radians.
+        # */
+        # inline void setEpsAngle (double ea) { eps_angle_ = ea; }
+        # 
+        # /** \brief Get the epsilon (delta) model angle threshold in radians. */
+        # inline double getEpsAngle () const { return (eps_angle_); }
+        # 
+        # /** \brief Base method for segmentation of a model in a PointCloud given by <setInputCloud (), setIndices ()>
+        # * \param[in] inliers the resultant point indices that support the model found (inliers)
+        # * \param[out] model_coefficients the resultant model coefficients
+        # */
+        # virtual void segment (PointIndices &inliers, ModelCoefficients &model_coefficients);
+
+
+###
+
+# sac_segmentation.h
+# namespace pcl
+# /** \brief @b SACSegmentationFromNormals represents the PCL nodelet segmentation class for Sample Consensus methods and
+#  * models that require the use of surface normals for estimation.
+#  * \ingroup segmentation
+#  */
+# template <typename PointT, typename PointNT>
+# class SACSegmentationFromNormals: public SACSegmentation<PointT>
+        # using SACSegmentation<PointT>::model_;
+        # using SACSegmentation<PointT>::model_type_;
+        # using SACSegmentation<PointT>::radius_min_;
+        # using SACSegmentation<PointT>::radius_max_;
+        # using SACSegmentation<PointT>::eps_angle_;
+        # using SACSegmentation<PointT>::axis_;
+        # using SACSegmentation<PointT>::random_;
+        # 
+        # public:
+        # using PCLBase<PointT>::input_;
+        # using PCLBase<PointT>::indices_;
+        # typedef typename SACSegmentation<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename pcl::PointCloud<PointNT> PointCloudN;
+        # typedef typename PointCloudN::Ptr PointCloudNPtr;
+        # typedef typename PointCloudN::ConstPtr PointCloudNConstPtr;
+        # typedef typename SampleConsensus<PointT>::Ptr SampleConsensusPtr;
+        # typedef typename SampleConsensusModel<PointT>::Ptr SampleConsensusModelPtr;
+        # typedef typename SampleConsensusModelFromNormals<PointT, PointNT>::Ptr SampleConsensusModelFromNormalsPtr;
+        # 
+        # /** \brief Empty constructor.
+        # * \param[in] random if true set the random seed to the current time, else set to 12345 (default: false)
+        # */
+        # SACSegmentationFromNormals (bool random = false) 
+        # : SACSegmentation<PointT> (random)
+        # , normals_ ()
+        # , distance_weight_ (0.1)
+        # , distance_from_origin_ (0)
+        # , min_angle_ ()
+        # , max_angle_ ()
+        # 
+        # /** \brief Provide a pointer to the input dataset that contains the point normals of 
+        # * the XYZ dataset.
+        # * \param[in] normals the const boost shared pointer to a PointCloud message
+        # */
+        # inline void setInputNormals (const PointCloudNConstPtr &normals) { normals_ = normals; }
+        # 
+        # /** \brief Get a pointer to the normals of the input XYZ point cloud dataset. */
+        # inline PointCloudNConstPtr getInputNormals () const { return (normals_); }
+        # 
+        # /** \brief Set the relative weight (between 0 and 1) to give to the angular 
+        # * distance (0 to pi/2) between point normals and the plane normal.
+        # * \param[in] distance_weight the distance/angular weight
+        # */
+        # inline void setNormalDistanceWeight (double distance_weight) { distance_weight_ = distance_weight; }
+        # 
+        # /** \brief Get the relative weight (between 0 and 1) to give to the angular distance (0 to pi/2) between point
+        # * normals and the plane normal. */
+        # inline double getNormalDistanceWeight () const { return (distance_weight_); }
+        # 
+        # /** \brief Set the minimum opning angle for a cone model.
+        # * \param min_angle the opening angle which we need minumum to validate a cone model.
+        # * \param max_angle the opening angle which we need maximum to validate a cone model.
+        # */
+        # inline void setMinMaxOpeningAngle (const double &min_angle, const double &max_angle)
+        # 
+        # /** \brief Get the opening angle which we need minumum to validate a cone model. */
+        # inline void getMinMaxOpeningAngle (double &min_angle, double &max_angle)
+        # 
+        # /** \brief Set the distance we expect a plane model to be from the origin
+        # * \param[in] d distance from the template plane modl to the origin
+        # */
+        # inline void setDistanceFromOrigin (const double d) { distance_from_origin_ = d; }
+        # 
+        # /** \brief Get the distance of a plane model from the origin. */
+        # inline double getDistanceFromOrigin () const { return (distance_from_origin_); }
+
+
+###
+
+# seeded_hue_segmentation.h
+# namespace pcl
+# /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#  * \param[in] cloud the point cloud message
+#  * \param[in] tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#  * \note the tree has to be created as a spatial locator on \a cloud
+#  * \param[in] tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#  * \param[in] indices_in the cluster containing the seed point indices (as a vector of PointIndices)
+#  * \param[out] indices_out 
+#  * \param[in] delta_hue
+#  * \todo look how to make this templated!
+#  * \ingroup segmentation
+#  */
+# void seededHueSegmentation (
+#                       const PointCloud<PointXYZRGB>                           &cloud, 
+#                         const boost::shared_ptr<search::Search<PointXYZRGB> >   &tree, 
+#                         float                                                   tolerance, 
+#                         PointIndices                                            &indices_in, 
+#                         PointIndices                                            &indices_out, 
+#                         float                                                   delta_hue = 0.0);
+###
+
+# seeded_hue_segmentation.h
+# namespace pcl
+#   /** \brief Decompose a region of space into clusters based on the Euclidean distance between points
+#     * \param[in] cloud the point cloud message
+#     * \param[in] tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching
+#     * \note the tree has to be created as a spatial locator on \a cloud
+#     * \param[in] tolerance the spatial cluster tolerance as a measure in L2 Euclidean space
+#     * \param[in] indices_in the cluster containing the seed point indices (as a vector of PointIndices)
+#     * \param[out] indices_out 
+#     * \param[in] delta_hue
+#     * \todo look how to make this templated!
+#     * \ingroup segmentation
+#     */
+#   void 
+#   seededHueSegmentation (const PointCloud<PointXYZRGB>                           &cloud, 
+#                          const boost::shared_ptr<search::Search<PointXYZRGBL> >  &tree, 
+#                          float                                                   tolerance, 
+#                          PointIndices                                            &indices_in, 
+#                          PointIndices                                            &indices_out, 
+#                          float                                                   delta_hue = 0.0);
+# 
+###
+
+# seeded_hue_segmentation.h
+# namespace pcl
+#   /** \brief SeededHueSegmentation 
+#     * \author Koen Buys
+#     * \ingroup segmentation
+#     */
+#   class SeededHueSegmentation: public PCLBase<PointXYZRGB>
+#   {
+#     typedef PCLBase<PointXYZRGB> BasePCLBase;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointXYZRGB> PointCloud;
+#       typedef PointCloud::Ptr PointCloudPtr;
+#       typedef PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef pcl::search::Search<PointXYZRGB> KdTree;
+#       typedef pcl::search::Search<PointXYZRGB>::Ptr KdTreePtr;
+# 
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+# 
+#       //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#       /** \brief Empty constructor. */
+#       SeededHueSegmentation () : tree_ (), cluster_tolerance_ (0), delta_hue_ (0.0)
+#       {};
+# 
+#       /** \brief Provide a pointer to the search object.
+#         * \param[in] tree a pointer to the spatial search object.
+#         */
+#       inline void 
+#       setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+# 
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr 
+#       getSearchMethod () const { return (tree_); }
+# 
+#       /** \brief Set the spatial cluster tolerance as a measure in the L2 Euclidean space
+#         * \param[in] tolerance the spatial cluster tolerance as a measure in the L2 Euclidean space
+#         */
+#       inline void 
+#       setClusterTolerance (double tolerance) { cluster_tolerance_ = tolerance; }
+# 
+#       /** \brief Get the spatial cluster tolerance as a measure in the L2 Euclidean space. */
+#       inline double 
+#       getClusterTolerance () const { return (cluster_tolerance_); }
+# 
+#       /** \brief Set the tollerance on the hue
+#         * \param[in] delta_hue the new delta hue
+#         */
+#       inline void setDeltaHue (float delta_hue) { delta_hue_ = delta_hue; }
+#       
+#       /** \brief Get the tolerance on the hue */
+#       inline float getDeltaHue () const { return (delta_hue_); }
+#       
+#       /** \brief Cluster extraction in a PointCloud given by <setInputCloud (), setIndices ()>
+#         * \param[in] indices_in
+#         * \param[out] indices_out
+#         */
+#       void segment (PointIndices &indices_in, PointIndices &indices_out);
+
+
+###
+
+# segment_differences.h
+# namespace pcl
+# /** \brief Obtain the difference between two aligned point clouds as another point cloud, given a distance threshold.
+#   * \param src the input point cloud source
+#   * \param tgt the input point cloud target we need to obtain the difference against
+#   * \param threshold the distance threshold (tolerance) for point correspondences. (e.g., check if f a point p1 from 
+#   * src has a correspondence > threshold than a point p2 from tgt)
+#   * \param tree the spatial locator (e.g., kd-tree) used for nearest neighbors searching built over \a tgt
+#   * \param output the resultant output point cloud difference
+#   * \ingroup segmentation
+#   */
+# template <typename PointT> 
+# void getPointCloudDifference (
+#     const pcl::PointCloud<PointT> &src, const pcl::PointCloud<PointT> &tgt, 
+#     double threshold, const boost::shared_ptr<pcl::search::Search<PointT> > &tree,
+#     pcl::PointCloud<PointT> &output);
+###
+
+# segment_differences.h
+# namespace pcl
+# /** \brief @b SegmentDifferences obtains the difference between two spatially
+#   * aligned point clouds and returns the difference between them for a maximum
+#   * given distance threshold.
+#   * \author Radu Bogdan Rusu
+#   * \ingroup segmentation
+#   */
+# template <typename PointT>
+# class SegmentDifferences: public PCLBase<PointT>
+#       typedef PCLBase<PointT> BasePCLBase;
+#       
+#       public:
+#       typedef pcl::PointCloud<PointT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+#       typedef typename pcl::search::Search<PointT> KdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr KdTreePtr;
+#       typedef PointIndices::Ptr PointIndicesPtr;
+#       typedef PointIndices::ConstPtr PointIndicesConstPtr;
+#       
+#       /** \brief Empty constructor. */
+#       SegmentDifferences () : 
+#         tree_ (), target_ (), distance_threshold_ (0)
+#       {};
+#       
+#       /** \brief Provide a pointer to the target dataset against which we
+#         * compare the input cloud given in setInputCloud
+#         *
+#         * \param cloud the target PointCloud dataset
+#         */
+#       inline void setTargetCloud (const PointCloudConstPtr &cloud) { target_ = cloud; }
+#       
+#       /** \brief Get a pointer to the input target point cloud dataset. */
+#       inline PointCloudConstPtr const getTargetCloud () { return (target_); }
+#       
+#       /** \brief Provide a pointer to the search object.
+#         * \param tree a pointer to the spatial search object.
+#         */
+#       inline void setSearchMethod (const KdTreePtr &tree) { tree_ = tree; }
+#       
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr getSearchMethod () { return (tree_); }
+#       
+#       /** \brief Set the maximum distance tolerance (squared) between corresponding
+#         * points in the two input datasets.
+#         * \param sqr_threshold the squared distance tolerance as a measure in L2 Euclidean space
+#         */
+#       inline void setDistanceThreshold (double sqr_threshold) { distance_threshold_ = sqr_threshold; }
+#       
+#       /** \brief Get the squared distance tolerance between corresponding points as a
+#         * measure in the L2 Euclidean space.
+#         */
+#       inline double getDistanceThreshold () { return (distance_threshold_); }
+#       
+#       /** \brief Segment differences between two input point clouds.
+#         * \param output the resultant difference between the two point clouds as a PointCloud
+#         */
+#       void segment (PointCloud &output);
+
+
+###
+
+# supervoxel_clustering.h
+# namespace pcl
+# /** \brief Supervoxel container class - stores a cluster extracted using supervoxel clustering 
+#  */
+# template <typename PointT>
+# class Supervoxel
+#       public:
+#       Supervoxel () :
+#         voxels_ (new pcl::PointCloud<PointT> ()),
+#         normals_ (new pcl::PointCloud<Normal> ())
+#       
+#       typedef boost::shared_ptr<Supervoxel<PointT> > Ptr;
+#       typedef boost::shared_ptr<const Supervoxel<PointT> > ConstPtr;
+#       
+#       /** \brief Gets the centroid of the supervoxel
+#        *  \param[out] centroid_arg centroid of the supervoxel
+#        */ 
+#       void getCentroidPoint (PointXYZRGBA &centroid_arg)
+#       
+#       /** \brief Gets the point normal for the supervoxel 
+#        * \param[out] normal_arg Point normal of the supervoxel
+#        * \note This isn't an average, it is a normal computed using all of the voxels in the supervoxel as support
+#        */ 
+#       void getCentroidPointNormal (PointNormal &normal_arg)
+
+
+###
+
+# # supervoxel_clustering.h
+# namespace pcl
+#   /** \brief Implements a supervoxel algorithm based on voxel structure, normals, and rgb values
+#    *   \note Supervoxels are oversegmented volumetric patches (usually surfaces) 
+#    *   \note Usually, color isn't needed (and can be detrimental)- spatial structure is mainly used
+#     * - J. Papon, A. Abramov, M. Schoeler, F. Woergoetter
+#     *   Voxel Cloud Connectivity Segmentation - Supervoxels from PointClouds
+#     *   In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) 2013 
+#     *  \author Jeremie Papon (jpapon@gmail.com)
+#     */
+#   template <typename PointT>
+#   class PCL_EXPORTS SupervoxelClustering : public pcl::PCLBase<PointT>
+#   {
+#     //Forward declaration of friended helper class
+#     class SupervoxelHelper;
+#     friend class SupervoxelHelper;
+#     public:
+#       /** \brief VoxelData is a structure used for storing data within a pcl::octree::OctreePointCloudAdjacencyContainer
+#        *  \note It stores xyz, rgb, normal, distance, an index, and an owner.
+#        */
+#       class VoxelData
+#       {
+#         public:
+#           VoxelData ():
+#             xyz_ (0.0f, 0.0f, 0.0f),
+#             rgb_ (0.0f, 0.0f, 0.0f),
+#             normal_ (0.0f, 0.0f, 0.0f, 0.0f),
+#             curvature_ (0.0f),
+#             owner_ (0)
+#             {}
+#             
+#           /** \brief Gets the data of in the form of a point
+#            *  \param[out] point_arg Will contain the point value of the voxeldata
+#            */  
+#           void
+#           getPoint (PointT &point_arg) const;
+#           
+#           /** \brief Gets the data of in the form of a normal
+#            *  \param[out] normal_arg Will contain the normal value of the voxeldata
+#            */            
+#           void
+#           getNormal (Normal &normal_arg) const;
+#           
+#           Eigen::Vector3f xyz_;
+#           Eigen::Vector3f rgb_;
+#           Eigen::Vector4f normal_;
+#           float curvature_;
+#           float distance_;
+#           int idx_;
+#           SupervoxelHelper* owner_;
+#           
+#         public:
+#           EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#       };
+#       
+#       typedef pcl::octree::OctreePointCloudAdjacencyContainer<PointT, VoxelData> LeafContainerT;
+#       typedef std::vector <LeafContainerT*> LeafVectorT;
+#       typedef typename pcl::PointCloud<PointT> PointCloudT;
+#       typedef typename pcl::PointCloud<Normal> NormalCloudT;
+#       typedef typename pcl::octree::OctreePointCloudAdjacency<PointT, LeafContainerT> OctreeAdjacencyT;
+#       typedef typename pcl::octree::OctreePointCloudSearch <PointT> OctreeSearchT;
+#       typedef typename pcl::search::KdTree<PointT> KdTreeT;
+#       typedef boost::shared_ptr<std::vector<int> > IndicesPtr;
+#       
+#       using PCLBase <PointT>::initCompute;
+#       using PCLBase <PointT>::deinitCompute;
+#       using PCLBase <PointT>::input_;
+#       
+#       typedef boost::adjacency_list<boost::setS, boost::setS, boost::undirectedS, uint32_t, float> VoxelAdjacencyList;
+#       typedef VoxelAdjacencyList::vertex_descriptor VoxelID;
+#       typedef VoxelAdjacencyList::edge_descriptor EdgeID;
+#       
+#       
+#       public:
+#       
+#       /** \brief Constructor that sets default values for member variables. 
+#        *  \param[in] voxel_resolution The resolution (in meters) of voxels used
+#        *  \param[in] seed_resolution The average size (in meters) of resulting supervoxels
+#        *  \param[in] use_single_camera_transform Set to true if point density in cloud falls off with distance from origin (such as with a cloud coming from one stationary camera), set false if input cloud is from multiple captures from multiple locations.
+#        */
+#       SupervoxelClustering (float voxel_resolution, float seed_resolution, bool use_single_camera_transform = true);
+#       
+#       /** \brief This destructor destroys the cloud, normals and search method used for
+#         * finding neighbors. In other words it frees memory.
+#         */
+#       virtual
+#       ~SupervoxelClustering ();
+#       
+#       /** \brief Set the resolution of the octree voxels */
+#       void
+#       setVoxelResolution (float resolution);
+#       
+#       /** \brief Get the resolution of the octree voxels */
+#       float 
+#       getVoxelResolution () const;
+#       
+#       /** \brief Set the resolution of the octree seed voxels */
+#       void
+#       setSeedResolution (float seed_resolution);
+#       
+#       /** \brief Get the resolution of the octree seed voxels */
+#       float 
+#       getSeedResolution () const;
+#         
+#       /** \brief Set the importance of color for supervoxels */
+#       void
+#       setColorImportance (float val);
+#       
+#       /** \brief Set the importance of spatial distance for supervoxels */
+#       void
+#       setSpatialImportance (float val);
+#             
+#       /** \brief Set the importance of scalar normal product for supervoxels */
+#       void
+#       setNormalImportance (float val);
+#       
+#       /** \brief This method launches the segmentation algorithm and returns the supervoxels that were
+#        * obtained during the segmentation.
+#        * \param[out] supervoxel_clusters A map of labels to pointers to supervoxel structures
+#        */
+#       virtual void
+#       extract (std::map<uint32_t,typename Supervoxel<PointT>::Ptr > &supervoxel_clusters);
+#       
+#       /** \brief This method sets the cloud to be supervoxelized
+#        * \param[in] cloud The cloud to be supervoxelize
+#        */
+#       virtual void
+#       setInputCloud (const typename pcl::PointCloud<PointT>::ConstPtr& cloud);
+#       
+#       /** \brief This method sets the normals to be used for supervoxels (should be same size as input cloud)
+#       * \param[in] normal_cloud The input normals                         
+#       */
+#       virtual void
+#       setNormalCloud (typename NormalCloudT::ConstPtr normal_cloud);
+#       
+#       /** \brief This method refines the calculated supervoxels - may only be called after extract
+#        * \param[in] num_itr The number of iterations of refinement to be done (2 or 3 is usually sufficient)
+#        * \param[out] supervoxel_clusters The resulting refined supervoxels
+#        */
+#       virtual void
+#       refineSupervoxels (int num_itr, std::map<uint32_t,typename Supervoxel<PointT>::Ptr > &supervoxel_clusters);
+#       
+#       ////////////////////////////////////////////////////////////
+#       /** \brief Returns an RGB colorized cloud showing superpixels
+#         * Otherwise it returns an empty pointer.
+#         * Points that belong to the same supervoxel have the same color.
+#         * But this function doesn't guarantee that different segments will have different
+#         * color(it's random). Points that are unlabeled will be black
+#         * \note This will expand the label_colors_ vector so that it can accomodate all labels
+#         */
+#       typename pcl::PointCloud<PointXYZRGBA>::Ptr
+#       getColoredCloud () const;
+#       
+#       /** \brief Returns a deep copy of the voxel centroid cloud */
+#       typename pcl::PointCloud<PointT>::Ptr
+#       getVoxelCentroidCloud () const;
+#       
+#       /** \brief Returns labeled cloud
+#         * Points that belong to the same supervoxel have the same label.
+#         * Labels for segments start from 1, unlabled points have label 0
+#         */
+#       typename pcl::PointCloud<PointXYZL>::Ptr
+#       getLabeledCloud () const;
+#       
+#       /** \brief Returns an RGB colorized voxelized cloud showing superpixels
+#        * Otherwise it returns an empty pointer.
+#        * Points that belong to the same supervoxel have the same color.
+#        * But this function doesn't guarantee that different segments will have different
+#        * color(it's random). Points that are unlabeled will be black
+#        * \note This will expand the label_colors_ vector so that it can accomodate all labels
+#        */
+#       pcl::PointCloud<pcl::PointXYZRGBA>::Ptr
+#       getColoredVoxelCloud () const;
+#       
+#       /** \brief Returns labeled voxelized cloud
+#        * Points that belong to the same supervoxel have the same label.
+#        * Labels for segments start from 1, unlabled points have label 0
+#        */      
+#       pcl::PointCloud<pcl::PointXYZL>::Ptr
+#       getLabeledVoxelCloud () const;
+# 
+#       /** \brief Gets the adjacency list (Boost Graph library) which gives connections between supervoxels
+#        *  \param[out] adjacency_list_arg BGL graph where supervoxel labels are vertices, edges are touching relationships
+#        */
+#       void
+#       getSupervoxelAdjacencyList (VoxelAdjacencyList &adjacency_list_arg) const;
+#       
+#       /** \brief Get a multimap which gives supervoxel adjacency
+#        *  \param[out] label_adjacency Multi-Map which maps a supervoxel label to all adjacent supervoxel labels
+#        */
+#       void getSupervoxelAdjacency (std::multimap<uint32_t, uint32_t> &label_adjacency) const;
+#             
+#       /** \brief Static helper function which returns a pointcloud of normals for the input supervoxels 
+#        *  \param[in] supervoxel_clusters Supervoxel cluster map coming from this class
+#        *  \returns Cloud of PointNormals of the supervoxels
+#        * 
+#        */
+#       static pcl::PointCloud<pcl::PointNormal>::Ptr
+#       makeSupervoxelNormalCloud (std::map<uint32_t,typename Supervoxel<PointT>::Ptr > &supervoxel_clusters);
+#       
+#       /** \brief Returns the current maximum (highest) label */
+#       int getMaxLabel () const;
+#   };
+# 
+# }
+
+
+###
+
+
diff --git a/pcl/pcl_surface.pxd b/pcl/pcl_surface.pxd
new file mode 100644
index 0000000..8a94ae3
--- /dev/null
+++ b/pcl/pcl_surface.pxd
@@ -0,0 +1,4695 @@
+# -*- coding: utf-8 -*-
+
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_kdtree as pclkdt
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# reconstruction.h
+# namespace pcl
+# brief Pure abstract class. All types of meshing/reconstruction
+# algorithms in \b libpcl_surface must inherit from this, in order to make
+# sure we have a consistent API. The methods that we care about here are:
+#  - \b setSearchMethod(&SearchPtr): passes a search locator
+#  - \b reconstruct(&PolygonMesh): creates a PolygonMesh object from the input data
+# author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+# 
+# template <typename PointInT>
+# class PCLSurfaceBase: public PCLBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass PCLSurfaceBase[In](cpp.PCLBase[In]):
+        PCLSurfaceBase()
+        
+        # brief Provide an optional pointer to a search object.
+        # param[in] tree a pointer to the spatial search object.
+        # inline void setSearchMethod (const KdTreePtr &tree)
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # brief Get a pointer to the search method used.
+        # inline KdTreePtr getSearchMethod ()
+        pclkdt.KdTreePtr_t getSearchMethod ()
+        
+        # /** \brief Base method for surface reconstruction for all points given in
+        #   * <setInputCloud (), setIndices ()> 
+        #   * \param[out] output the resultant reconstructed surface model
+        # virtual void reconstruct (pcl::PolygonMesh &output) = 0;
+
+
+###
+
+# /** \brief SurfaceReconstruction represents a base surface reconstruction
+#   * class. All \b surface reconstruction methods take in a point cloud and
+#   * generate a new surface from it, by either re-sampling the data or
+#   * generating new data altogether. These methods are thus \b not preserving
+#   * the topology of the original data.
+#   * \note Reconstruction methods that always preserve the original input
+#   * point cloud data as the surface vertices and simply construct the mesh on
+#   * top should inherit from \ref MeshConstruction.
+#   * \author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+#   * \ingroup surface
+#   */
+# template <typename PointInT>
+# class SurfaceReconstruction: public PCLSurfaceBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass SurfaceReconstruction[In](PCLSurfaceBase[In]):
+        SurfaceReconstruction()
+        # public:
+        # using PCLSurfaceBase<PointInT>::input_;
+        # using PCLSurfaceBase<PointInT>::indices_;
+        # using PCLSurfaceBase<PointInT>::initCompute;
+        # using PCLSurfaceBase<PointInT>::deinitCompute;
+        # using PCLSurfaceBase<PointInT>::tree_;
+        # using PCLSurfaceBase<PointInT>::getClassName;
+        # 
+        # /** \brief Base method for surface reconstruction for all points given in
+        #  * <setInputCloud (), setIndices ()> 
+        #  * \param[out] output the resultant reconstructed surface model
+        #  */
+        # virtual void reconstruct (pcl::PolygonMesh &output);
+        # 
+        # /** \brief Base method for surface reconstruction for all points given in
+        #   * <setInputCloud (), setIndices ()> 
+        #   * \param[out] points the resultant points lying on the new surface
+        #   * \param[out] polygons the resultant polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   */
+        # virtual void reconstruct (pcl::PointCloud<PointInT> &points, std::vector<pcl::Vertices> &polygons);
+
+
+###
+
+# brief MeshConstruction represents a base surface reconstruction
+# class. All \b mesh constructing methods that take in a point cloud and
+# generate a surface that uses the original data as vertices should inherit
+# from this class.
+# 
+# note Reconstruction methods that generate a new surface or create new
+# vertices in locations different than the input data should inherit from
+# \ref SurfaceReconstruction.
+# 
+# author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+# \ingroup surface
+# 
+# template <typename PointInT>
+# class MeshConstruction: public PCLSurfaceBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass MeshConstruction[In](PCLSurfaceBase[In]):
+        MeshConstruction()
+        # public:
+        # using PCLSurfaceBase<PointInT>::input_;
+        # using PCLSurfaceBase<PointInT>::indices_;
+        # using PCLSurfaceBase<PointInT>::initCompute;
+        # using PCLSurfaceBase<PointInT>::deinitCompute;
+        # using PCLSurfaceBase<PointInT>::tree_;
+        # using PCLSurfaceBase<PointInT>::getClassName;
+        
+        # brief Base method for surface reconstruction for all points given in <setInputCloud (), setIndices ()> 
+        # param[out] output the resultant reconstructed surface model
+        # 
+        # note This method copies the input point cloud data from
+        # PointCloud<T> to PointCloud2, and is implemented here for backwards
+        # compatibility only!
+        # 
+        # virtual void reconstruct (pcl::PolygonMesh &output);
+        # brief Base method for mesh construction for all points given in <setInputCloud (), setIndices ()> 
+        # param[out] polygons the resultant polygons, as a set of vertices.
+        # The Vertices structure contains an array of point indices.
+        # 
+        # virtual void reconstruct (std::vector<pcl::Vertices> &polygons);
+        # 
+        # protected:
+        # /** \brief A flag specifying whether or not the derived reconstruction
+        #   * algorithm needs the search object \a tree.*/
+        # bool check_tree_;
+        # /** \brief Abstract surface reconstruction method. 
+        #   * \param[out] output the output polygonal mesh 
+        #   */
+        # virtual void performReconstruction (pcl::PolygonMesh &output) = 0;
+        # /** \brief Abstract surface reconstruction method. 
+        #   * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+        #   */
+        # virtual void performReconstruction (std::vector<pcl::Vertices> &polygons) = 0;
+###
+
+# processing.h
+# namespace pcl
+# brief @b CloudSurfaceProcessing represents the base class for algorithms that take a point cloud as an input and
+# produce a new output cloud that has been modified towards a better surface representation. These types of
+# algorithms include surface smoothing, hole filling, cloud upsampling etc.
+# author Alexandru E. Ichim
+# ingroup surface
+# 
+# template <typename PointInT, typename PointOutT>
+# class CloudSurfaceProcessing : public PCLBase<PointInT>
+cdef extern from "pcl/surface/processing.h" namespace "pcl":
+    cdef cppclass CloudSurfaceProcessing[In, Out](cpp.PCLBase[In]):
+        CloudSurfaceProcessing()
+        # public:
+        # using PCLBase<PointInT>::input_;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::initCompute;
+        # using PCLBase<PointInT>::deinitCompute;
+        # public:
+        # /** \brief Process the input cloud and store the results
+        #   * \param[out] output the cloud where the results will be stored
+        # virtual void process (pcl::PointCloud<PointOutT> &output);
+
+
+### 
+
+# /** \brief @b MeshProcessing represents the base class for mesh processing algorithms.
+#   * \author Alexandru E. Ichim
+#   * \ingroup surface
+#   */
+# class PCL_EXPORTS MeshProcessing
+#       public:
+#       typedef PolygonMesh::ConstPtr PolygonMeshConstPtr;
+#       /** \brief Constructor. */
+#       MeshProcessing () : input_mesh_ () {};
+#       /** \brief Destructor. */
+#       virtual ~MeshProcessing () {}
+#       /** \brief Set the input mesh that we want to process
+#         * \param[in] input the input polygonal mesh
+#       void setInputMesh (const pcl::PolygonMeshConstPtr &input) 
+#       /** \brief Process the input surface mesh and store the results
+#         * \param[out] output the resultant processed surface model
+#       void process (pcl::PolygonMesh &output);
+#       protected:
+#       /** \brief Initialize computation. Must be called before processing starts. */
+#       virtual bool initCompute ();
+#       /** \brief UnInitialize computation. Must be called after processing ends. */
+#       virtual void deinitCompute ();
+#       /** \brief Abstract surface processing method. */
+#       virtual void performProcessing (pcl::PolygonMesh &output) = 0;
+#       /** \brief Abstract class get name method. */
+#       virtual std::string getClassName () const { return (""); }
+#       /** \brief Input polygonal mesh. */
+#       pcl::PolygonMeshConstPtr input_mesh_;
+###
+
+
+# (1.6.0)allocator.h
+# (1.7.2) -> pcl\surface\3rdparty\poisson4 ?
+# namespace pcl 
+# namespace poisson 
+# class AllocatorState
+# cdef extern from "pcl/surface/allocator.h" namespace "pcl::poisson":
+#     cdef cppclass AllocatorState:
+#         AllocatorState()
+#         # public:
+#         # int index,remains;
+
+
+# (1.6.0) -> allocator.h
+# (1.7.2) -> pcl\surface\3rdparty\poisson4 ?
+# template<class T>
+# class Allocator
+# cdef extern from "pcl/surface/allocator.h" namespace "pcl::poisson":
+#     cdef cppclass Allocator[T]:
+#         Allocator()
+        # int blockSize;
+        # int index, remains;
+        # std::vector<T*> memory;
+        # public:
+        # /** This method is the allocators destructor. It frees up any of the memory that
+        #   * it has allocated. 
+        # void reset ()
+        # /** This method returns the memory state of the allocator. */
+        # AllocatorState getState () const
+        # /** This method rolls back the allocator so that it makes all of the memory previously
+        #   * allocated available for re-allocation. Note that it does it not call the constructor
+        #   * again, so after this method has been called, assumptions about the state of the values
+        #   * in memory are no longer valid. 
+        # void rollBack ()
+        # /** This method rolls back the allocator to the previous memory state and makes all of the memory previously
+        #   * allocated available for re-allocation. Note that it does it not call the constructor
+        #   * again, so after this method has been called, assumptions about the state of the values
+        #   * in memory are no longer valid. 
+        # void rollBack (const AllocatorState& state)
+        # /** This method initiallizes the constructor and the blockSize variable specifies the
+        #   * the number of objects that should be pre-allocated at a time. 
+        # void set (const int& blockSize)
+        # /** This method returns a pointer to an array of elements objects. If there is left over pre-allocated
+        #   * memory, this method simply returns a pointer to the next free piece of memory, otherwise it pre-allocates
+        #   * more memory. Note that if the number of objects requested is larger than the value blockSize with which
+        #   * the allocator was initialized, the request for memory will fail.
+        # T* newElements (const int& elements = 1)
+###
+
+# bilateral_upsampling.h
+# namespace pcl
+# /** \brief Bilateral filtering implementation, based on the following paper:
+#   *   * Kopf, Johannes and Cohen, Michael F. and Lischinski, Dani and Uyttendaele, Matt - Joint Bilateral Upsampling,
+#   *   * ACM Transations in Graphics, July 2007
+#   * Takes in a colored organized point cloud (i.e. PointXYZRGB or PointXYZRGBA), that might contain nan values for the
+#   * depth information, and it will returned an upsampled version of this cloud, based on the formula:
+#   * \f[
+#   *    \tilde{S}_p = \frac{1}{k_p} \sum_{q_d \in \Omega} {S_{q_d} f(||p_d - q_d|| g(||\tilde{I}_p-\tilde{I}_q||})
+#   * \f]
+#   * where S is the depth image, I is the RGB image and f and g are Gaussian functions centered at 0 and with
+#   * standard deviations \f$\sigma_{color}\f$ and \f$\sigma_{depth}\f$
+#   */
+# template <typename PointInT, typename PointOutT>
+# class BilateralUpsampling: public CloudSurfaceProcessing<PointInT, PointOutT>
+cdef extern from "pcl/surface/bilateral_upsampling.h" namespace "pcl":
+    cdef cppclass BilateralUpsampling[In, Out](CloudSurfaceProcessing[In, Out]):
+        BilateralUpsampling()
+        # public:
+        # using PCLBase<PointInT>::input_;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::initCompute;
+        # using PCLBase<PointInT>::deinitCompute;
+        # using CloudSurfaceProcessing<PointInT, PointOutT>::process;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # Eigen::Matrix3f KinectVGAProjectionMatrix, KinectSXGAProjectionMatrix;
+        # 
+        # /** \brief Method that sets the window size for the filter
+        #   * \param[in] window_size the given window size
+        # inline void setWindowSize (int window_size)
+        void setWindowSize (int window_size)
+        
+        # /** \brief Returns the filter window size */
+        # inline int getWindowSize () const
+        int getWindowSize ()
+        
+        # /** \brief Method that sets the sigma color parameter
+        #   * \param[in] sigma_color the new value to be set
+        # inline void setSigmaColor (const float &sigma_color)
+        void setSigmaColor (const float &sigma_color)
+        
+        # /** \brief Returns the current sigma color value */
+        # inline float getSigmaColor () const
+        
+        # /** \brief Method that sets the sigma depth parameter
+        #   * \param[in] sigma_depth the new value to be set
+        # inline void setSigmaDepth (const float &sigma_depth)
+        
+        # /** \brief Returns the current sigma depth value */
+        # inline float getSigmaDepth () const
+        
+        # /** \brief Method that sets the projection matrix to be used when unprojecting the points in the depth image
+        #   * back to (x,y,z) positions.
+        #   * \note There are 2 matrices already set in the class, used for the 2 modes available for the Kinect. They
+        #   * are tuned to be the same as the ones in the OpenNiGrabber
+        #   * \param[in] projection_matrix the new projection matrix to be set */
+        # inline void setProjectionMatrix (const Eigen::Matrix3f &projection_matrix)
+        
+        # /** \brief Returns the current projection matrix */
+        # inline Eigen::Matrix3f getProjectionMatrix () const
+        
+        # /** \brief Method that does the actual processing on the input cloud.
+        #   * \param[out] output the container of the resulting upsampled cloud */
+        # void process (pcl::PointCloud<PointOutT> &output)
+
+
+###
+
+# binary_node.h (1.6.0)
+# pcl/surface/3rdparty\poisson4\binary_node.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# template<class Real>
+# class BinaryNode
+# cdef extern from "pcl/surface/binary_node.h" namespace "pcl::poisson":
+#    cdef cppclass BinaryNode[Real]:
+#        BinaryNode()
+        # public:
+        # static inline int CenterCount (int depth){return 1<<depth;}
+        # static inline int CumulativeCenterCount (int maxDepth){return  (1<< (maxDepth+1))-1;}
+        # static inline int Index (int depth,  int offSet){return  (1<<depth)+offSet-1;}
+        # static inline int CornerIndex (int maxDepth, int depth, int offSet, int forwardCorner)
+        # static inline Real CornerIndexPosition (int index, int maxDepth)
+        # static inline Real Width (int depth)
+        # 
+        # // Fix for Bug #717 with Visual Studio that generates wrong code for this function
+        # // when global optimization is enabled (release mode).
+        # #ifdef _MSC_VER
+        #   static __declspec(noinline) void CenterAndWidth (int depth, int offset, Real& center, Real& width)
+        # #else
+        # static inline void CenterAndWidth (int depth, int offset, Real& center, Real& width)
+        # # #endif
+        # 
+        # #ifdef _MSC_VER
+        # static __declspec(noinline) void CenterAndWidth (int idx, Real& center, Real& width)
+        # #else
+        # static inline void CenterAndWidth (int idx, Real& center, Real& width)
+        # #endif
+        # static inline void DepthAndOffset (int idx,  int& depth, int& offset)
+###
+
+# concave_hull.h
+# namespace pcl
+# template<typename PointInT>
+# class ConcaveHull : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/concave_hull.h" namespace "pcl":
+    cdef cppclass ConcaveHull[PointInT](MeshConstruction[PointInT]):
+        ConcaveHull()
+        # public:
+        # \brief Compute a concave hull for all points given 
+        # \param points the resultant points lying on the concave hull 
+        # \param polygons the resultant concave hull polygons, as a set of
+        # vertices. The Vertices structure contains an array of point indices.
+        # void reconstruct (PointCloud &points, std::vector<pcl::Vertices> &polygons);
+        
+        # /** \brief Compute a concave hull for all points given 
+        #  * \param output the resultant concave hull vertices
+        # void reconstruct (PointCloud &output);
+        void reconstruct (cpp.PointCloud_t output)
+        void reconstruct (cpp.PointCloud_PointXYZI_t output)
+        void reconstruct (cpp.PointCloud_PointXYZRGB_t output)
+        void reconstruct (cpp.PointCloud_PointXYZRGBA_t output)
+        void reconstruct (PointInT output)
+        
+        # /** \brief Set the alpha value, which limits the size of the resultant
+        #   * hull segments (the smaller the more detailed the hull).  
+        #   * \param alpha positive, non-zero value, defining the maximum length
+        #   * from a vertex to the facet center (center of the voronoi cell).
+        # inline void setAlpha (double alpha)
+        void setAlpha (double alpha)
+        
+        # Returns the alpha parameter, see setAlpha().
+        # inline double getAlpha ()
+        double getAlpha ()
+        
+        # If set, the voronoi cells center will be saved in _voronoi_centers_
+        # voronoi_centers
+        # inline void setVoronoiCenters (PointCloudPtr voronoi_centers)
+        
+        # \brief If keep_information_is set to true the convex hull
+        # points keep other information like rgb, normals, ...
+        # \param value where to keep the information or not, default is false
+        # void setKeepInformation (bool value)
+        void setKeepInformation (bool value)
+        
+        # brief Returns the dimensionality (2 or 3) of the calculated hull.
+        # inline int getDim () const
+        int getDim ()
+        
+        # brief Returns the dimensionality (2 or 3) of the calculated hull.
+        # inline int getDimension () const
+        int getDimension ()
+        
+        # brief Sets the dimension on the input data, 2D or 3D.
+        # param[in] dimension The dimension of the input data.  If not set, this will be determined automatically.
+        void setDimension (int dimension)
+
+
+ctypedef ConcaveHull[cpp.PointXYZ] ConcaveHull_t
+ctypedef ConcaveHull[cpp.PointXYZI] ConcaveHull_PointXYZI_t
+ctypedef ConcaveHull[cpp.PointXYZRGB] ConcaveHull_PointXYZRGB_t
+ctypedef ConcaveHull[cpp.PointXYZRGBA] ConcaveHull_PointXYZRGBA_t
+###
+
+# convex_hull.h
+# namespace pcl
+# /** \brief Sort 2D points in a vector structure
+#   * \param p1 the first point
+#   * \param p2 the second point
+#   * \ingroup surface
+#   */
+# inline bool comparePoints2D (const std::pair<int, Eigen::Vector4f> & p1, const std::pair<int, Eigen::Vector4f> & p2)
+# 
+# convex_hull.h
+# namespace pcl
+# template<typename PointInT>
+# class ConvexHull : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/convex_hull.h" namespace "pcl":
+    cdef cppclass ConvexHull[PointInT](MeshConstruction[PointInT]):
+        ConvexHull()
+        # protected:
+        # using PCLBase<PointInT>::input_;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::initCompute;
+        # using PCLBase<PointInT>::deinitCompute;
+        # public:
+        # using MeshConstruction<PointInT>::reconstruct;
+        # typedef pcl::PointCloud<PointInT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # 
+        # /** \brief Compute a convex hull for all points given 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        # void reconstruct (PointCloud &points, std::vector<pcl::Vertices> &polygons);
+        void reconstruct (PointInT &points, vector[cpp.Vertices] &polygons)
+        
+        # /** \brief Compute a convex hull for all points given 
+        #   * \param[out] output the resultant convex hull vertices
+        # void reconstruct (PointCloud &output);
+        void reconstruct (PointInT &output)
+        
+        # /** \brief If set to true, the qhull library is called to compute the total area and volume of the convex hull.
+        #   * NOTE: When this option is activated, the qhull library produces output to the console.
+        #   * \param[in] value wheter to compute the area and the volume, default is false
+        void setComputeAreaVolume (bool value)
+        
+        # /** \brief Returns the total area of the convex hull. */
+        double getTotalArea ()
+        
+        # /** \brief Returns the total volume of the convex hull. Only valid for 3-dimensional sets.
+        #   *  For 2D-sets volume is zero. 
+        double getTotalVolume ()
+        
+        # /** \brief Sets the dimension on the input data, 2D or 3D.
+        #   * \param[in] dimension The dimension of the input data.  If not set, this will be determined automatically.
+        void setDimension (int dimension)
+        
+        # /** \brief Returns the dimensionality (2 or 3) of the calculated hull. */
+        # inline int getDimension () const
+        int getDimension ()
+
+
+###
+
+# ear_clipping.h
+# namespace pcl
+# /** \brief The ear clipping triangulation algorithm.
+#   * The code is inspired by Flavien Brebion implementation, which is
+#   * in n^3 and does not handle holes.
+#   * \author Nicolas Burrus
+#   * \ingroup surface
+# class PCL_EXPORTS EarClipping : public MeshProcessing
+#       public:
+#       using MeshProcessing::input_mesh_;
+#       using MeshProcessing::initCompute;
+#       /** \brief Empty constructor */
+#       EarClipping () : MeshProcessing (), points_ ()
+#       { 
+#       };
+# 
+#       protected:
+#       /** \brief a Pointer to the point cloud data. */
+#       pcl::PointCloud<pcl::PointXYZ>::Ptr points_;
+# 
+#       /** \brief This method should get called before starting the actual computation. */
+#       bool initCompute ();
+#       /** \brief The actual surface reconstruction method. 
+#         * \param[out] output the output polygonal mesh 
+#         */
+#       void performProcessing (pcl::PolygonMesh &output);
+# 
+#       /** \brief Triangulate one polygon. 
+#         * \param[in] vertices the set of vertices
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void triangulate (const Vertices& vertices, PolygonMesh& output);
+# 
+#       /** \brief Compute the signed area of a polygon. 
+#         * \param[in] vertices the vertices representing the polygon 
+#         */
+#       float area (const std::vector<uint32_t>& vertices);
+# 
+#       /** \brief Check if the triangle (u,v,w) is an ear. 
+#         * \param[in] u the first triangle vertex 
+#         * \param[in] v the second triangle vertex 
+#         * \param[in] w the third triangle vertex 
+#         * \param[in] vertices a set of input vertices
+#         */
+#       bool isEar (int u, int v, int w, const std::vector<uint32_t>& vertices);
+# 
+#       /** \brief Check if p is inside the triangle (u,v,w). 
+#         * \param[in] u the first triangle vertex 
+#         * \param[in] v the second triangle vertex 
+#         * \param[in] w the third triangle vertex 
+#         * \param[in] p the point to check
+#         */
+#       bool isInsideTriangle (const Eigen::Vector2f& u,
+#                         const Eigen::Vector2f& v,
+#                         const Eigen::Vector2f& w,
+#                         const Eigen::Vector2f& p);
+# 
+# 
+#       /** \brief Compute the cross product between 2D vectors.
+#        * \param[in] p1 the first 2D vector
+#        * \param[in] p2 the first 2D vector
+#        */
+#       float crossProduct (const Eigen::Vector2f& p1, const Eigen::Vector2f& p2) const
+###
+
+# factor.h(1.6.0)
+# pcl/surface/3rdparty/poisson4/factor.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# 
+#     double ArcTan2 (const double& y, const double& x);
+#     double Angle (const double in[2]);
+#     void Sqrt (const double in[2], double out[2]);
+#     void Add (const double in1[2], const double in2[2], double out[2]);
+#     void Subtract (const double in1[2], const double in2[2], double out[2]);
+#     void Multiply (const double in1[2], const double in2[2], double out[2]);
+#     void Divide (const double in1[2], const double in2[2], double out[2]);
+# 
+#     int Factor (double a1, double a0, double roots[1][2], const double& EPS);
+#     int Factor (double a2, double a1, double a0, double roots[2][2], const double& EPS);
+#     int Factor (double a3, double a2, double a1, double a0, double roots[3][2], const double& EPS);
+#     int Factor (double a4, double a3, double a2, double a1, double a0, double roots[4][2], const double& EPS);
+# 
+#     int Solve (const double* eqns, const double* values, double* solutions, const int& dim);
+###
+
+# function_data.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/function_data.h (1.7.2)
+# namespace pcl 
+# namespace poisson 
+# template<int Degree,class Real>
+# class FunctionData
+# cdef extern from "pcl/surface/function_data.h" namespace "pcl::poisson":
+#     cdef cppclass FunctionData:
+#         FunctionData()
+#         int useDotRatios;
+#         int normalize;
+#         public:
+#         const static int DOT_FLAG;
+#         const static int D_DOT_FLAG;
+#         const static int D2_DOT_FLAG;
+#         const static int VALUE_FLAG;
+#         const static int D_VALUE_FLAG;
+#         int depth, res, res2;
+#         Real *dotTable, *dDotTable, *d2DotTable;
+#         Real *valueTables, *dValueTables;
+#         PPolynomial<Degree> baseFunction;
+#         PPolynomial<Degree-1> dBaseFunction;
+#         PPolynomial<Degree+1>* baseFunctions;
+#         virtual void setDotTables (const int& flags);
+#         virtual void clearDotTables (const int& flags);
+#         virtual void setValueTables (const int& flags, const double& smooth = 0);
+#         virtual void setValueTables (const int& flags, const double& valueSmooth, const double& normalSmooth);
+#         virtual void clearValueTables (void);
+#         void set (const int& maxDepth, const PPolynomial<Degree>& F, const int& normalize, const int& useDotRatios = 1);
+#         Real dotProduct (const double& center1, const double& width1,
+#                          const double& center2, const double& width2) const;
+#         Real dDotProduct (const double& center1, const double& width1,
+#                           const double& center2, const double& width2) const;
+#         Real d2DotProduct (const double& center1, const double& width1,
+#                            const double& center2, const double& width2) const;
+#         static inline int SymmetricIndex (const int& i1, const int& i2);
+#         static inline int SymmetricIndex (const int& i1, const int& i2, int& index);
+###
+
+# geometry.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/geometry.h (1.7.2)
+# namespace pcl
+# namespace poisson 
+#   {
+#     template<class Real>
+#     Real Random (void);
+# 
+#     template<class Real>
+#     struct Point3D{Real coords[3];};
+# 
+#     template<class Real>
+#     Point3D<Real> RandomBallPoint (void);
+# 
+#     template<class Real>
+#     Point3D<Real> RandomSpherePoint (void);
+# 
+#     template<class Real>
+#     double Length (const Point3D<Real>& p);
+# 
+#     template<class Real>
+#     double SquareLength (const Point3D<Real>& p);
+# 
+#     template<class Real>
+#     double Distance (const Point3D<Real>& p1, const Point3D<Real>& p2);
+# 
+#     template<class Real>
+#     double SquareDistance (const Point3D<Real>& p1, const Point3D<Real>& p2);
+# 
+#     template <class Real>
+#     void CrossProduct (const Point3D<Real>& p1, const Point3D<Real>& p2, Point3D<Real>& p);
+# 
+#     class Edge
+#     {
+#       public:
+#         double p[2][2];
+#         double Length (void) const
+#         {
+#           double d[2];
+#           d[0]=p[0][0]-p[1][0];
+#           d[1]=p[0][1]-p[1][1];
+# 
+#           return sqrt (d[0]*d[0]+d[1]*d[1]);
+#         }
+#     };
+#     
+#     class Triangle
+#     {
+#       public:
+#         double p[3][3];
+#         
+#         double 
+#         Area (void) const
+#         {
+#           double v1[3], v2[3], v[3];
+#           for (int d=0;d<3;d++)
+#           {
+#             v1[d] = p[1][d]-p[0][d];
+#             v2[d] = p[2][d]-p[0][d];
+#           }
+#           v[0] =  v1[1]*v2[2]-v1[2]*v2[1];
+#           v[1] = -v1[0]*v2[2]+v1[2]*v2[0];
+#           v[2] =  v1[0]*v2[1]-v1[1]*v2[0];
+# 
+#           return (sqrt (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) / 2);
+#         }
+# 
+#         double 
+#         AspectRatio (void) const
+#         {
+#           double d=0;
+#           int i, j;
+#           for (i = 0; i < 3; i++)
+#           {
+#             for (i = 0; i < 3; i++)
+#               for (j = 0; j < 3; j++)
+#               {
+#                 d += (p[(i+1)%3][j]-p[i][j])* (p[(i+1)%3][j]-p[i][j]);
+#               }
+#           }
+#           return (Area () / d);
+#         }
+#     };
+# 
+#     class CoredPointIndex
+#     {
+#       public:
+#         int index;
+#         char inCore;
+# 
+#         int operator == (const CoredPointIndex& cpi) const {return (index==cpi.index) && (inCore==cpi.inCore);};
+#         int operator != (const CoredPointIndex& cpi) const {return (index!=cpi.index) || (inCore!=cpi.inCore);};
+#     };
+# 
+#     class EdgeIndex
+#     {
+#       public:
+#         int idx[2];
+#     };
+# 
+#     class CoredEdgeIndex
+#     {
+#       public:
+#         CoredPointIndex idx[2];
+#     };
+# 
+#     class TriangleIndex
+#     {
+#       public:
+#         int idx[3];
+#     };
+# 
+#     class TriangulationEdge
+#     {
+#       public:
+#         TriangulationEdge (void);
+#         int pIndex[2];
+#         int tIndex[2];
+#     };
+# 
+#     class TriangulationTriangle
+#     {
+#       public:
+#         TriangulationTriangle (void);
+#         int eIndex[3];
+#     };
+# 
+#     template<class Real>
+#     class Triangulation
+#     {
+#       public:
+#         Triangulation () : points (),  edges (),  triangles (),  edgeMap () {}
+# 
+#         std::vector<Point3D<Real> >        points;
+#         std::vector<TriangulationEdge>     edges;
+#         std::vector<TriangulationTriangle> triangles;
+# 
+#         int 
+#         factor (const int& tIndex, int& p1, int& p2, int& p3);
+#         
+#         double 
+#         area (void);
+# 
+#         double 
+#         area (const int& tIndex);
+# 
+#         double 
+#         area (const int& p1, const int& p2, const int& p3);
+# 
+#         int 
+#         flipMinimize (const int& eIndex);
+# 
+#         int 
+#         addTriangle (const int& p1, const int& p2, const int& p3);
+# 
+#       protected:
+#         hash_map<long long, int> edgeMap;
+#         static long long EdgeIndex (const int& p1, const int& p2);
+#         double area (const Triangle& t);
+#     };
+# 
+# 
+#     template<class Real> void 
+#     EdgeCollapse (const Real& edgeRatio,
+#                   std::vector<TriangleIndex>& triangles,
+#                   std::vector< Point3D<Real> >& positions,
+#                   std::vector<Point3D<Real> >* normals);
+#     
+#     template<class Real> void 
+#     TriangleCollapse (const Real& edgeRatio,
+#                       std::vector<TriangleIndex>& triangles,
+#                       std::vector<Point3D<Real> >& positions,
+#                       std::vector<Point3D<Real> >* normals);
+# 
+#     struct CoredVertexIndex
+#     {
+#       int idx;
+#       bool inCore;
+#     };
+# 
+#     class CoredMeshData
+#     {
+#       public:
+#         CoredMeshData () : inCorePoints () {}
+# 
+#         virtual ~CoredMeshData () {}
+# 
+#         std::vector<Point3D<float> > inCorePoints;
+#         
+#         virtual void 
+#         resetIterator () = 0;
+# 
+#         virtual int 
+#         addOutOfCorePoint (const Point3D<float>& p) = 0;
+# 
+#         virtual int 
+#         addPolygon (const std::vector< CoredVertexIndex >& vertices) = 0;
+# 
+#         virtual int 
+#         nextOutOfCorePoint (Point3D<float>& p) = 0;
+#         
+#         virtual int 
+#         nextPolygon (std::vector<CoredVertexIndex >& vertices) = 0;
+# 
+#         virtual int 
+#         outOfCorePointCount () = 0;
+#         
+#         virtual int 
+#         polygonCount () = 0;
+#     };
+# 
+#     class CoredVectorMeshData : public CoredMeshData
+#     {
+#       std::vector<Point3D<float> > oocPoints;
+#       std::vector< std::vector< int > > polygons;
+#       int polygonIndex;
+#       int oocPointIndex;
+# 
+#       public:
+#         CoredVectorMeshData ();
+#         
+#         virtual ~CoredVectorMeshData () {}
+# 
+#         void resetIterator (void);
+# 
+#         int addOutOfCorePoint (const Point3D<float>& p);
+#         int addPolygon (const std::vector< CoredVertexIndex >& vertices);
+# 
+#         int nextOutOfCorePoint (Point3D<float>& p);
+#         int nextPolygon (std::vector< CoredVertexIndex >& vertices);
+# 
+#         int outOfCorePointCount (void);
+#         int polygonCount (void);
+#     };
+# 
+#     class CoredFileMeshData : public CoredMeshData
+#     {
+#       FILE *oocPointFile ,  *polygonFile;
+#       int oocPoints ,  polygons;
+#       public:
+#         CoredFileMeshData ();
+#         virtual ~CoredFileMeshData ();
+# 
+#         void resetIterator (void);
+# 
+#         int addOutOfCorePoint (const Point3D<float>& p);
+#         int addPolygon (const std::vector< CoredVertexIndex >& vertices);
+# 
+#         int nextOutOfCorePoint (Point3D<float>& p);
+#         int nextPolygon (std::vector< CoredVertexIndex >& vertices);
+# 
+#         int outOfCorePointCount (void);
+#         int polygonCount (void);
+#     };
+#   }
+# 
+###
+
+# gp3.h
+# namespace pcl
+#   /** \brief Returns if a point X is visible from point R (or the origin)
+#     * when taking into account the segment between the points S1 and S2
+#     * \param X 2D coordinate of the point
+#     * \param S1 2D coordinate of the segment's first point
+#     * \param S2 2D coordinate of the segment's secont point
+#     * \param R 2D coorddinate of the reference point (defaults to 0,0)
+#     * \ingroup surface
+#     */
+#   inline bool 
+#   isVisible (const Eigen::Vector2f &X, const Eigen::Vector2f &S1, const Eigen::Vector2f &S2, 
+#              const Eigen::Vector2f &R = Eigen::Vector2f::Zero ())
+# 
+# /** \brief GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points
+#   * based on local 2D projections. It assumes locally smooth surfaces and relatively smooth transitions between
+#   * areas with different point densities.
+#   * \author Zoltan Csaba Marton
+#   * \ingroup surface
+#   */
+# template <typename PointInT>
+# class GreedyProjectionTriangulation : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/gp3.h" namespace "pcl::poisson":
+    cdef cppclass GreedyProjectionTriangulation[In](MeshConstruction[In]):
+        GreedyProjectionTriangulation()
+        # public:
+        # using MeshConstruction<PointInT>::tree_;
+        # using MeshConstruction<PointInT>::input_;
+        # using MeshConstruction<PointInT>::indices_;
+        # typedef typename pcl::KdTree<PointInT> KdTree;
+        # typedef typename pcl::KdTree<PointInT>::Ptr KdTreePtr;
+        # typedef pcl::PointCloud<PointInT> PointCloudIn;
+        # typedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # // FIXME this enum should have a type.  Not be anonymous. 
+        # // Otherplaces where consts are used probably should be fixed.
+        # enum 
+        # { 
+        #   NONE = -1,    // not-defined
+        #   FREE = 0,    
+        #   FRINGE = 1,  
+        #   BOUNDARY = 2,
+        #   COMPLETED = 3
+        # };
+        # 
+        # /** \brief Set the multiplier of the nearest neighbor distance to obtain the final search radius for each point
+        #  *  (this will make the algorithm adapt to different point densities in the cloud).
+        #  * \param[in] mu the multiplier
+        # inline void setMu (double mu)
+        # /** \brief Get the nearest neighbor distance multiplier. */
+        # inline double getMu ()
+        # /** \brief Set the maximum number of nearest neighbors to be searched for.
+        #   * \param[in] nnn the maximum number of nearest neighbors
+        # inline void setMaximumNearestNeighbors (int nnn)
+        # /** \brief Get the maximum number of nearest neighbors to be searched for. */
+        # inline int getMaximumNearestNeighbors ()
+        # /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors used for triangulating.
+        #   * \param[in] radius the sphere radius that is to contain all k-nearest neighbors
+        #   * \note This distance limits the maximum edge length!
+        # inline void setSearchRadius (double radius)
+        # /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+        # inline double getSearchRadius ()
+        # /** \brief Set the minimum angle each triangle should have.
+        #   * \param[in] minimum_angle the minimum angle each triangle should have
+        #   * \note As this is a greedy approach, this will have to be violated from time to time
+        # inline void setMinimumAngle (double minimum_angle)
+        # /** \brief Get the parameter for distance based weighting of neighbors. */
+        # inline double getMinimumAngle ()
+        # /** \brief Set the maximum angle each triangle can have.
+        #   * \param[in] maximum_angle the maximum angle each triangle can have
+        #   * \note For best results, its value should be around 120 degrees
+        # inline void setMaximumAngle (double maximum_angle)
+        # /** \brief Get the parameter for distance based weighting of neighbors. */
+        # inline double getMaximumAngle ()
+        # /** \brief Don't consider points for triangulation if their normal deviates more than this value from the query point's normal.
+        #   * \param[in] eps_angle maximum surface angle
+        #   * \note As normal estimation methods usually give smooth transitions at sharp edges, this ensures correct triangulation
+        #   *       by avoiding connecting points from one side to points from the other through forcing the use of the edge points.
+        # inline void setMaximumSurfaceAngle (double eps_angle)
+        # /** \brief Get the maximum surface angle. */
+        # inline double getMaximumSurfaceAngle ()
+        # /** \brief Set the flag if the input normals are oriented consistently.
+        #   * \param[in] consistent set it to true if the normals are consistently oriented
+        # inline void setNormalConsistency (bool consistent)
+        # /** \brief Get the flag for consistently oriented normals. */
+        # inline bool getNormalConsistency ()
+        # /** \brief Set the flag to order the resulting triangle vertices consistently (positive direction around normal).
+        #   * @note Assumes consistently oriented normals (towards the viewpoint) -- see setNormalConsistency ()
+        #   * \param[in] consistent_ordering set it to true if triangle vertices should be ordered consistently
+        # inline void setConsistentVertexOrdering (bool consistent_ordering)
+        # /** \brief Get the flag signaling consistently ordered triangle vertices. */
+        # inline bool getConsistentVertexOrdering ()
+        # /** \brief Get the state of each point after reconstruction.
+        #   * \note Options are defined as constants: FREE, FRINGE, COMPLETED, BOUNDARY and NONE
+        # inline std::vector<int> getPointStates ()
+        # /** \brief Get the ID of each point after reconstruction.
+        #   * \note parts are numbered from 0, a -1 denotes unconnected points
+        # inline std::vector<int> getPartIDs ()
+        # /** \brief Get the sfn list. */
+        # inline std::vector<int> getSFN ()
+        # /** \brief Get the ffn list. */
+        # inline std::vector<int> getFFN ()
+
+
+###
+
+# grid_projection.h
+# namespace pcl
+# {
+#   /** \brief The 12 edges of a cell. */
+#   const int I_SHIFT_EP[12][2] = {
+#     {0, 4}, {1, 5}, {2, 6}, {3, 7}, 
+#     {0, 1}, {1, 2}, {2, 3}, {3, 0},
+#     {4, 5}, {5, 6}, {6, 7}, {7, 4}
+#   };
+# 
+#   const int I_SHIFT_PT[4] = {
+#     0, 4, 5, 7
+#   };
+# 
+#   const int I_SHIFT_EDGE[3][2] = {
+#     {0,1}, {1,3}, {1,2}
+#   };
+###
+
+# grid_projection.h
+# namespace pcl
+
+# grid_projection.h
+# namespace pcl
+# /** \brief Grid projection surface reconstruction method.
+#   * \author Rosie Li
+#   *
+#   * \note If you use this code in any academic work, please cite:
+#   *   - Ruosi Li, Lu Liu, Ly Phan, Sasakthi Abeysinghe, Cindy Grimm, Tao Ju.
+#   *     Polygonizing extremal surfaces with manifold guarantees.
+#   *     In Proceedings of the 14th ACM Symposium on Solid and Physical Modeling, 2010.
+#    * \ingroup surface
+#   */
+# template <typename PointNT>
+# class GridProjection : public SurfaceReconstruction<PointNT>
+cdef extern from "pcl/surface/grid_projection.h" namespace "pcl":
+    cdef cppclass GridProjection[PointNT](SurfaceReconstruction[PointNT]):
+        GridProjection()
+        GridProjection (double in_resolution)
+        # public:
+        # using SurfaceReconstruction<PointNT>::input_;
+        # using SurfaceReconstruction<PointNT>::tree_;
+        # typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+        # typedef typename pcl::KdTree<PointNT> KdTree;
+        # typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+        # 
+        # /** \brief Data leaf. */
+        # struct Leaf
+        # {
+        #   Leaf () : data_indices (), pt_on_surface (), vect_at_grid_pt () {}
+        # 
+        #   std::vector<int> data_indices;
+        #   Eigen::Vector4f pt_on_surface; 
+        #   Eigen::Vector3f vect_at_grid_pt;
+        # };
+        # 
+        # typedef boost::unordered_map<int, Leaf, boost::hash<int>, std::equal_to<int>, Eigen::aligned_allocator<int> > HashMap;
+        # 
+        # /** \brief Constructor. */ 
+        # GridProjection ();
+        # 
+        # /** \brief Constructor. 
+        #   * \param in_resolution set the resolution of the grid
+        #   */ 
+        # GridProjection (double in_resolution);
+        # 
+        # /** \brief Destructor. */
+        # ~GridProjection ();
+        # 
+        
+        # /** \brief Set the size of the grid cell
+        #   * \param resolution  the size of the grid cell
+        #   */
+        # inline void setResolution (double resolution)
+        void setResolution (double resolution)
+        
+        # inline double getResolution () const
+        double getResolution ()
+        
+        # /** \brief When averaging the vectors, we find the union of all the input data 
+        #   *  points within the padding area,and do a weighted average. Say if the padding
+        #   *  size is 1, when we process cell (x,y,z), we will find union of input data points
+        #   *  from (x-1) to (x+1), (y-1) to (y+1), (z-1) to (z+1)(in total, 27 cells). In this
+        #   *  way, even the cells itself doesnt contain any data points, we will stil process it
+        #   *  because there are data points in the padding area. This can help us fix holes which 
+        #   *  is smaller than the padding size.
+        #   * \param padding_size The num of padding cells we want to create 
+        #   */
+        # inline void setPaddingSize (int padding_size)
+        void setPaddingSize (int padding_size)
+        
+        # inline int getPaddingSize () const
+        int getPaddingSize ()
+        
+        # /** \brief Set this only when using the k nearest neighbors search 
+        #   * instead of finding the point union
+        #   * \param k The number of nearest neighbors we are looking for
+        #   */
+        # inline void setNearestNeighborNum (int k)
+        void setNearestNeighborNum (int k)
+        
+        # inline int getNearestNeighborNum () const
+        int getNearestNeighborNum ()
+        
+        # /** \brief Binary search is used in projection. given a point x, we find another point
+        #   *  which is 3*cell_size_ far away from x. Then we do a binary search between these 
+        #   *  two points to find where the projected point should be.
+        #   */
+        # inline void setMaxBinarySearchLevel (int max_binary_search_level)
+        void setMaxBinarySearchLevel (int max_binary_search_level)
+        
+        # inline int getMaxBinarySearchLevel () const
+        int getMaxBinarySearchLevel () const
+        
+        # inline const HashMap& getCellHashMap () const
+        # 
+        # inline const std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> >& getVectorAtDataPoint () const
+        # 
+        # inline const std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& getSurface () const
+
+
+###
+
+# hash.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/hash.h (1.7.2)
+###
+
+# marching_cubes.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2)
+# 
+# namespace pcl
+# {
+#   /*
+#    * Tables, and functions, derived from Paul Bourke's Marching Cubes implementation:
+#    * http://paulbourke.net/geometry/polygonise/
+#    * Cube vertex indices:
+#    *   y_dir 4 ________ 5
+#    *         /|       /|
+#    *       /  |     /  |
+#    *   7 /_______ /    |
+#    *    |     |  |6    |
+#    *    |    0|__|_____|1 x_dir
+#    *    |    /   |    /
+#    *    |  /     |  /
+#    z_dir|/_______|/
+#    *   3          2
+#    */
+#   const unsigned int edgeTable[256] = {
+#     0x0  , 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
+#     0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
+#     0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
+#     0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
+#     0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c,
+#     0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
+#     0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac,
+#     0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
+#     0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c,
+#     0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
+#     0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc,
+#     0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
+#     0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c,
+#     0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
+#     0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc ,
+#     0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
+#     0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
+#     0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
+#     0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
+#     0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
+#     0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
+#     0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
+#     0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
+#     0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460,
+#     0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
+#     0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0,
+#     0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
+#     0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230,
+#     0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
+#     0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190,
+#     0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
+#     0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0
+#   };
+#   const int triTable[256][16] = {
+#     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+#     {8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
+#     {3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
+#     {4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+#     {4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
+#     {9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
+#     {10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
+#     {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+#     {5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
+#     {8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
+#     {2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+#     {2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
+#     {11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
+#     {5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
+#     {11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
+#     {11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
+#     {2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
+#     {6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+#     {3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
+#     {6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+#     {6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
+#     {8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
+#     {7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
+#     {3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+#     {0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
+#     {9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
+#     {8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+#     {5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
+#     {0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
+#     {6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
+#     {10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+#     {1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
+#     {0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
+#     {3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+#     {6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
+#     {9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
+#     {8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
+#     {3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
+#     {10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
+#     {10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+#     {2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
+#     {7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+#     {2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
+#     {1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
+#     {11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
+#     {8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
+#     {0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
+#     {7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
+#     {7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
+#     {10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
+#     {0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
+#     {7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
+#     {6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
+#     {4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
+#     {10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
+#     {8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
+#     {1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
+#     {10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
+#     {10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
+#     {9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
+#     {7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
+#     {3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
+#     {7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
+#     {3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
+#     {6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
+#     {9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
+#     {1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
+#     {4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
+#     {7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
+#     {6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
+#     {0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
+#     {6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
+#     {0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
+#     {11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
+#     {6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
+#     {5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
+#     {9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
+#     {1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
+#     {10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
+#     {0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
+#     {11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
+#     {9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
+#     {7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
+#     {2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
+#     {9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
+#     {9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
+#     {1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
+#     {0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
+#     {10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
+#     {2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
+#     {0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
+#     {0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
+#     {9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
+#     {5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
+#     {5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
+#     {8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
+#     {9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
+#     {1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
+#     {3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
+#     {4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
+#     {9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
+#     {11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
+#     {2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
+#     {9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
+#     {3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
+#     {1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
+#     {4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
+#     {0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
+#     {1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
+#   };
+# 
+# 
+#   /** \brief The marching cubes surface reconstruction algorithm. This is an abstract class that takes a grid and
+#     * extracts the isosurface as a mesh, based on the original marching cubes paper:
+#     *
+#     * Lorensen W.E., Cline H.E., "Marching cubes: A high resolution 3d surface construction algorithm",
+#     * SIGGRAPH '87
+#     *
+#     * \author Alexandru E. Ichim
+#     * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class MarchingCubes : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubes ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubes ();
+# 
+# 
+#       /** \brief Method that sets the iso level of the surface to be extracted.
+#         * \param[in] iso_level the iso level.
+#         */
+#       inline void
+#       setIsoLevel (float iso_level)
+#       { iso_level_ = iso_level; }
+# 
+#       /** \brief Method that returns the iso level of the surface to be extracted. */
+#       inline float
+#       getIsoLevel ()
+#       { return iso_level_; }
+# 
+#       /** \brief Method that sets the marching cubes grid resolution.
+#         * \param[in] res_x the resolution of the grid along the x-axis
+#         * \param[in] res_y the resolution of the grid along the y-axis
+#         * \param[in] res_z the resolution of the grid along the z-axis
+#         */
+#       inline void
+#       setGridResolution (int res_x, int res_y, int res_z)
+#       { res_x_ = res_x; res_y_ = res_y; res_z_ = res_z; }
+# 
+# 
+#       /** \brief Method to get the marching cubes grid resolution.
+#         * \param[in] res_x the resolution of the grid along the x-axis
+#         * \param[in] res_y the resolution of the grid along the y-axis
+#         * \param[in] res_z the resolution of the grid along the z-axis
+#         */
+#       inline void
+#       getGridResolution (int &res_x, int &res_y, int &res_z)
+#       { res_x = res_x_; res_y = res_y_; res_z = res_z_; }
+# 
+#       /** \brief Method that sets the parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits. Does not affect the resolution of the grid, it just
+#         * changes the voxel size accordingly.
+#         * \param[in] percentage the percentage of the bounding box that should be left empty between the bounding box and
+#         * the grid limits.
+#         */
+#       inline void
+#       setPercentageExtendGrid (float percentage)
+#       { percentage_extend_grid_ = percentage; }
+# 
+#       /** \brief Method that gets the parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits, as a percentage of the bounding box.
+#         */
+#       inline float
+#       getPercentageExtendGrid ()
+#       { return percentage_extend_grid_; }
+# 
+# protected:
+#       /** \brief The data structure storing the 3D grid */
+#       std::vector<float> grid_;
+# 
+#       /** \brief The grid resolution */
+#       int res_x_, res_y_, res_z_;
+# 
+#       /** \brief Parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits, as a percentage of the bounding box.*/
+#       float percentage_extend_grid_;
+# 
+#       /** \brief Min and max data points. */
+#       Eigen::Vector4f min_p_, max_p_;
+# 
+#       /** \brief The iso level to be extracted. */
+#       float iso_level_;
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       virtual void
+#       voxelizeData () = 0;
+# 
+#       /** \brief Interpolate along the voxel edge.
+#         * \param[in] p1 The first point on the edge
+#         * \param[in] p2 The second point on the edge
+#         * \param[in] val_p1 The scalar value at p1
+#         * \param[in] val_p2 The scalar value at p2
+#         * \param[out] output The interpolated point along the edge
+#         */
+#       void
+#       interpolateEdge (Eigen::Vector3f &p1, Eigen::Vector3f &p2, float val_p1, float val_p2, Eigen::Vector3f &output);
+# 
+# 
+#       /** \brief Calculate out the corresponding polygons in the leaf node
+#         * \param leaf_node the leaf node to be checked
+#         * \param index_3d the 3d index of the leaf node to be checked
+#         * \param cloud point cloud to store the vertices of the polygon
+#        */
+#       void
+#       createSurface (std::vector<float> &leaf_node,
+#                      Eigen::Vector3i &index_3d,
+#                      pcl::PointCloud<PointNT> &cloud);
+# 
+#       /** \brief Get the bounding box for the input data points. */
+#       void
+#       getBoundingBox ();
+# 
+# 
+#       /** \brief Method that returns the scalar value at the given grid position.
+#         * \param[in] pos The 3D position in the grid
+#         */
+#       float
+#       getGridValue (Eigen::Vector3i pos);
+# 
+#       /** \brief Method that returns the scalar values of the neighbors of a given 3D position in the grid.
+#         * \param[in] index3d the point in the grid
+#         * \param[out] leaf the set of values
+#         */
+#       void
+#       getNeighborList1D (std::vector<float> &leaf,
+#                          Eigen::Vector3i &index3d);
+# 
+#       /** \brief Class get name method. */
+#       std::string getClassName () const { return ("MarchingCubes"); }
+# 
+#       /** \brief Extract the surface.
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#        void
+#        performReconstruction (pcl::PolygonMesh &output);
+# 
+#        /** \brief Extract the surface.
+#          * \param[out] points the points of the extracted mesh
+#          * \param[out] polygons the connectivity between the point of the extracted mesh.
+#          */
+#        void
+#        performReconstruction (pcl::PointCloud<PointNT> &points,
+#                               std::vector<pcl::Vertices> &polygons);
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# marching_cubes_hoppe.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2) ?
+# namespace pcl
+# {
+#    /** \brief The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance
+#      * from tangent planes, proposed by Hoppe et. al. in:
+#      * Hoppe H., DeRose T., Duchamp T., MC-Donald J., Stuetzle W., "Surface reconstruction from unorganized points",
+#      * SIGGRAPH '92
+#      * \author Alexandru E. Ichim
+#      * \ingroup surface
+#      */
+#   template <typename PointNT>
+#   class MarchingCubesHoppe : public MarchingCubes<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+#       using MarchingCubes<PointNT>::grid_;
+#       using MarchingCubes<PointNT>::res_x_;
+#       using MarchingCubes<PointNT>::res_y_;
+#       using MarchingCubes<PointNT>::res_z_;
+#       using MarchingCubes<PointNT>::min_p_;
+#       using MarchingCubes<PointNT>::max_p_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubesHoppe ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubesHoppe ();
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       void
+#       voxelizeData ();
+# 
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# marching_cubes_poisson.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2)
+# namespace pcl {
+#   namespace poisson {
+# 
+# 
+#     class Square
+#     {
+#     public:
+#       const static int CORNERS = 4, EDGES = 4, NEIGHBORS = 4;
+#       static int  CornerIndex (const int& x, const int& y);
+#       static void FactorCornerIndex (const int& idx, int& x, int& y);
+#       static int  EdgeIndex (const int& orientation, const int& i);
+#       static void FactorEdgeIndex (const int& idx, int& orientation, int& i);
+# 
+#       static int  ReflectCornerIndex (const int& idx, const int& edgeIndex);
+#       static int  ReflectEdgeIndex (const int& idx, const int& edgeIndex);
+# 
+#       static void EdgeCorners (const int& idx, int& c1, int &c2);
+#     };
+# 
+#     class Cube{
+#     public:
+#       const static int CORNERS = 8, EDGES = 12, NEIGHBORS = 6;
+# 
+#       static int CornerIndex (const int& x, const int& y, const int& z);
+#       static void FactorCornerIndex (const int& idx, int& x, int& y, int& z);
+#       static int EdgeIndex (const int& orientation, const int& i, const int& j);
+#       static void FactorEdgeIndex (const int& idx, int& orientation, int& i, int &j);
+#       static int FaceIndex (const int& dir, const int& offSet);
+#       static int FaceIndex (const int& x, const int& y, const int& z);
+#       static void FactorFaceIndex (const int& idx, int& x, int &y, int& z);
+#       static void FactorFaceIndex (const int& idx, int& dir, int& offSet);
+# 
+#       static int AntipodalCornerIndex (const int& idx);
+#       static int FaceReflectCornerIndex (const int& idx, const int& faceIndex);
+#       static int FaceReflectEdgeIndex (const int& idx, const int& faceIndex);
+#       static int FaceReflectFaceIndex (const int& idx, const int& faceIndex);
+#       static int EdgeReflectCornerIndex   (const int& idx, const int& edgeIndex);
+#       static int EdgeReflectEdgeIndex (const int& edgeIndex);
+# 
+#       static int FaceAdjacentToEdges (const int& eIndex1, const int& eIndex2);
+#       static void FacesAdjacentToEdge (const int& eIndex, int& f1Index, int& f2Index);
+# 
+#       static void EdgeCorners (const int& idx, int& c1, int &c2);
+#       static void FaceCorners (const int& idx, int& c1, int &c2, int& c3, int& c4);
+#     };
+# 
+#     class MarchingSquares
+#     {
+#       static double Interpolate (const double& v1, const double& v2);
+#       static void SetVertex (const int& e, const double values[Square::CORNERS], const double& iso);
+#     public:
+#       const static int MAX_EDGES = 2;
+#       static const int edgeMask[1<<Square::CORNERS];
+#       static const int edges[1<<Square::CORNERS][2*MAX_EDGES+1];
+#       static double vertexList[Square::EDGES][2];
+# 
+#       static int GetIndex (const double values[Square::CORNERS], const double& iso);
+#       static int IsAmbiguous (const double v[Square::CORNERS] ,const double& isoValue);
+#       static int AddEdges (const double v[Square::CORNERS], const double& isoValue, Edge* edges);
+#       static int AddEdgeIndices (const double v[Square::CORNERS], const double& isoValue, int* edges);
+#     };
+# 
+#     class MarchingCubes
+#     {
+#       static double Interpolate (const double& v1, const double& v2);
+#       static void SetVertex (const int& e, const double values[Cube::CORNERS], const double& iso);
+#       static int GetFaceIndex (const double values[Cube::CORNERS], const double& iso, const int& faceIndex);
+# 
+#       static float Interpolate (const float& v1, const float& v2);
+#       static void SetVertex (const int& e, const float values[Cube::CORNERS], const float& iso);
+#       static int GetFaceIndex (const float values[Cube::CORNERS], const float& iso, const int& faceIndex);
+# 
+#       static int GetFaceIndex (const int& mcIndex, const int& faceIndex);
+#     public:
+#       const static int MAX_TRIANGLES=5;
+#       static const int edgeMask[1<<Cube::CORNERS];
+#       static const int triangles[1<<Cube::CORNERS][3*MAX_TRIANGLES+1];
+#       static const int cornerMap[Cube::CORNERS];
+#       static double vertexList[Cube::EDGES][3];
+# 
+#       static int AddTriangleIndices (const int& mcIndex, int* triangles);
+# 
+#       static int GetIndex (const double values[Cube::CORNERS],const double& iso);
+#       static int IsAmbiguous (const double v[Cube::CORNERS],const double& isoValue,const int& faceIndex);
+#       static int HasRoots (const double v[Cube::CORNERS],const double& isoValue);
+#       static int HasRoots (const double v[Cube::CORNERS],const double& isoValue,const int& faceIndex);
+#       static int AddTriangles (const double v[Cube::CORNERS],const double& isoValue,Triangle* triangles);
+#       static int AddTriangleIndices (const double v[Cube::CORNERS],const double& isoValue,int* triangles);
+# 
+#       static int GetIndex (const float values[Cube::CORNERS], const float& iso);
+#       static int IsAmbiguous (const float v[Cube::CORNERS], const float& isoValue, const int& faceIndex);
+#       static int HasRoots (const float v[Cube::CORNERS], const float& isoValue);
+#       static int HasRoots (const float v[Cube::CORNERS], const float& isoValue, const int& faceIndex);
+#       static int AddTriangles (const float v[Cube::CORNERS], const float& isoValue, Triangle* triangles);
+#       static int AddTriangleIndices (const float v[Cube::CORNERS], const float& isoValue, int* triangles);
+# 
+#       static int IsAmbiguous (const int& mcIndex, const int& faceIndex);
+#       static int HasRoots (const int& mcIndex);
+#       static int HasFaceRoots (const int& mcIndex, const int& faceIndex);
+#       static int HasEdgeRoots (const int& mcIndex, const int& edgeIndex);
+#     };
+# 
+# 
+###
+
+# marching_cubes_rbf.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2) ?
+# namespace pcl
+# {
+#   /** \brief The marching cubes surface reconstruction algorithm, using a signed distance function based on radial
+#     * basis functions. Partially based on:
+#     * Carr J.C., Beatson R.K., Cherrie J.B., Mitchell T.J., Fright W.R., McCallum B.C. and Evans T.R.,
+#     * "Reconstruction and representation of 3D objects with radial basis functions"
+#     * SIGGRAPH '01
+#     *
+#     * \author Alexandru E. Ichim
+#     * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class MarchingCubesRBF : public MarchingCubes<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+#       using MarchingCubes<PointNT>::grid_;
+#       using MarchingCubes<PointNT>::res_x_;
+#       using MarchingCubes<PointNT>::res_y_;
+#       using MarchingCubes<PointNT>::res_z_;
+#       using MarchingCubes<PointNT>::min_p_;
+#       using MarchingCubes<PointNT>::max_p_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubesRBF ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubesRBF ();
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       void
+#       voxelizeData ();
+# 
+# 
+#       /** \brief Set the off-surface points displacement value.
+#         * \param[in] epsilon the value
+#         */
+#       inline void
+#       setOffSurfaceDisplacement (float epsilon)
+#       { off_surface_epsilon_ = epsilon; }
+# 
+#       /** \brief Get the off-surface points displacement value. */
+#       inline float
+#       getOffSurfaceDisplacement ()
+#       { return off_surface_epsilon_; }
+# 
+# 
+#     protected:
+#       /** \brief the Radial Basis Function kernel. */
+#       double
+#       kernel (Eigen::Vector3d c, Eigen::Vector3d x);
+# 
+#       /** \brief The off-surface displacement value. */
+#       float off_surface_epsilon_;
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# }
+###
+
+# mls.h
+cdef extern from "pcl/surface/mls.h" namespace "pcl":
+    cdef cppclass MovingLeastSquares[I,O]:
+        MovingLeastSquares()
+        void setInputCloud (shared_ptr[cpp.PointCloud[I]])
+        void setSearchRadius (double)
+        void setComputeNormals (bool compute_normals)
+        void setPolynomialOrder(bool)
+        void setPolynomialFit(int)
+        # void process(cpp.PointCloud[O] &) except +
+        void process(cpp.PointCloud[O] &) except +
+        
+        # KdTree
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        pclkdt.KdTreePtr_t getSearchMethod ()
+
+ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointXYZ] MovingLeastSquares_t
+ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointXYZI] MovingLeastSquares_PointXYZI_t
+ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointXYZRGB] MovingLeastSquares_PointXYZRGB_t
+ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointXYZRGBA] MovingLeastSquares_PointXYZRGBA_t
+# NG
+# ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointNormal] MovingLeastSquares_t
+# ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointNormal] MovingLeastSquares_PointXYZI_t
+# ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointNormal] MovingLeastSquares_PointXYZRGB_t
+# ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointNormal] MovingLeastSquares_PointXYZRGBA_t
+
+
+# namespace pcl
+# {
+#   /** \brief MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm 
+#     * for data smoothing and improved normal estimation. It also contains methods for upsampling the 
+#     * resulting cloud based on the parametric fit.
+#     * Reference paper: "Computing and Rendering Point Set Surfaces" by Marc Alexa, Johannes Behr, 
+#     * Daniel Cohen-Or, Shachar Fleishman, David Levin and Claudio T. Silva
+#     * www.sci.utah.edu/~shachar/Publications/crpss.pdf
+#     * \author Zoltan Csaba Marton, Radu B. Rusu, Alexandru E. Ichim, Suat Gedikli
+#     * \ingroup surface
+#     */
+#   template <typename PointInT, typename PointOutT>
+#   class MovingLeastSquares: public CloudSurfaceProcessing<PointInT, PointOutT>
+#   {
+#     public:
+#       using PCLBase<PointInT>::input_;
+#       using PCLBase<PointInT>::indices_;
+#       using PCLBase<PointInT>::fake_indices_;
+#       using PCLBase<PointInT>::initCompute;
+#       using PCLBase<PointInT>::deinitCompute;
+# 
+#       typedef typename pcl::search::Search<PointInT> KdTree;
+#       typedef typename pcl::search::Search<PointInT>::Ptr KdTreePtr;
+#       typedef pcl::PointCloud<pcl::Normal> NormalCloud;
+#       typedef pcl::PointCloud<pcl::Normal>::Ptr NormalCloudPtr;
+# 
+#       typedef pcl::PointCloud<PointOutT> PointCloudOut;
+#       typedef typename PointCloudOut::Ptr PointCloudOutPtr;
+#       typedef typename PointCloudOut::ConstPtr PointCloudOutConstPtr;
+# 
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       typedef typename PointCloudIn::Ptr PointCloudInPtr;
+#       typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+# 
+#       typedef boost::function<int (int, double, std::vector<int> &, std::vector<float> &)> SearchMethod;
+# 
+#       enum UpsamplingMethod { NONE, SAMPLE_LOCAL_PLANE, RANDOM_UNIFORM_DENSITY, VOXEL_GRID_DILATION };
+# 
+#       /** \brief Empty constructor. */
+#       MovingLeastSquares () : CloudSurfaceProcessing<PointInT, PointOutT> (),
+#                               normals_ (),
+#                               search_method_ (),
+#                               tree_ (),
+#                               order_ (2),
+#                               polynomial_fit_ (true),
+#                               search_radius_ (0.0),
+#                               sqr_gauss_param_ (0.0),
+#                               compute_normals_ (false),
+#                               upsample_method_ (NONE),
+#                               upsampling_radius_ (0.0),
+#                               upsampling_step_ (0.0),
+#                               rng_uniform_distribution_ (),
+#                               desired_num_points_in_radius_ (0),
+#                               mls_results_ (),
+#                               voxel_size_ (1.0),
+#                               dilation_iteration_num_ (0),
+#                               nr_coeff_ ()
+#                               {};
+# 
+# 
+#       /** \brief Set whether the algorithm should also store the normals computed
+#         * \note This is optional, but need a proper output cloud type
+#         */
+#       inline void
+#       setComputeNormals (bool compute_normals) { compute_normals_ = compute_normals; }
+# 
+#       /** \brief Provide a pointer to the search object.
+#         * \param[in] tree a pointer to the spatial search object.
+#         */
+#       inline void
+#       setSearchMethod (const KdTreePtr &tree)
+#       {
+#         tree_ = tree;
+#         // Declare the search locator definition
+#         int (KdTree::*radiusSearch)(int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn) const = &KdTree::radiusSearch;
+#         search_method_ = boost::bind (radiusSearch, boost::ref (tree_), _1, _2, _3, _4, 0);
+#       }
+# 
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr 
+#       getSearchMethod () { return (tree_); }
+# 
+#       /** \brief Set the order of the polynomial to be fit.
+#         * \param[in] order the order of the polynomial
+#         */
+#       inline void 
+#       setPolynomialOrder (int order) { order_ = order; }
+# 
+#       /** \brief Get the order of the polynomial to be fit. */
+#       inline int 
+#       getPolynomialOrder () { return (order_); }
+# 
+#       /** \brief Sets whether the surface and normal are approximated using a polynomial, or only via tangent estimation.
+#         * \param[in] polynomial_fit set to true for polynomial fit
+#         */
+#       inline void 
+#       setPolynomialFit (bool polynomial_fit) { polynomial_fit_ = polynomial_fit; }
+# 
+#       /** \brief Get the polynomial_fit value (true if the surface and normal are approximated using a polynomial). */
+#       inline bool 
+#       getPolynomialFit () { return (polynomial_fit_); }
+# 
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+#         * \param[in] radius the sphere radius that is to contain all k-nearest neighbors
+#         * \note Calling this method resets the squared Gaussian parameter to radius * radius !
+#         */
+#       inline void 
+#       setSearchRadius (double radius) { search_radius_ = radius; sqr_gauss_param_ = search_radius_ * search_radius_; }
+# 
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       inline double 
+#       getSearchRadius () { return (search_radius_); }
+# 
+#       /** \brief Set the parameter used for distance based weighting of neighbors (the square of the search radius works
+#         * best in general).
+#         * \param[in] sqr_gauss_param the squared Gaussian parameter
+#         */
+#       inline void 
+#       setSqrGaussParam (double sqr_gauss_param) { sqr_gauss_param_ = sqr_gauss_param; }
+# 
+#       /** \brief Get the parameter for distance based weighting of neighbors. */
+#       inline double 
+#       getSqrGaussParam () const { return (sqr_gauss_param_); }
+# 
+#       /** \brief Set the upsampling method to be used
+#         * \note Options are: * NONE - no upsampling will be done, only the input points will be projected to their own
+#         *                             MLS surfaces
+#         *                    * SAMPLE_LOCAL_PLANE - the local plane of each input point will be sampled in a circular
+#         *                                           fashion using the \ref upsampling_radius_ and the \ref upsampling_step_
+#         *                                           parameters
+#         *                    * RANDOM_UNIFORM_DENSITY - the local plane of each input point will be sampled using an
+#         *                                               uniform random distribution such that the density of points is
+#         *                                               constant throughout the cloud - given by the \ref \ref desired_num_points_in_radius_
+#         *                                               parameter
+#         *                    * VOXEL_GRID_DILATION - the input cloud will be inserted into a voxel grid with voxels of
+#         *                                            size \ref voxel_size_; this voxel grid will be dilated \ref dilation_iteration_num_
+#         *                                            times and the resulting points will be projected to the MLS surface
+#         *                                            of the closest point in the input cloud; the result is a point cloud
+#         *                                            with filled holes and a constant point density
+#         */
+#       inline void
+#       setUpsamplingMethod (UpsamplingMethod method) { upsample_method_ = method; }
+# 
+# 
+#       /** \brief Set the radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         * \param[in] radius the radius of the circle
+#         */
+#       inline void
+#       setUpsamplingRadius (double radius) { upsampling_radius_ = radius; }
+# 
+#       /** \brief Get the radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       inline double
+#       getUpsamplingRadius () { return upsampling_radius_; }
+# 
+#       /** \brief Set the step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         * \param[in] step_size the step size
+#         */
+#       inline void
+#       setUpsamplingStepSize (double step_size) { upsampling_step_ = step_size; }
+# 
+# 
+#       /** \brief Get the step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       inline double
+#       getUpsamplingStepSize () { return upsampling_step_; }
+# 
+#       /** \brief Set the parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         * \param[in] desired_num_points_in_radius the desired number of points in the output cloud in a sphere of
+#         * radius \ref search_radius_ around each point
+#         */
+#       inline void
+#       setPointDensity (int desired_num_points_in_radius) { desired_num_points_in_radius_ = desired_num_points_in_radius; }
+# 
+# 
+#       /** \brief Get the parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       inline int
+#       getPointDensity () { return desired_num_points_in_radius_; }
+# 
+#       /** \brief Set the voxel size for the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         * \param[in] voxel_size the edge length of a cubic voxel in the voxel grid
+#         */
+#       inline void
+#       setDilationVoxelSize (float voxel_size) { voxel_size_ = voxel_size; }
+# 
+# 
+#       /** \brief Get the voxel size for the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         */
+#       inline float
+#       getDilationVoxelSize () { return voxel_size_; }
+# 
+#       /** \brief Set the number of dilation steps of the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         * \param[in] iterations the number of dilation iterations
+#         */
+#       inline void
+#       setDilationIterations (int iterations) { dilation_iteration_num_ = iterations; }
+# 
+#       /** \brief Get the number of dilation steps of the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         */
+#       inline int
+#       getDilationIterations () { return dilation_iteration_num_; }
+# 
+#       /** \brief Base method for surface reconstruction for all points given in <setInputCloud (), setIndices ()>
+#         * \param[out] output the resultant reconstructed surface model
+#         */
+#       void 
+#       process (PointCloudOut &output);
+# 
+#     protected:
+#       /** \brief The point cloud that will hold the estimated normals, if set. */
+#       NormalCloudPtr normals_;
+# 
+#       /** \brief The search method template for indices. */
+#       SearchMethod search_method_;
+# 
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+# 
+#       /** \brief The order of the polynomial to be fit. */
+#       int order_;
+# 
+#       /** True if the surface and normal be approximated using a polynomial, false if tangent estimation is sufficient. */
+#       bool polynomial_fit_;
+# 
+#       /** \brief The nearest neighbors search radius for each point. */
+#       double search_radius_;
+# 
+#       /** \brief Parameter for distance based weighting of neighbors (search_radius_ * search_radius_ works fine) */
+#       double sqr_gauss_param_;
+# 
+#       /** \brief Parameter that specifies whether the normals should be computed for the input cloud or not */
+#       bool compute_normals_;
+# 
+#       /** \brief Parameter that specifies the upsampling method to be used */
+#       UpsamplingMethod upsample_method_;
+# 
+#       /** \brief Radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       double upsampling_radius_;
+# 
+#       /** \brief Step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       double upsampling_step_;
+# 
+#       /** \brief Random number generator using an uniform distribution of floats
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       boost::variate_generator<boost::mt19937, boost::uniform_real<float> > *rng_uniform_distribution_;
+# 
+#       /** \brief Parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       int desired_num_points_in_radius_;
+# 
+#       
+#       /** \brief Data structure used to store the results of the MLS fitting
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       struct MLSResult
+#       {
+#         MLSResult () : plane_normal (), u (), v (), c_vec (), num_neighbors (), curvature (), valid (false) {}
+# 
+#         MLSResult (Eigen::Vector3d &a_plane_normal,
+#                    Eigen::Vector3d &a_u,
+#                    Eigen::Vector3d &a_v,
+#                    Eigen::VectorXd a_c_vec,
+#                    int a_num_neighbors,
+#                    float &a_curvature);
+# 
+#         Eigen::Vector3d plane_normal, u, v;
+#         Eigen::VectorXd c_vec;
+#         int num_neighbors;
+#         float curvature;
+#         bool valid;
+#       };
+# 
+#       /** \brief Stores the MLS result for each point in the input cloud
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       std::vector<MLSResult> mls_results_;
+# 
+#       
+#       /** \brief A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       class MLSVoxelGrid
+#       {
+#         public:
+#           struct Leaf { Leaf () : valid (true) {} bool valid; };
+# 
+#           MLSVoxelGrid (PointCloudInConstPtr& cloud,
+#                         IndicesPtr &indices,
+#                         float voxel_size);
+# 
+#           void
+#           dilate ();
+# 
+#           inline void
+#           getIndexIn1D (const Eigen::Vector3i &index, uint64_t &index_1d) const
+#           {
+#             index_1d = index[0] * data_size_ * data_size_ +
+#                        index[1] * data_size_ + index[2];
+#           }
+# 
+#           inline void
+#           getIndexIn3D (uint64_t index_1d, Eigen::Vector3i& index_3d) const
+#           {
+#             index_3d[0] = static_cast<Eigen::Vector3i::Scalar> (index_1d / (data_size_ * data_size_));
+#             index_1d -= index_3d[0] * data_size_ * data_size_;
+#             index_3d[1] = static_cast<Eigen::Vector3i::Scalar> (index_1d / data_size_);
+#             index_1d -= index_3d[1] * data_size_;
+#             index_3d[2] = static_cast<Eigen::Vector3i::Scalar> (index_1d);
+#           }
+# 
+#           inline void
+#           getCellIndex (const Eigen::Vector3f &p, Eigen::Vector3i& index) const
+#           {
+#             for (int i = 0; i < 3; ++i)
+#               index[i] = static_cast<Eigen::Vector3i::Scalar> ((p[i] - bounding_min_(i)) / voxel_size_);
+#           }
+# 
+#           inline void
+#           getPosition (const uint64_t &index_1d, Eigen::Vector3f &point) const
+#           {
+#             Eigen::Vector3i index_3d;
+#             getIndexIn3D (index_1d, index_3d);
+#             for (int i = 0; i < 3; ++i)
+#               point[i] = static_cast<Eigen::Vector3f::Scalar> (index_3d[i]) * voxel_size_ + bounding_min_[i];
+#           }
+# 
+#           typedef std::map<uint64_t, Leaf> HashMap;
+#           HashMap voxel_grid_;
+#           Eigen::Vector4f bounding_min_, bounding_max_;
+#           uint64_t data_size_;
+#           float voxel_size_;
+#       };
+# 
+# 
+#       /** \brief Voxel size for the VOXEL_GRID_DILATION upsampling method */
+#       float voxel_size_;
+# 
+#       /** \brief Number of dilation steps for the VOXEL_GRID_DILATION upsampling method */
+#       int dilation_iteration_num_; 
+# 
+#       /** \brief Number of coefficients, to be computed from the requested order.*/
+#       int nr_coeff_;
+# 
+#       /** \brief Search for the closest nearest neighbors of a given point using a radius search
+#         * \param[in] index the index of the query point
+#         * \param[out] indices the resultant vector of indices representing the k-nearest neighbors
+#         * \param[out] sqr_distances the resultant squared distances from the query point to the k-nearest neighbors
+#         */
+#       inline int
+#       searchForNeighbors (int index, std::vector<int> &indices, std::vector<float> &sqr_distances)
+#       {
+#         return (search_method_ (index, search_radius_, indices, sqr_distances));
+#       }
+# 
+#       /** \brief Smooth a given point and its neighborghood using Moving Least Squares.
+#         * \param[in] index the inex of the query point in the \ref input cloud
+#         * \param[in] input the input point cloud that \ref nn_indices refer to
+#         * \param[in] nn_indices the set of nearest neighbors indices for \ref pt
+#         * \param[in] nn_sqr_dists the set of nearest neighbors squared distances for \ref pt
+#         * \param[out] projected_points the set of points projected points around the query point
+#         * (in the case of upsampling method NONE, only the query point projected to its own fitted surface will be returned,
+#         * in the case of the other upsampling methods, multiple points will be returned)
+#         * \param[out] projected_points_normals the normals corresponding to the projected points
+#         */
+#       void
+#       computeMLSPointNormal (int index,
+#                              const PointCloudIn &input,
+#                              const std::vector<int> &nn_indices,
+#                              std::vector<float> &nn_sqr_dists,
+#                              PointCloudOut &projected_points,
+#                              NormalCloud &projected_points_normals);
+# 
+#       /** \brief Fits a point (sample point) given in the local plane coordinates of an input point (query point) to
+#         * the MLS surface of the input point
+#         * \param[in] u_disp the u coordinate of the sample point in the local plane of the query point
+#         * \param[in] v_disp the v coordinate of the sample point in the local plane of the query point
+#         * \param[in] u the axis corresponding to the u-coordinates of the local plane of the query point
+#         * \param[in] v the axis corresponding to the v-coordinates of the local plane of the query point
+#         * \param[in] plane_normal the normal to the local plane of the query point
+#         * \param[in] curvature the curvature of the surface at the query point
+#         * \param[in] query_point the absolute 3D position of the query point
+#         * \param[in] c_vec the coefficients of the polynomial fit on the MLS surface of the query point
+#         * \param[in] num_neighbors the number of neighbors of the query point in the input cloud
+#         * \param[out] result_point the absolute 3D position of the resulting projected point
+#         * \param[out] result_normal the normal of the resulting projected point
+#         */
+#       void
+#       projectPointToMLSSurface (float &u_disp, float &v_disp,
+#                                 Eigen::Vector3d &u, Eigen::Vector3d &v,
+#                                 Eigen::Vector3d &plane_normal,
+#                                 float &curvature,
+#                                 Eigen::Vector3f &query_point,
+#                                 Eigen::VectorXd &c_vec,
+#                                 int num_neighbors,
+#                                 PointOutT &result_point,
+#                                 pcl::Normal &result_normal);
+#     public:
+#         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# mls_omp.h
+# namespace pcl
+# {
+#   /** \brief MovingLeastSquaresOMP represent an OpenMP implementation of the MLS (Moving Least Squares) algorithm for 
+#     * data smoothing and improved normal estimation.
+#     * \author Radu B. Rusu
+#     * \ingroup surface
+#     */
+#   template <typename PointInT, typename PointOutT>
+#   class MovingLeastSquaresOMP : public MovingLeastSquares<PointInT, PointOutT>
+#   {
+#     using MovingLeastSquares<PointInT, PointOutT>::input_;
+#     using MovingLeastSquares<PointInT, PointOutT>::indices_;
+#     using MovingLeastSquares<PointInT, PointOutT>::fake_indices_;
+#     using MovingLeastSquares<PointInT, PointOutT>::initCompute;
+#     using MovingLeastSquares<PointInT, PointOutT>::deinitCompute;
+#     using MovingLeastSquares<PointInT, PointOutT>::nr_coeff_;
+#     using MovingLeastSquares<PointInT, PointOutT>::order_;
+#     using MovingLeastSquares<PointInT, PointOutT>::normals_;
+#     using MovingLeastSquares<PointInT, PointOutT>::upsample_method_;
+#     using MovingLeastSquares<PointInT, PointOutT>::voxel_size_;
+#     using MovingLeastSquares<PointInT, PointOutT>::dilation_iteration_num_;
+#     using MovingLeastSquares<PointInT, PointOutT>::tree_;
+#     using MovingLeastSquares<PointInT, PointOutT>::mls_results_;
+#     using MovingLeastSquares<PointInT, PointOutT>::search_radius_;
+#     using MovingLeastSquares<PointInT, PointOutT>::compute_normals_;
+#     using MovingLeastSquares<PointInT, PointOutT>::searchForNeighbors;
+#       
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::NormalCloud NormalCloud;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::MLSVoxelGrid MLSVoxelGrid;
+# 
+#     public:
+#       /** \brief Empty constructor. */
+#       MovingLeastSquaresOMP () : threads_ (1)
+#       {};
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       MovingLeastSquaresOMP (unsigned int nr_threads) : threads_ (0)
+#       {
+#         setNumberOfThreads (nr_threads);
+#       }
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void 
+#       setNumberOfThreads (unsigned int nr_threads)
+#       { 
+#         if (nr_threads == 0)
+#           nr_threads = 1;
+#         threads_ = nr_threads; 
+#       }
+# 
+###
+
+# multi_grid_octree_data.h
+# pcl/surface/3rdparty/poisson4/multi_grid_octree_data.h (1.7.2)
+# namespace pcl 
+# {
+#   namespace poisson 
+#   {
+#     typedef float Real;
+#     typedef float FunctionDataReal;
+#     typedef OctNode<class TreeNodeData,Real> TreeOctNode;
+# 
+#     class RootInfo
+#     {
+#       public:
+#         const TreeOctNode* node;
+#         int edgeIndex;
+#         long long key;
+#     };
+# 
+#     class VertexData
+#     {
+#       public:
+#         static long long 
+#         EdgeIndex (const TreeOctNode* node, const int& eIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         EdgeIndex (const TreeOctNode* node, const int& eIndex, const int& maxDepth);
+# 
+#         static long long 
+#         FaceIndex (const TreeOctNode* node, const int& fIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         FaceIndex (const TreeOctNode* node, const int& fIndex, const int& maxDepth);
+# 
+#         static long long 
+#         CornerIndex (const int& depth, const int offSet[DIMENSION] ,const int& cIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CornerIndex (const TreeOctNode* node, const int& cIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CornerIndex (const TreeOctNode* node, const int& cIndex, const int& maxDepth);
+# 
+#         static long long 
+#         CenterIndex (const int& depth, const int offSet[DIMENSION], const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CenterIndex (const TreeOctNode* node, const int& maxDepth, int index[DIMENSION]);
+#         
+#         static long long 
+#         CenterIndex (const TreeOctNode* node, const int& maxDepth);
+#     };
+# 
+#     class SortedTreeNodes
+#     {
+#       public:
+#         TreeOctNode** treeNodes;
+#         int *nodeCount;
+#         int maxDepth;
+#         SortedTreeNodes ();
+#         ~SortedTreeNodes ();
+#         void 
+#         set (TreeOctNode& root,const int& setIndex);
+#     };
+# 
+#     class TreeNodeData
+#     {
+#       public:
+#         static int UseIndex;
+#         union
+#         {
+#           int mcIndex;
+#           struct
+#           {
+#             int nodeIndex;
+#             Real centerWeightContribution;
+#           };
+#         };
+#         Real value;
+# 
+#         TreeNodeData (void);
+#         ~TreeNodeData (void);
+#     };
+# 
+#     template<int Degree>
+#     class Octree
+#     {
+#       TreeOctNode::NeighborKey neighborKey;
+#       TreeOctNode::NeighborKey2 neighborKey2;
+# 
+#       Real radius;
+#       int width;
+# 
+#       void 
+#       setNodeIndices (TreeOctNode& tree,int& idx);
+#       
+#       Real 
+#       GetDotProduct (const int index[DIMENSION]) const;
+# 
+#       Real 
+#       GetLaplacian (const int index[DIMENSION]) const;
+# 
+#       Real 
+#       GetDivergence (const int index[DIMENSION], const Point3D<Real>& normal) const;
+# 
+#       class DivergenceFunction
+#       {
+#         public:
+#           Point3D<Real> normal;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+# 
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class LaplacianProjectionFunction
+#       {
+#         public:
+#           double value;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+# 
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class LaplacianMatrixFunction
+#       {
+#         public:
+#           int x2,y2,z2,d2;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+#           int elementCount,offset;
+#           MatrixEntry<float>* rowElements;
+# 
+#           int 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class RestrictedLaplacianMatrixFunction
+#       {
+#         public:
+#           int depth,offset[3];
+#           Octree<Degree>* ot;
+#           Real radius;
+#           int index[DIMENSION], scratch[DIMENSION];
+#           int elementCount;
+#           MatrixEntry<float>* rowElements;
+# 
+#           int 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       ///////////////////////////
+#       // Evaluation Functions  //
+#       ///////////////////////////
+#       class PointIndexValueFunction
+#       {
+#         public:
+#           int res2;
+#           FunctionDataReal* valueTables;
+#           int index[DIMENSION];
+#           Real value;
+# 
+#           void 
+#           Function (const TreeOctNode* node);
+#       };
+# 
+#       class PointIndexValueAndNormalFunction
+#       {
+#         public:
+#           int res2;
+#           FunctionDataReal* valueTables;
+#           FunctionDataReal* dValueTables;
+#           Real value;
+#           Point3D<Real> normal;
+#           int index[DIMENSION];
+# 
+#           void 
+#           Function (const TreeOctNode* node);
+#       };
+# 
+#       class AdjacencyCountFunction
+#       {
+#         public:
+#           int adjacencyCount;
+# 
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class AdjacencySetFunction
+#       {
+#         public:
+#           int *adjacencies,adjacencyCount;
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class RefineFunction
+#       {
+#         public:
+#           int depth;
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class FaceEdgesFunction 
+#       {
+#         public:
+#           int fIndex,maxDepth;
+#           std::vector<std::pair<long long,long long> >* edges;
+#           hash_map<long long, std::pair<RootInfo,int> >* vertexCount;
+# 
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       int 
+#       SolveFixedDepthMatrix (const int& depth, const SortedTreeNodes& sNodes);
+#       
+#       int 
+#       SolveFixedDepthMatrix (const int& depth, const int& startingDepth, const SortedTreeNodes& sNodes);
+# 
+#       int 
+#       GetFixedDepthLaplacian (SparseSymmetricMatrix<float>& matrix, const int& depth, const SortedTreeNodes& sNodes);
+# 
+#       int 
+#       GetRestrictedFixedDepthLaplacian (SparseSymmetricMatrix<float>& matrix,
+#                                         const int& depth,
+#                                         const int* entries,
+#                                         const int& entryCount,
+#                                         const TreeOctNode* rNode,
+#                                         const Real& radius,
+#                                         const SortedTreeNodes& sNodes);
+# 
+#       void 
+#       SetIsoSurfaceCorners (const Real& isoValue, const int& subdivisionDepth, const int& fullDepthIso);
+# 
+#       static int 
+#       IsBoundaryFace (const TreeOctNode* node, const int& faceIndex, const int& subdivideDepth);
+#       
+#       static int 
+#       IsBoundaryEdge (const TreeOctNode* node, const int& edgeIndex, const int& subdivideDepth);
+#       
+#       static int 
+#       IsBoundaryEdge (const TreeOctNode* node, const int& dir, const int& x, const int& y, const int& subidivideDepth);
+#       
+#       void 
+#       PreValidate (const Real& isoValue, const int& maxDepth, const int& subdivideDepth);
+#       
+#       void 
+#       PreValidate (TreeOctNode* node, const Real& isoValue, const int& maxDepth, const int& subdivideDepth);
+#       
+#       void 
+#       Validate (TreeOctNode* node,
+#                 const Real& isoValue,
+#                 const int& maxDepth,
+#                 const int& fullDepthIso,
+#                 const int& subdivideDepth);
+# 
+#       void 
+#       Validate (TreeOctNode* node, const Real& isoValue, const int& maxDepth, const int& fullDepthIso);
+# 
+#       void 
+#       Subdivide (TreeOctNode* node, const Real& isoValue, const int& maxDepth);
+# 
+#       int 
+#       SetBoundaryMCRootPositions (const int& sDepth,const Real& isoValue,
+#                                   hash_map<long long,int>& boundaryRoots,
+#                                   hash_map<long long,
+#                                   std::pair<Real,Point3D<Real> > >& boundaryNormalHash,
+#                                   CoredMeshData* mesh,
+#                                   const int& nonLinearFit);
+# 
+#       int 
+#       SetMCRootPositions (TreeOctNode* node,
+#                           const int& sDepth,
+#                           const Real& isoValue,
+#                           hash_map<long long, int>& boundaryRoots,
+#                           hash_map<long long, int>* interiorRoots,
+#                           hash_map<long long, std::pair<Real,Point3D<Real> > >& boundaryNormalHash,
+#                           hash_map<long long, std::pair<Real,Point3D<Real> > >* interiorNormalHash,
+#                           std::vector<Point3D<float> >* interiorPositions,
+#                           CoredMeshData* mesh,
+#                           const int& nonLinearFit);
+# 
+#       int 
+#       GetMCIsoTriangles (TreeOctNode* node,
+#                          CoredMeshData* mesh,
+#                          hash_map<long long,int>& boundaryRoots,
+#                          hash_map<long long,int>* interiorRoots,
+#                          std::vector<Point3D<float> >* interiorPositions,
+#                          const int& offSet,
+#                          const int& sDepth, 
+#                          bool addBarycenter, 
+#                          bool polygonMesh);
+# 
+#       static int 
+#       AddTriangles (CoredMeshData* mesh,
+#                     std::vector<CoredPointIndex> edges[3],
+#                     std::vector<Point3D<float> >* interiorPositions, 
+#                     const int& offSet);
+#       
+#       static int 
+#       AddTriangles (CoredMeshData* mesh, 
+#                     std::vector<CoredPointIndex>& edges, std::vector<Point3D<float> >* interiorPositions, 
+#                     const int& offSet, 
+#                     bool addBarycenter, 
+#                     bool polygonMesh);
+# 
+#       void 
+#       GetMCIsoEdges (TreeOctNode* node,
+#                      hash_map<long long,int>& boundaryRoots,
+#                      hash_map<long long,int>* interiorRoots,
+#                      const int& sDepth,
+#                      std::vector<std::pair<long long,long long> >& edges);
+# 
+#       static int 
+#       GetEdgeLoops (std::vector<std::pair<long long,long long> >& edges,
+#                     std::vector<std::vector<std::pair<long long,long long> > >& loops);
+# 
+#       static int 
+#       InteriorFaceRootCount (const TreeOctNode* node,const int &faceIndex,const int& maxDepth);
+# 
+#       static int 
+#       EdgeRootCount (const TreeOctNode* node,const int& edgeIndex,const int& maxDepth);
+# 
+#       int 
+#       GetRoot (const RootInfo& ri,
+#                const Real& isoValue,
+#                const int& maxDepth,Point3D<Real> & position,
+#                hash_map<long long,std::pair<Real,Point3D<Real> > >& normalHash,
+#                Point3D<Real>* normal,
+#                const int& nonLinearFit);
+# 
+#       int 
+#       GetRoot (const RootInfo& ri,
+#                const Real& isoValue,
+#                Point3D<Real> & position,
+#                hash_map<long long,
+#                std::pair<Real,Point3D<Real> > >& normalHash,
+#                const int& nonLinearFit);
+# 
+#       static int 
+#       GetRootIndex (const TreeOctNode* node,const int& edgeIndex,const int& maxDepth,RootInfo& ri);
+# 
+#       static int 
+#       GetRootIndex (const TreeOctNode* node, 
+#                     const int& edgeIndex,
+#                     const int& maxDepth,
+#                     const int& sDepth,
+#                     RootInfo& ri);
+#       
+#       static int 
+#       GetRootIndex (const long long& key,
+#                     hash_map<long long,int>& boundaryRoots,
+#                     hash_map<long long,int>* interiorRoots,
+#                     CoredPointIndex& index);
+#       
+#       static int 
+#       GetRootPair (const RootInfo& root,const int& maxDepth,RootInfo& pair);
+# 
+#       int 
+#       NonLinearUpdateWeightContribution (TreeOctNode* node,
+#                                          const Point3D<Real>& position,
+#                                          const Real& weight = Real(1.0));
+# 
+#       Real 
+#       NonLinearGetSampleWeight (TreeOctNode* node,
+#                                 const Point3D<Real>& position);
+#       
+#       void 
+#       NonLinearGetSampleDepthAndWeight (TreeOctNode* node,
+#                                         const Point3D<Real>& position,
+#                                         const Real& samplesPerNode,
+#                                         Real& depth,
+#                                         Real& weight);
+# 
+#       int 
+#       NonLinearSplatOrientedPoint (TreeOctNode* node,
+#                                    const Point3D<Real>& point,
+#                                    const Point3D<Real>& normal);
+#       
+#       void 
+#       NonLinearSplatOrientedPoint (const Point3D<Real>& point,
+#                                    const Point3D<Real>& normal,
+#                                    const int& kernelDepth,
+#                                    const Real& samplesPerNode,
+#                                    const int& minDepth,
+#                                    const int& maxDepth);
+# 
+#       int 
+#       HasNormals (TreeOctNode* node,const Real& epsilon);
+# 
+#       Real 
+#       getCenterValue (const TreeOctNode* node);
+# 
+#       Real 
+#       getCornerValue (const TreeOctNode* node,const int& corner);
+# 
+#       void 
+#       getCornerValueAndNormal (const TreeOctNode* node,const int& corner,Real& value,Point3D<Real>& normal);
+# 
+#       public:
+#         static double maxMemoryUsage;
+#         static double 
+#         MemoryUsage ();
+# 
+#         std::vector<Point3D<Real> >* normals;
+#         Real postNormalSmooth;
+#         TreeOctNode tree;
+#         FunctionData<Degree,FunctionDataReal> fData;
+#         Octree ();
+# 
+#         void 
+#         setFunctionData (const PPolynomial<Degree>& ReconstructionFunction,
+#                          const int& maxDepth,
+#                          const int& normalize,
+#                          const Real& normalSmooth = -1);
+#         
+#         void 
+#         finalize1 (const int& refineNeighbors=-1);
+#         
+#         void 
+#         finalize2 (const int& refineNeighbors=-1);
+# 
+#         //int setTree(char* fileName,const int& maxDepth,const int& binary,const int& kernelDepth,const Real& samplesPerNode,
+#         //    const Real& scaleFactor,Point3D<Real>& center,Real& scale,const int& resetSampleDepths,const int& useConfidence);
+# 
+#         template<typename PointNT> int
+#         setTree (boost::shared_ptr<const pcl::PointCloud<PointNT> > input_,
+#                  const int& maxDepth,
+#                  const int& kernelDepth,
+#                  const Real& samplesPerNode,
+#                  const Real& scaleFactor,
+#                  Point3D<Real>& center,
+#                  Real& scale,
+#                  const int& resetSamples,
+#                  const int& useConfidence);
+# 
+# 
+#         void 
+#         SetLaplacianWeights (void);
+#         
+#         void 
+#         ClipTree (void);
+# 
+#         int 
+#         LaplacianMatrixIteration (const int& subdivideDepth);
+# 
+#         Real 
+#         GetIsoValue (void);
+#         
+#         void 
+#         GetMCIsoTriangles (const Real& isoValue,
+#                            CoredMeshData* mesh,
+#                            const int& fullDepthIso = 0,
+#                            const int& nonLinearFit = 1, 
+#                            bool addBarycenter = false, 
+#                            bool polygonMesh = false);
+#         
+#         void 
+#         GetMCIsoTriangles (const Real& isoValue,
+#                            const int& subdivideDepth,
+#                            CoredMeshData* mesh,
+#                            const int& fullDepthIso = 0,
+#                            const int& nonLinearFit = 1, 
+#                            bool addBarycenter = false, 
+#                            bool polygonMesh = false );
+#     };
+#   }
+# }
+# 
+###
+
+# octree_poisson.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/octree_poisson.h (1.7.2)
+# namespace pcl 
+# {
+#   namespace poisson 
+#   {
+# 
+#     template<class NodeData,class Real=float>
+#     class OctNode
+#     {
+#       private:
+#         static int UseAlloc;
+# 
+#         class AdjacencyCountFunction
+#         {
+#           public:
+#             int count;
+#             void Function(const OctNode<NodeData,Real>* node1,const OctNode<NodeData,Real>* node2);
+#         };
+# 
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeFaces (OctNode* node,
+#                                  NodeAdjacencyFunction* F,
+#                                  const int& cIndex1, const int& cIndex2, const int& cIndex3, const int& cIndex4);
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeEdges (OctNode* node,
+#                                  NodeAdjacencyFunction* F,
+#                                  const int& cIndex1, const int& cIndex2);
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeNodes (OctNode* node, NodeAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                 OctNode* node1, const int& radius1,
+#                                                 OctNode* node2, const int& radius2,
+#                                                 const int& cWidth2,
+#                                                 NodeAdjacencyFunction* F);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void __ProcessTerminatingNodeAdjacentNodes(const int& dx, const int& dy, const int& dz,
+#                                                           OctNode* node1, const int& radius1,
+#                                                           OctNode* node2, const int& radius2,
+#                                                           const int& cWidth2,
+#                                                           TerminatingNodeAdjacencyFunction* F);
+#         template<class PointAdjacencyFunction>
+#         static void __ProcessPointAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                  OctNode* node2, const int& radius2,
+#                                                  const int& cWidth2,
+#                                                  PointAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessFixedDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                           OctNode* node1, const int& radius1,
+#                                                           OctNode* node2, const int& radius2,
+#                                                           const int& cWidth2,
+#                                                           const int& depth,
+#                                                           NodeAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessMaxDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                         OctNode* node1, const int& radius1,
+#                                                         OctNode* node2, const int& radius2,
+#                                                         const int& cWidth2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F);
+# 
+#         // This is made private because the division by two has been pulled out.
+#         static inline int Overlap (const int& c1, const int& c2, const int& c3, const int& dWidth);
+#         inline static int ChildOverlap (const int& dx, const int& dy, const int& dz, const int& d, const int& cRadius2);
+# 
+#         const OctNode* __faceNeighbor (const int& dir, const int& off) const;
+#         const OctNode* __edgeNeighbor (const int& o, const int i[2], const int idx[2]) const;
+#         OctNode* __faceNeighbor (const int& dir, const int& off, const int& forceChildren);
+#         OctNode* __edgeNeighbor (const int& o, const int i[2], const int idx[2], const int& forceChildren);
+#       public:
+#         static const int DepthShift,OffsetShift,OffsetShift1,OffsetShift2,OffsetShift3;
+#         static const int DepthMask,OffsetMask;
+# 
+#         static Allocator<OctNode> AllocatorOctNode;
+#         static int UseAllocator (void);
+#         static void SetAllocator (int blockSize);
+# 
+#         OctNode* parent;
+#         OctNode* children;
+#         short d,off[3];
+#         NodeData nodeData;
+# 
+# 
+#         OctNode (void);
+#         ~OctNode (void);
+#         int initChildren (void);
+# 
+#         void depthAndOffset (int& depth, int offset[3]) const;
+#         int depth (void) const;
+#         static inline void DepthAndOffset (const long long& index, int& depth, int offset[3]);
+#         static inline void CenterAndWidth (const long long& index, Point3D<Real>& center, Real& width);
+#         static inline int Depth (const long long& index);
+#         static inline void Index (const int& depth, const int offset[3], short& d, short off[3]);
+#         void centerAndWidth (Point3D<Real>& center, Real& width) const;
+# 
+#         int leaves (void) const;
+#         int maxDepthLeaves (const int& maxDepth) const;
+#         int nodes (void) const;
+#         int maxDepth (void) const;
+# 
+#         const OctNode* root (void) const;
+# 
+#         const OctNode* nextLeaf (const OctNode* currentLeaf = NULL) const;
+#         OctNode* nextLeaf (OctNode* currentLeaf = NULL);
+#         const OctNode* nextNode (const OctNode* currentNode = NULL) const;
+#         OctNode* nextNode (OctNode* currentNode = NULL);
+#         const OctNode* nextBranch (const OctNode* current) const;
+#         OctNode* nextBranch (OctNode* current);
+# 
+#         void setFullDepth (const int& maxDepth);
+# 
+#         void printLeaves (void) const;
+#         void printRange (void) const;
+# 
+#         template<class NodeAdjacencyFunction>
+#         void processNodeFaces (OctNode* node,NodeAdjacencyFunction* F, const int& fIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeEdges (OctNode* node, NodeAdjacencyFunction* F, const int& eIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeCorners (OctNode* node, NodeAdjacencyFunction* F, const int& cIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeNodes (OctNode* node, NodeAdjacencyFunction* F, const int& processCurrent=1);
+# 
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessNodeAdjacentNodes (const int& maxDepth,
+#                                               OctNode* node1, const int& width1,
+#                                               OctNode* node2, const int& width2,
+#                                               NodeAdjacencyFunction* F,
+#                                               const int& processCurrent=1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                               OctNode* node1, const int& radius1,
+#                                               OctNode* node2, const int& radius2,
+#                                               const int& width2,
+#                                               NodeAdjacencyFunction* F,
+#                                               const int& processCurrent = 1);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void ProcessTerminatingNodeAdjacentNodes (const int& maxDepth,
+#                                                          OctNode* node1, const int& width1,
+#                                                          OctNode* node2, const int& width2,
+#                                                          TerminatingNodeAdjacencyFunction* F,
+#                                                          const int& processCurrent = 1);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void ProcessTerminatingNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                          OctNode* node1, const int& radius1,
+#                                                          OctNode* node2, const int& radius2,
+#                                                          const int& width2,
+#                                                          TerminatingNodeAdjacencyFunction* F,
+#                                                          const int& processCurrent = 1);
+#         template<class PointAdjacencyFunction>
+#         static void ProcessPointAdjacentNodes (const int& maxDepth,
+#                                                const int center1[3],
+#                                                OctNode* node2, const int& width2,
+#                                                PointAdjacencyFunction* F,
+#                                                const int& processCurrent = 1);
+#         template<class PointAdjacencyFunction>
+#         static void ProcessPointAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                OctNode* node2, const int& radius2, const int& width2,
+#                                                PointAdjacencyFunction* F,
+#                                                const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessFixedDepthNodeAdjacentNodes (const int& maxDepth,
+#                                                         OctNode* node1, const int& width1,
+#                                                         OctNode* node2, const int& width2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F,
+#                                                         const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessFixedDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                         OctNode* node1, const int& radius1,
+#                                                         OctNode* node2, const int& radius2,
+#                                                         const int& width2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F,
+#                                                         const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessMaxDepthNodeAdjacentNodes (const int& maxDepth,
+#                                                       OctNode* node1, const int& width1,
+#                                                       OctNode* node2, const int& width2,
+#                                                       const int& depth,
+#                                                       NodeAdjacencyFunction* F,
+#                                                       const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessMaxDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                       OctNode* node1, const int& radius1,
+#                                                       OctNode* node2, const int& radius2,
+#                                                       const int& width2,
+#                                                       const int& depth,
+#                                                       NodeAdjacencyFunction* F,
+#                                                       const int& processCurrent = 1);
+# 
+#         static int CornerIndex (const Point3D<Real>& center, const Point3D<Real> &p);
+# 
+#         OctNode* faceNeighbor (const int& faceIndex, const int& forceChildren = 0);
+#         const OctNode* faceNeighbor (const int& faceIndex) const;
+#         OctNode* edgeNeighbor (const int& edgeIndex, const int& forceChildren = 0);
+#         const OctNode* edgeNeighbor (const int& edgeIndex) const;
+#         OctNode* cornerNeighbor (const int& cornerIndex, const int& forceChildren = 0);
+#         const OctNode* cornerNeighbor (const int& cornerIndex) const;
+# 
+#         OctNode* getNearestLeaf (const Point3D<Real>& p);
+#         const OctNode* getNearestLeaf (const Point3D<Real>& p) const;
+# 
+#         static int CommonEdge (const OctNode* node1, const int& eIndex1,
+#                                const OctNode* node2, const int& eIndex2);
+#         static int CompareForwardDepths (const void* v1, const void* v2);
+#         static int CompareForwardPointerDepths (const void* v1, const void* v2);
+#         static int CompareBackwardDepths (const void* v1, const void* v2);
+#         static int CompareBackwardPointerDepths (const void* v1, const void* v2);
+# 
+# 
+#         template<class NodeData2>
+#         OctNode& operator = (const OctNode<NodeData2, Real>& node);
+# 
+#         static inline int Overlap2 (const int &depth1,
+#                                     const int offSet1[DIMENSION],
+#                                     const Real& multiplier1,
+#                                     const int &depth2,
+#                                     const int offSet2[DIMENSION],
+#                                     const Real& multiplier2);
+# 
+# 
+#         int write (const char* fileName) const;
+#         int write (FILE* fp) const;
+#         int read (const char* fileName);
+#         int read (FILE* fp);
+# 
+#         class Neighbors{
+#         public:
+#           OctNode* neighbors[3][3][3];
+#           Neighbors (void);
+#           void clear (void);
+#         };
+#         class NeighborKey{
+#         public:
+#           Neighbors* neighbors;
+# 
+#           NeighborKey (void);
+#           ~NeighborKey (void);
+# 
+#           void set (const int& depth);
+#           Neighbors& setNeighbors (OctNode* node);
+#           Neighbors& getNeighbors (OctNode* node);
+#         };
+#         class Neighbors2{
+#         public:
+#           const OctNode* neighbors[3][3][3];
+#           Neighbors2 (void);
+#           void clear (void);
+#         };
+#         class NeighborKey2{
+#         public:
+#           Neighbors2* neighbors;
+# 
+#           NeighborKey2 (void);
+#           ~NeighborKey2 (void);
+# 
+#           void set (const int& depth);
+#           Neighbors2& getNeighbors (const OctNode* node);
+#         };
+# 
+#         void centerIndex (const int& maxDepth, int index[DIMENSION]) const;
+#         int width (const int& maxDepth) const;
+#     };
+# 
+#   }
+# }
+###
+
+# organized_fast_mesh.h
+# namespace pcl
+# {
+# 
+#   /** \brief Simple triangulation/surface reconstruction for organized point
+#     * clouds. Neighboring points (pixels in image space) are connected to
+#     * construct a triangular mesh.
+#     *
+#     * \author Dirk Holz, Radu B. Rusu
+#     * \ingroup surface
+#     */
+#   template <typename PointInT>
+#   class OrganizedFastMesh : public MeshConstruction<PointInT>
+#   {
+#     public:
+#       using MeshConstruction<PointInT>::input_;
+#       using MeshConstruction<PointInT>::check_tree_;
+# 
+#       typedef typename pcl::PointCloud<PointInT>::Ptr PointCloudPtr;
+# 
+#       typedef std::vector<pcl::Vertices> Polygons;
+# 
+#       enum TriangulationType
+#       {
+#         TRIANGLE_RIGHT_CUT,     // _always_ "cuts" a quad from top left to bottom right
+#         TRIANGLE_LEFT_CUT,      // _always_ "cuts" a quad from top right to bottom left
+#         TRIANGLE_ADAPTIVE_CUT,  // "cuts" where possible and prefers larger differences in 'z' direction
+#         QUAD_MESH               // create a simple quad mesh
+#       };
+# 
+#       /** \brief Constructor. Triangulation type defaults to \a QUAD_MESH. */
+#       OrganizedFastMesh ()
+#       : max_edge_length_squared_ (0.025f)
+#       , triangle_pixel_size_ (1)
+#       , triangulation_type_ (QUAD_MESH)
+#       , store_shadowed_faces_ (false)
+#       , cos_angle_tolerance_ (fabsf (cosf (pcl::deg2rad (12.5f))))
+#       {
+#         check_tree_ = false;
+#       };
+# 
+#       /** \brief Destructor. */
+#       ~OrganizedFastMesh () {};
+# 
+#       /** \brief Set a maximum edge length. TODO: Implement!
+#         * \param[in] max_edge_length the maximum edge length
+#         */
+#       inline void
+#       setMaxEdgeLength (float max_edge_length)
+#       {
+#         max_edge_length_squared_ = max_edge_length * max_edge_length;
+#       };
+# 
+#       /** \brief Set the edge length (in pixels) used for constructing the fixed mesh.
+#         * \param[in] triangle_size edge length in pixels
+#         * (Default: 1 = neighboring pixels are connected)
+#         */
+#       inline void
+#       setTrianglePixelSize (int triangle_size)
+#       {
+#         triangle_pixel_size_ = std::max (1, (triangle_size - 1));
+#       }
+# 
+#       /** \brief Set the triangulation type (see \a TriangulationType)
+#         * \param[in] type quad mesh, triangle mesh with fixed left, right cut,
+#         * or adaptive cut (splits a quad wrt. the depth (z) of the points)
+#         */
+#       inline void
+#       setTriangulationType (TriangulationType type)
+#       {
+#         triangulation_type_ = type;
+#       }
+# 
+#       /** \brief Store shadowed faces or not.
+#         * \param[in] enable set to true to store shadowed faces
+#         */
+#       inline void
+#       storeShadowedFaces (bool enable)
+#       {
+#         store_shadowed_faces_ = enable;
+#       }
+# 
+#     protected:
+#       /** \brief max (squared) length of edge */
+#       float max_edge_length_squared_;
+# 
+#       /** \brief size of triangle endges (in pixels) */
+#       int triangle_pixel_size_;
+# 
+#       /** \brief Type of meshin scheme (quads vs. triangles, left cut vs. right cut ... */
+#       TriangulationType triangulation_type_;
+# 
+#       /** \brief Whether or not shadowed faces are stored, e.g., for exploration */
+#       bool store_shadowed_faces_;
+# 
+#       float cos_angle_tolerance_;
+# 
+#       /** \brief Perform the actual polygonal reconstruction.
+#         * \param[out] polygons the resultant polygons
+#         */
+#       void
+#       reconstructPolygons (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create the surface.
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       virtual void
+#       performReconstruction (std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Create the surface.
+#         *
+#         * Simply uses image indices to create an initial polygonal mesh for organized point clouds.
+#         * \a indices_ are ignored!
+#         *
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Add a new triangle to the current polygon mesh
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] idx the index in the set of polygon vertices (assumes \a idx is valid in \a polygons)
+#         * \param[out] polygons the polygon mesh to be updated
+#         */
+#       inline void
+#       addTriangle (int a, int b, int c, int idx, std::vector<pcl::Vertices>& polygons)
+#       {
+#         assert (idx < static_cast<int> (polygons.size ()));
+#         polygons[idx].vertices.resize (3);
+#         polygons[idx].vertices[0] = a;
+#         polygons[idx].vertices[1] = b;
+#         polygons[idx].vertices[2] = c;
+#       }
+# 
+#       /** \brief Add a new quad to the current polygon mesh
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         * \param[in] idx the index in the set of polygon vertices (assumes \a idx is valid in \a polygons)
+#         * \param[out] polygons the polygon mesh to be updated
+#         */
+#       inline void
+#       addQuad (int a, int b, int c, int d, int idx, std::vector<pcl::Vertices>& polygons)
+#       {
+#         assert (idx < static_cast<int> (polygons.size ()));
+#         polygons[idx].vertices.resize (4);
+#         polygons[idx].vertices[0] = a;
+#         polygons[idx].vertices[1] = b;
+#         polygons[idx].vertices[2] = c;
+#         polygons[idx].vertices[3] = d;
+#       }
+# 
+#       /** \brief Set (all) coordinates of a particular point to the specified value
+#         * \param[in] point_index index of point
+#         * \param[out] mesh to modify
+#         * \param[in] value value to use when re-setting
+#         * \param[in] field_x_idx the X coordinate of the point
+#         * \param[in] field_y_idx the Y coordinate of the point
+#         * \param[in] field_z_idx the Z coordinate of the point
+#         */
+#       inline void
+#       resetPointData (const int &point_index, pcl::PolygonMesh &mesh, const float &value = 0.0f,
+#                       int field_x_idx = 0, int field_y_idx = 1, int field_z_idx = 2)
+#       {
+#         float new_value = value;
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_x_idx].offset], &new_value, sizeof (float));
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_y_idx].offset], &new_value, sizeof (float));
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_z_idx].offset], &new_value, sizeof (float));
+#       }
+# 
+#       /** \brief Check if a point is shadowed by another point
+#         * \param[in] point_a the first point
+#         * \param[in] point_b the second point
+#         */
+#       inline bool
+#       isShadowed (const PointInT& point_a, const PointInT& point_b)
+#       {
+#         Eigen::Vector3f viewpoint = Eigen::Vector3f::Zero (); // TODO: allow for passing viewpoint information
+#         Eigen::Vector3f dir_a = viewpoint - point_a.getVector3fMap ();
+#         Eigen::Vector3f dir_b = point_b.getVector3fMap () - point_a.getVector3fMap ();
+#         float distance_to_points = dir_a.norm ();
+#         float distance_between_points = dir_b.norm ();
+#         float cos_angle = dir_a.dot (dir_b) / (distance_to_points*distance_between_points);
+#         if (cos_angle != cos_angle)
+#           cos_angle = 1.0f;
+#         return (fabs (cos_angle) >= cos_angle_tolerance_);
+#         // TODO: check for both: angle almost 0/180 _and_ distance between points larger than noise level
+#       }
+# 
+#       /** \brief Check if a triangle is valid.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         */
+#       inline bool
+#       isValidTriangle (const int& a, const int& b, const int& c)
+#       {
+#         if (!pcl::isFinite (input_->points[a])) return (false);
+#         if (!pcl::isFinite (input_->points[b])) return (false);
+#         if (!pcl::isFinite (input_->points[c])) return (false);
+#         return (true);
+#       }
+# 
+#       /** \brief Check if a triangle is shadowed.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         */
+#       inline bool
+#       isShadowedTriangle (const int& a, const int& b, const int& c)
+#       {
+#         if (isShadowed (input_->points[a], input_->points[b])) return (true);
+#         if (isShadowed (input_->points[b], input_->points[c])) return (true);
+#         if (isShadowed (input_->points[c], input_->points[a])) return (true);
+#         return (false);
+#       }
+# 
+#       /** \brief Check if a quad is valid.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         */
+#       inline bool
+#       isValidQuad (const int& a, const int& b, const int& c, const int& d)
+#       {
+#         if (!pcl::isFinite (input_->points[a])) return (false);
+#         if (!pcl::isFinite (input_->points[b])) return (false);
+#         if (!pcl::isFinite (input_->points[c])) return (false);
+#         if (!pcl::isFinite (input_->points[d])) return (false);
+#         return (true);
+#       }
+# 
+#       /** \brief Check if a triangle is shadowed.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         */
+#       inline bool
+#       isShadowedQuad (const int& a, const int& b, const int& c, const int& d)
+#       {
+#         if (isShadowed (input_->points[a], input_->points[b])) return (true);
+#         if (isShadowed (input_->points[b], input_->points[c])) return (true);
+#         if (isShadowed (input_->points[c], input_->points[d])) return (true);
+#         if (isShadowed (input_->points[d], input_->points[a])) return (true);
+#         return (false);
+#       }
+# 
+#       /** \brief Create a quad mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeQuadMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create a right cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeRightCutMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create a left cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeLeftCutMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create an adaptive cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeAdaptiveCutMesh (std::vector<pcl::Vertices>& polygons);
+#   };
+# 
+###
+
+# poisson.h
+# namespace pcl
+# {
+#   /** \brief The Poisson surface reconstruction algorithm.
+#     * \note Code adapted from Misha Kazhdan: http://www.cs.jhu.edu/~misha/Code/PoissonRecon/
+#     * \note Based on the paper:
+#     *       * Michael Kazhdan, Matthew Bolitho, Hugues Hoppe, "Poisson surface reconstruction",
+#     *         SGP '06 Proceedings of the fourth Eurographics symposium on Geometry processing
+#     * \author Alexandru-Eugen Ichim
+#     * \ingroup surface
+#     */
+#   template<typename PointNT>
+#   class Poisson : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+#       /** \brief Constructor that sets all the parameters to working default values. */
+#       Poisson ();
+# 
+#       /** \brief Destructor. */
+#       ~Poisson ();
+# 
+#       /** \brief Create the surface.
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Create the surface.
+#         * \param[out] points the vertex positions of the resulting mesh
+#         * \param[out] polygons the connectivity of the resulting mesh
+#         */
+#       void
+#       performReconstruction (pcl::PointCloud<PointNT> &points,
+#                              std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Set the confidence flag
+#         * \note Enabling this flag tells the reconstructor to use the size of the normals as confidence information.
+#         * When the flag is not enabled, all normals are normalized to have unit-length prior to reconstruction.
+#         * \param[in] confidence the given flag
+#         */
+#       inline void
+#       setConfidence (bool confidence) { confidence_ = confidence; }
+# 
+#       /** \brief Get the confidence flag */
+#       inline bool
+#       getConfidence () { return confidence_; }
+# 
+#       /** \brief Set the manifold flag.
+#         * \note Enabling this flag tells the reconstructor to add the polygon barycenter when triangulating polygons
+#         * with more than three vertices.
+#         * \param[in] manifold the given flag
+#         */
+#       inline void
+#       setManifold (bool manifold) { manifold_ = manifold; }
+# 
+#       /** \brief Get the manifold flag */
+#       inline bool
+#       getManifold () { return manifold_; }
+# 
+#       /** \brief Enabling this flag tells the reconstructor to output a polygon mesh (rather than triangulating the
+#         * results of Marching Cubes).
+#         * \param[in] output_polygons the given flag
+#         */
+#       inline void
+#       setOutputPolygons (bool output_polygons) { output_polygons_ = output_polygons; }
+# 
+#       /** \brief Get whether the algorithm outputs a polygon mesh or a triangle mesh */
+#       inline bool
+#       getOutputPolygons () { return output_polygons_; }
+# 
+# 
+#       /** \brief Set the maximum depth of the tree that will be used for surface reconstruction.
+#         * \note Running at depth d corresponds to solving on a voxel grid whose resolution is no larger than
+#         * 2^d x 2^d x 2^d. Note that since the reconstructor adapts the octree to the sampling density, the specified
+#         * reconstruction depth is only an upper bound.
+#         * \param[in] depth the depth parameter
+#         */
+#       inline void
+#       setDepth (int depth) { depth_ = depth; }
+# 
+#       /** \brief Get the depth parameter */
+#       inline int
+#       getDepth () { return depth_; }
+# 
+#       /** \brief Set the the depth at which a block Gauss-Seidel solver is used to solve the Laplacian equation
+#         * \note Using this parameter helps reduce the memory overhead at the cost of a small increase in
+#         * reconstruction time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide
+#         * depth of 7 or 8 can greatly reduce the memory usage.)
+#         * \param[in] solver_divide the given parameter value
+#         */
+#       inline void
+#       setSolverDivide (int solver_divide) { solver_divide_ = solver_divide; }
+# 
+#       /** \brief Get the the depth at which a block Gauss-Seidel solver is used to solve the Laplacian equation */
+#       inline int
+#       getSolverDivide () { return solver_divide_; }
+# 
+#       /** \brief Set the depth at which a block iso-surface extractor should be used to extract the iso-surface
+#         * \note Using this parameter helps reduce the memory overhead at the cost of a small increase in extraction
+#         * time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide depth of 7 or 8
+#         * can greatly reduce the memory usage.)
+#         * \param[in] iso_divide the given parameter value
+#         */
+#       inline void
+#       setIsoDivide (int iso_divide) { iso_divide_ = iso_divide; }
+# 
+#       /** \brief Get the depth at which a block iso-surface extractor should be used to extract the iso-surface */
+#       inline int
+#       getIsoDivide () { return iso_divide_; }
+# 
+#       /** \brief Set the minimum number of sample points that should fall within an octree node as the octree
+#         * construction is adapted to sampling density
+#         * \note For noise-free samples, small values in the range [1.0 - 5.0] can be used. For more noisy samples,
+#         * larger values in the range [15.0 - 20.0] may be needed to provide a smoother, noise-reduced, reconstruction.
+#         * \param[in] samples_per_node the given parameter value
+#         */
+#       inline void
+#       setSamplesPerNode (float samples_per_node) { samples_per_node_ = samples_per_node; }
+# 
+#       /** \brief Get the minimum number of sample points that should fall within an octree node as the octree
+#         * construction is adapted to sampling density
+#         */
+#       inline float
+#       getSamplesPerNode () { return samples_per_node_; }
+# 
+#       /** \brief Set the ratio between the diameter of the cube used for reconstruction and the diameter of the
+#         * samples' bounding cube.
+#         * \param[in] scale the given parameter value
+#         */
+#       inline void
+#       setScale (float scale) { scale_ = scale; }
+# 
+#       /** Get the ratio between the diameter of the cube used for reconstruction and the diameter of the
+#         * samples' bounding cube.
+#         */
+#       inline float
+#       getScale () { return scale_; }
+# 
+#       /** \brief Set the degree parameter
+#         * \param[in] degree the given degree
+#         */
+#       inline void
+#       setDegree (int degree) { degree_ = degree; }
+# 
+#       /** \brief Get the degree parameter */
+#       inline int
+#       getDegree () { return degree_; }
+# 
+# 
+#     protected:
+#       /** \brief The point cloud input (XYZ+Normals). */
+#       PointCloudPtr data_;
+# 
+#       /** \brief Class get name method. */
+#       std::string
+#       getClassName () const { return ("Poisson"); }
+# 
+#     private:
+#       bool no_reset_samples_;
+#       bool no_clip_tree_;
+#       bool confidence_;
+#       bool manifold_;
+#       bool output_polygons_;
+# 
+#       int depth_;
+#       int solver_divide_;
+#       int iso_divide_;
+#       int refine_;
+#       int kernel_depth_;
+#       int degree_;
+# 
+#       float samples_per_node_;
+#       float scale_;
+# 
+#       template<int Degree> void
+#       execute (poisson::CoredMeshData &mesh,
+#                poisson::Point3D<float> &translate,
+#                float &scale);
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+###
+
+# polynomial.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/polynomial.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# template<int Degree>
+# class Polynomial
+#       public:
+#       double coefficients[Degree+1];
+# 
+#       Polynomial(void);
+#       template<int Degree2>
+#       Polynomial(const Polynomial<Degree2>& P);
+#       double operator() (const double& t) const;
+#       double integral (const double& tMin,const double& tMax) const;
+# 
+#       int operator == (const Polynomial& p) const;
+#       int operator != (const Polynomial& p) const;
+#       int isZero(void) const;
+#       void setZero(void);
+# 
+#       template<int Degree2>
+#       Polynomial& operator  = (const Polynomial<Degree2> &p);
+#       Polynomial& operator += (const Polynomial& p);
+#       Polynomial& operator -= (const Polynomial& p);
+#       Polynomial  operator -  (void) const;
+#       Polynomial  operator +  (const Polynomial& p) const;
+#       Polynomial  operator -  (const Polynomial& p) const;
+#       template<int Degree2>
+#       Polynomial<Degree+Degree2>  operator *  (const Polynomial<Degree2>& p) const;
+# 
+#       Polynomial& operator += (const double& s);
+#       Polynomial& operator -= (const double& s);
+#       Polynomial& operator *= (const double& s);
+#       Polynomial& operator /= (const double& s);
+#       Polynomial  operator +  (const double& s) const;
+#       Polynomial  operator -  (const double& s) const;
+#       Polynomial  operator *  (const double& s) const;
+#       Polynomial  operator /  (const double& s) const;
+# 
+#       Polynomial scale (const double& s) const;
+#       Polynomial shift (const double& t) const;
+# 
+#       Polynomial<Degree-1> derivative (void) const;
+#       Polynomial<Degree+1> integral (void) const;
+# 
+#       void printnl (void) const;
+# 
+#       Polynomial& addScaled (const Polynomial& p, const double& scale);
+# 
+#       static void Negate (const Polynomial& in, Polynomial& out);
+#       static void Subtract (const Polynomial& p1, const Polynomial& p2, Polynomial& q);
+#       static void Scale (const Polynomial& p, const double& w, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const double& w1, const Polynomial& p2, const double& w2, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const Polynomial& p2, const double& w2, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const double& w1, const Polynomial& p2, Polynomial& q);
+# 
+#       void getSolutions (const double& c, std::vector<double>& roots, const double& EPS) const;
+#     };
+#   }
+# }
+###
+
+# ppolynomial.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/ppolynomial.h (1.7.2)
+# namespace pcl
+# {
+#   namespace poisson
+#   {
+#     template <int Degree> 
+#     class StartingPolynomial
+#     {
+#       public:
+#         Polynomial<Degree> p;
+#         double start;
+# 
+#         StartingPolynomial () : p (), start () {}
+# 
+#         template <int Degree2> StartingPolynomial<Degree+Degree2> operator* (const StartingPolynomial<Degree2>&p) const;
+#         StartingPolynomial scale (const double&s) const;
+#         StartingPolynomial shift (const double&t) const;
+#         int operator < (const StartingPolynomial &sp) const;
+#         static int Compare (const void *v1,const void *v2);
+#     };
+# 
+#     template <int Degree> 
+#     class PPolynomial
+#     {
+#       public:
+#         size_t polyCount;
+#         StartingPolynomial<Degree>*polys;
+# 
+#         PPolynomial (void);
+#         PPolynomial (const PPolynomial<Degree>&p);
+#         ~PPolynomial (void);
+# 
+#         PPolynomial& operator = (const PPolynomial&p);
+# 
+#         int size (void) const;
+# 
+#         void set (const size_t&size);
+#         // Note: this method will sort the elements in sps
+#         void set (StartingPolynomial<Degree>*sps,const int&count);
+#         void reset (const size_t&newSize);
+# 
+# 
+#         double operator() (const double &t) const;
+#         double integral (const double &tMin,const double &tMax) const;
+#         double Integral (void) const;
+# 
+#         template <int Degree2> PPolynomial<Degree>& operator = (const PPolynomial<Degree2>&p);
+# 
+#         PPolynomial operator + (const PPolynomial&p) const;
+#         PPolynomial operator - (const PPolynomial &p) const;
+# 
+#         template <int Degree2> PPolynomial<Degree+Degree2> operator * (const Polynomial<Degree2> &p) const;
+# 
+#         template <int Degree2> PPolynomial<Degree+Degree2> operator* (const PPolynomial<Degree2>&p) const;
+# 
+# 
+#         PPolynomial& operator += (const double&s);
+#         PPolynomial& operator -= (const double&s);
+#         PPolynomial& operator *= (const double&s);
+#         PPolynomial& operator /= (const double&s);
+#         PPolynomial operator +  (const double&s) const;
+#         PPolynomial operator -  (const double&s) const;
+#         PPolynomial operator*  (const double&s) const;
+#         PPolynomial operator /  (const double &s) const;
+# 
+#         PPolynomial& addScaled (const PPolynomial &poly,const double &scale);
+# 
+#         PPolynomial scale (const double &s) const;
+#         PPolynomial shift (const double &t) const;
+# 
+#         PPolynomial<Degree-1> derivative (void) const;
+#         PPolynomial<Degree+1> integral (void) const;
+# 
+#         void getSolutions (const double &c,
+#                            std::vector<double> &roots,
+#                            const double &EPS,
+#                            const double &min =- DBL_MAX,
+#                            const double &max=DBL_MAX) const;
+# 
+#         void printnl (void) const;
+# 
+#         PPolynomial<Degree+1> MovingAverage (const double &radius);
+# 
+#         static PPolynomial ConstantFunction (const double &width=0.5);
+#         static PPolynomial GaussianApproximation (const double &width=0.5);
+#         void write (FILE *fp,
+#                     const int &samples,
+#                     const double &min,
+#                     const double &max) const;
+#     };
+# 
+# 
+#   }
+# }
+###
+
+# qhull.h
+# 
+# #if defined __GNUC__
+# #  pragma GCC system_header 
+# #endif
+# 
+# extern "C"
+# {
+# #ifdef HAVE_QHULL_2011
+# #  include "libqhull/libqhull.h"
+# #  include "libqhull/mem.h"
+# #  include "libqhull/qset.h"
+# #  include "libqhull/geom.h"
+# #  include "libqhull/merge.h"
+# #  include "libqhull/poly.h"
+# #  include "libqhull/io.h"
+# #  include "libqhull/stat.h"
+# #else
+# #  include "qhull/qhull.h"
+# #  include "qhull/mem.h"
+# #  include "qhull/qset.h"
+# #  include "qhull/geom.h"
+# #  include "qhull/merge.h"
+# #  include "qhull/poly.h"
+# #  include "qhull/io.h"
+# #  include "qhull/stat.h"
+# #endif
+# }
+# 
+###
+
+# simplification_remove_unused_vertices.h
+# namespace pcl
+# {
+#   namespace surface
+#   {
+#     class PCL_EXPORTS SimplificationRemoveUnusedVertices
+#     {
+#       public:
+#         /** \brief Constructor. */
+#         SimplificationRemoveUnusedVertices () {};
+#         /** \brief Destructor. */
+#         ~SimplificationRemoveUnusedVertices () {};
+# 
+#         /** \brief Simply a polygonal mesh.
+#           * \param[in] input the input mesh
+#           * \param[out] output the output mesh
+#           */
+#         inline void
+#         simplify (const pcl::PolygonMesh& input, pcl::PolygonMesh& output)
+#         {
+#           std::vector<int> indices;
+#           simplify (input, output, indices);
+#         }
+# 
+#         /** \brief Perform simplification (remove unused vertices).
+#           * \param[in] input the input mesh
+#           * \param[out] output the output mesh
+#           * \param[out] indices the resultant vector of indices
+#           */
+#         void
+#         simplify (const pcl::PolygonMesh& input, pcl::PolygonMesh& output, std::vector<int>& indices);
+# 
+#     };
+#   }
+###
+
+# sparse_matrix.h
+# pcl/surface/3rdparty/poisson4/sparse_matrix.h (1.7.2)
+# 
+# namespace pcl 
+# namespace poisson 
+# template <class T>
+# struct MatrixEntry
+#     {
+#       MatrixEntry () : N (-1), Value (0) {}
+#       MatrixEntry (int i) : N (i), Value (0) {}
+#       int N;
+#       T Value;
+#     };
+# 
+#     template <class T,int Dim>
+#     struct NMatrixEntry
+#     {
+#       NMatrixEntry () : N (-1), Value () { memset (Value, 0, sizeof (T) * Dim); }
+#       NMatrixEntry (int i) : N (i), Value () { memset (Value, 0, sizeof (T) * Dim); }
+#       int N;
+#       T Value[Dim];
+#     };
+# 
+#     template<class T> class SparseMatrix
+#     {
+#       private:
+#         static int UseAlloc;
+#       public:
+#         static Allocator<MatrixEntry<T> > AllocatorMatrixEntry;
+#         static int UseAllocator (void);
+#         static void SetAllocator (const int& blockSize);
+# 
+#         int rows;
+#         int* rowSizes;
+#         MatrixEntry<T>** m_ppElements;
+# 
+#         SparseMatrix ();
+#         SparseMatrix (int rows);
+#         void Resize (int rows);
+#         void SetRowSize (int row , int count);
+#         int Entries (void);
+# 
+#         SparseMatrix (const SparseMatrix& M);
+#         virtual ~SparseMatrix ();
+# 
+#         void SetZero ();
+#         void SetIdentity ();
+# 
+#         SparseMatrix<T>& operator = (const SparseMatrix<T>& M);
+# 
+#         SparseMatrix<T> operator * (const T& V) const;
+#         SparseMatrix<T>& operator *= (const T& V);
+# 
+# 
+#         SparseMatrix<T> operator * (const SparseMatrix<T>& M) const;
+#         SparseMatrix<T> Multiply (const SparseMatrix<T>& M) const;
+#         SparseMatrix<T> MultiplyTranspose (const SparseMatrix<T>& Mt) const;
+# 
+#         template<class T2>
+#         Vector<T2> operator * (const Vector<T2>& V) const;
+#         template<class T2>
+#         Vector<T2> Multiply (const Vector<T2>& V) const;
+#         template<class T2>
+#         void Multiply (const Vector<T2>& In, Vector<T2>& Out) const;
+# 
+# 
+#         SparseMatrix<T> Transpose() const;
+# 
+#         static int Solve (const SparseMatrix<T>& M,
+#                           const Vector<T>& b,
+#                           const int& iters,
+#                           Vector<T>& solution,
+#                           const T eps = 1e-8);
+# 
+#         template<class T2>
+#         static int SolveSymmetric (const SparseMatrix<T>& M,
+#                                    const Vector<T2>& b,
+#                                    const int& iters,
+#                                    Vector<T2>& solution,
+#                                    const T2 eps = 1e-8,
+#                                    const int& reset=1);
+# 
+#     };
+# 
+#     template<class T,int Dim> class SparseNMatrix
+#     {
+#       private:
+#         static int UseAlloc;
+#       public:
+#         static Allocator<NMatrixEntry<T,Dim> > AllocatorNMatrixEntry;
+#         static int UseAllocator (void);
+#         static void SetAllocator (const int& blockSize);
+# 
+#         int rows;
+#         int* rowSizes;
+#         NMatrixEntry<T,Dim>** m_ppElements;
+# 
+#         SparseNMatrix ();
+#         SparseNMatrix (int rows);
+#         void Resize (int rows);
+#         void SetRowSize (int row, int count);
+#         int Entries ();
+# 
+#         SparseNMatrix (const SparseNMatrix& M);
+#         ~SparseNMatrix ();
+# 
+#         SparseNMatrix& operator = (const SparseNMatrix& M);
+# 
+#         SparseNMatrix  operator *  (const T& V) const;
+#         SparseNMatrix& operator *= (const T& V);
+# 
+#         template<class T2>
+#         NVector<T2,Dim> operator * (const Vector<T2>& V) const;
+#         template<class T2>
+#         Vector<T2> operator * (const NVector<T2,Dim>& V) const;
+#     };
+# 
+#     template <class T>
+#     class SparseSymmetricMatrix : public SparseMatrix<T>
+#     {
+#       public:
+#         virtual ~SparseSymmetricMatrix () {}
+# 
+#         template<class T2>
+#         Vector<T2> operator * (const Vector<T2>& V) const;
+# 
+#         template<class T2>
+#         Vector<T2> Multiply (const Vector<T2>& V ) const;
+# 
+#         template<class T2> void 
+#         Multiply (const Vector<T2>& In, Vector<T2>& Out ) const;
+# 
+#         template<class T2> static int 
+#         Solve (const SparseSymmetricMatrix<T>& M,
+#                const Vector<T2>& b,
+#                const int& iters,
+#                Vector<T2>& solution,
+#                const T2 eps = 1e-8,
+#                const int& reset=1);
+# 
+#         template<class T2> static int 
+#         Solve (const SparseSymmetricMatrix<T>& M,
+#                const Vector<T>& diagonal,
+#                const Vector<T2>& b,
+#                const int& iters,
+#                Vector<T2>& solution,
+#                const T2 eps = 1e-8,
+#                const int& reset=1);
+#     };
+#   }
+# 
+###
+
+# surfel_smoothing.h
+# namespace pcl
+# {
+#   template <typename PointT, typename PointNT>
+#   class SurfelSmoothing : public PCLBase<PointT>
+#   {
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::initCompute;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloudIn;
+#       typedef typename pcl::PointCloud<PointT>::Ptr PointCloudInPtr;
+#       typedef pcl::PointCloud<PointNT> NormalCloud;
+#       typedef typename pcl::PointCloud<PointNT>::Ptr NormalCloudPtr;
+#       typedef pcl::search::Search<PointT> CloudKdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr CloudKdTreePtr;
+# 
+#       SurfelSmoothing (float a_scale = 0.01)
+#         : PCLBase<PointT> ()
+#         , scale_ (a_scale)
+#         , scale_squared_ (a_scale * a_scale)
+#         , normals_ ()
+#         , interm_cloud_ ()
+#         , interm_normals_ ()
+#         , tree_ ()
+#       {
+#       }
+# 
+#       void
+#       setInputNormals (NormalCloudPtr &a_normals) { normals_ = a_normals; };
+# 
+#       void
+#       setSearchMethod (const CloudKdTreePtr &a_tree) { tree_ = a_tree; };
+# 
+#       bool
+#       initCompute ();
+# 
+#       float
+#       smoothCloudIteration (PointCloudInPtr &output_positions,
+#                             NormalCloudPtr &output_normals);
+# 
+#       void
+#       computeSmoothedCloud (PointCloudInPtr &output_positions,
+#                             NormalCloudPtr &output_normals);
+# 
+# 
+#       void
+#       smoothPoint (size_t &point_index,
+#                    PointT &output_point,
+#                    PointNT &output_normal);
+# 
+#       void
+#       extractSalientFeaturesBetweenScales (PointCloudInPtr &cloud2,
+#                                            NormalCloudPtr &cloud2_normals,
+#                                            boost::shared_ptr<std::vector<int> > &output_features);
+# 
+#     private:
+#       float scale_, scale_squared_;
+#       NormalCloudPtr normals_;
+# 
+#       PointCloudInPtr interm_cloud_;
+#       NormalCloudPtr interm_normals_;
+# 
+#       CloudKdTreePtr tree_;
+# 
+#   };
+###
+
+# texture_mapping.h
+# namespace pcl
+# {
+#   namespace texture_mapping
+#   {
+#         
+#     /** \brief Structure to store camera pose and focal length. */
+#     struct Camera
+#     {
+#       Camera () : pose (), focal_length (), height (), width (), texture_file () {}
+#       Eigen::Affine3f pose;
+#       double focal_length;
+#       double height;
+#       double width;
+#       std::string texture_file;
+# 
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#     };
+# 
+#     /** \brief Structure that links a uv coordinate to its 3D point and face.
+#       */
+#     struct UvIndex
+#     {
+#       UvIndex () : idx_cloud (), idx_face () {}
+#       int idx_cloud; // Index of the PointXYZ in the camera's cloud
+#       int idx_face; // Face corresponding to that projection
+#     };
+#     
+#     typedef std::vector<Camera, Eigen::aligned_allocator<Camera> > CameraVector;
+#     
+#   }
+#   
+#   /** \brief The texture mapping algorithm
+#     * \author Khai Tran, Raphael Favier
+#     * \ingroup surface
+#     */
+#   template<typename PointInT>
+#   class TextureMapping
+#   {
+#     public:
+#      
+#       typedef boost::shared_ptr< PointInT > Ptr;
+#       typedef boost::shared_ptr< const PointInT > ConstPtr;
+# 
+#       typedef pcl::PointCloud<PointInT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef pcl::octree::OctreePointCloudSearch<PointInT> Octree;
+#       typedef typename Octree::Ptr OctreePtr;
+#       typedef typename Octree::ConstPtr OctreeConstPtr;
+#       
+#       typedef pcl::texture_mapping::Camera Camera;
+#       typedef pcl::texture_mapping::UvIndex UvIndex;
+# 
+#       /** \brief Constructor. */
+#       TextureMapping () :
+#         f_ (), vector_field_ (), tex_files_ (), tex_material_ ()
+#       {
+#       }
+# 
+#       /** \brief Destructor. */
+#       ~TextureMapping ()
+#       {
+#       }
+# 
+#       /** \brief Set mesh scale control
+#         * \param[in] f
+#         */
+#       inline void
+#       setF (float f)
+#       {
+#         f_ = f;
+#       }
+# 
+#       /** \brief Set vector field
+#         * \param[in] x data point x
+#         * \param[in] y data point y
+#         * \param[in] z data point z
+#         */
+#       inline void
+#       setVectorField (float x, float y, float z)
+#       {
+#         vector_field_ = Eigen::Vector3f (x, y, z);
+#         // normalize vector field
+#         vector_field_ = vector_field_ / std::sqrt (vector_field_.dot (vector_field_));
+#       }
+# 
+#       /** \brief Set texture files
+#         * \param[in] tex_files list of texture files
+#         */
+#       inline void
+#       setTextureFiles (std::vector<std::string> tex_files)
+#       {
+#         tex_files_ = tex_files;
+#       }
+# 
+#       /** \brief Set texture materials
+#         * \param[in] tex_material texture material
+#         */
+#       inline void
+#       setTextureMaterials (TexMaterial tex_material)
+#       {
+#         tex_material_ = tex_material;
+#       }
+# 
+#       /** \brief Map texture to a mesh synthesis algorithm
+#         * \param[in] tex_mesh texture mesh
+#         */
+#       void
+#       mapTexture2Mesh (pcl::TextureMesh &tex_mesh);
+# 
+#       /** \brief map texture to a mesh UV mapping
+#         * \param[in] tex_mesh texture mesh
+#         */
+#       void
+#       mapTexture2MeshUV (pcl::TextureMesh &tex_mesh);
+# 
+#       /** \brief map textures aquired from a set of cameras onto a mesh.
+#         * \details With UV mapping, the mesh must be divided into NbCamera + 1 sub-meshes.
+#         * Each sub-mesh corresponding to the faces visible by one camera. The last submesh containing all non-visible faces
+#         * \param[in] tex_mesh texture mesh
+#         * \param[in] cams cameras used for UV mapping
+#         */
+#       void
+#       mapMultipleTexturesToMeshUV (pcl::TextureMesh &tex_mesh, 
+#                                    pcl::texture_mapping::CameraVector &cams);
+# 
+#       /** \brief computes UV coordinates of point, observed by one particular camera
+#         * \param[in] pt XYZ point to project on camera plane
+#         * \param[in] cam the camera used for projection
+#         * \param[out] UV_coordinates the resulting uv coordinates. Set to (-1.0,-1.0) if the point is not visible by the camera
+#         * \returns false if the point is not visible by the camera
+#         */
+#       inline bool
+#       getPointUVCoordinates (const pcl::PointXYZ &pt, const Camera &cam, Eigen::Vector2f &UV_coordinates)
+#       {
+#         // if the point is in front of the camera
+#         if (pt.z > 0)
+#         {
+#           // compute image center and dimension
+#           double sizeX = cam.width;
+#           double sizeY = cam.height;
+#           double cx = (sizeX) / 2.0;
+#           double cy = (sizeY) / 2.0;
+# 
+#           double focal_x = cam.focal_length;
+#           double focal_y = cam.focal_length;
+# 
+#           // project point on image frame
+#           UV_coordinates[0] = static_cast<float> ((focal_x * (pt.x / pt.z) + cx) / sizeX); //horizontal
+#           UV_coordinates[1] = 1.0f - static_cast<float> (((focal_y * (pt.y / pt.z) + cy) / sizeY)); //vertical
+# 
+#           // point is visible!
+#           if (UV_coordinates[0] >= 0.0 && UV_coordinates[0] <= 1.0 && UV_coordinates[1] >= 0.0 && UV_coordinates[1]
+#                                                                                                                  <= 1.0)
+#             return (true);
+#         }
+# 
+#         // point is NOT visible by the camera
+#         UV_coordinates[0] = -1.0;
+#         UV_coordinates[1] = -1.0;
+#         return (false);
+#       }
+# 
+#       /** \brief Check if a point is occluded using raycasting on octree.
+#         * \param[in] pt XYZ from which the ray will start (toward the camera)
+#         * \param[in] octree the octree used for raycasting. It must be initialized with a cloud transformed into the camera's frame
+#         * \returns true if the point is occluded.
+#         */
+#       inline bool
+#       isPointOccluded (const pcl::PointXYZ &pt, const OctreePtr octree);
+# 
+#       /** \brief Remove occluded points from a point cloud
+#         * \param[in] input_cloud the cloud on which to perform occlusion detection
+#         * \param[out] filtered_cloud resulting cloud, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         * \param[out] visible_indices will contain indices of visible points
+#         * \param[out] occluded_indices will contain indices of occluded points
+#         */
+#       void
+#       removeOccludedPoints (const PointCloudPtr &input_cloud,
+#                             PointCloudPtr &filtered_cloud, const double octree_voxel_size,
+#                             std::vector<int> &visible_indices, std::vector<int> &occluded_indices);
+# 
+#       /** \brief Remove occluded points from a textureMesh
+#         * \param[in] tex_mesh input mesh, on witch to perform occlusion detection
+#         * \param[out] cleaned_mesh resulting mesh, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         */
+#       void
+#       removeOccludedPoints (const pcl::TextureMesh &tex_mesh, pcl::TextureMesh &cleaned_mesh, const double octree_voxel_size);
+# 
+# 
+#       /** \brief Remove occluded points from a textureMesh
+#         * \param[in] tex_mesh input mesh, on witch to perform occlusion detection
+#         * \param[out] filtered_cloud resulting cloud, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         */
+#       void
+#       removeOccludedPoints (const pcl::TextureMesh &tex_mesh, PointCloudPtr &filtered_cloud, const double octree_voxel_size);
+# 
+# 
+#       /** \brief Segment faces by camera visibility. Point-based segmentation.
+#         * \details With N camera, faces will be arranged into N+1 groups: 1 for each camera, plus 1 for faces not visible from any camera.
+#         * \param[in] tex_mesh input mesh that needs sorting. Must contain only 1 sub-mesh.
+#         * \param[in] sorted_mesh resulting mesh, will contain nbCamera + 1 sub-mesh.
+#         * \param[in] cameras vector containing the cameras used for texture mapping.
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         * \param[out] visible_pts cloud containing only visible points
+#         */
+#       int
+#       sortFacesByCamera (pcl::TextureMesh &tex_mesh, 
+#                          pcl::TextureMesh &sorted_mesh, 
+#                          const pcl::texture_mapping::CameraVector &cameras,
+#                          const double octree_voxel_size, PointCloud &visible_pts);
+# 
+#       /** \brief Colors a point cloud, depending on its occlusions.
+#         * \details If showNbOcclusions is set to True, each point is colored depending on the number of points occluding it.
+#         * Else, each point is given a different a 0 value is not occluded, 1 if occluded.
+#         * By default, the number of occlusions is bounded to 4.
+#         * \param[in] input_cloud input cloud on which occlusions will be computed.
+#         * \param[out] colored_cloud resulting colored cloud showing the number of occlusions per point.
+#         * \param[in] octree_voxel_size octree resolution (in meters).
+#         * \param[in] show_nb_occlusions If false, color information will only represent.
+#         * \param[in] max_occlusions Limit the number of occlusions per point.
+#         */
+#       void
+#       showOcclusions (const PointCloudPtr &input_cloud, 
+#                       pcl::PointCloud<pcl::PointXYZI>::Ptr &colored_cloud,
+#                       const double octree_voxel_size, 
+#                       const bool show_nb_occlusions = true,
+#                       const int max_occlusions = 4);
+# 
+#       /** \brief Colors the point cloud of a Mesh, depending on its occlusions.
+#         * \details If showNbOcclusions is set to True, each point is colored depending on the number of points occluding it.
+#         * Else, each point is given a different a 0 value is not occluded, 1 if occluded.
+#         * By default, the number of occlusions is bounded to 4.
+#         * \param[in] tex_mesh input mesh on which occlusions will be computed.
+#         * \param[out] colored_cloud resulting colored cloud showing the number of occlusions per point.
+#         * \param[in] octree_voxel_size octree resolution (in meters).
+#         * \param[in] show_nb_occlusions If false, color information will only represent.
+#         * \param[in] max_occlusions Limit the number of occlusions per point.
+#         */
+#       void
+#       showOcclusions (pcl::TextureMesh &tex_mesh, 
+#                       pcl::PointCloud<pcl::PointXYZI>::Ptr &colored_cloud,
+#                       double octree_voxel_size, 
+#                       bool show_nb_occlusions = true, 
+#                       int max_occlusions = 4);
+# 
+#       /** \brief Segment and texture faces by camera visibility. Face-based segmentation.
+#         * \details With N camera, faces will be arranged into N+1 groups: 1 for each camera, plus 1 for faces not visible from any camera.
+#         * The mesh will also contain uv coordinates for each face
+#         * \param[in/out] tex_mesh input mesh that needs sorting. Should contain only 1 sub-mesh.
+#         * \param[in] cameras vector containing the cameras used for texture mapping.
+#         */
+#       void 
+#       textureMeshwithMultipleCameras (pcl::TextureMesh &mesh, 
+#                                       const pcl::texture_mapping::CameraVector &cameras);
+# 
+#     protected:
+#       /** \brief mesh scale control. */
+#       float f_;
+# 
+#       /** \brief vector field */
+#       Eigen::Vector3f vector_field_;
+# 
+#       /** \brief list of texture files */
+#       std::vector<std::string> tex_files_;
+# 
+#       /** \brief list of texture materials */
+#       TexMaterial tex_material_;
+# 
+#       /** \brief Map texture to a face
+#         * \param[in] p1 the first point
+#         * \param[in] p2 the second point
+#         * \param[in] p3 the third point
+#         */
+#       std::vector<Eigen::Vector2f>
+#       mapTexture2Face (const Eigen::Vector3f &p1, const Eigen::Vector3f &p2, const Eigen::Vector3f &p3);
+# 
+#       /** \brief Returns the circumcenter of a triangle and the circle's radius.
+#         * \details see http://en.wikipedia.org/wiki/Circumcenter for formulas.
+#         * \param[in] p1 first point of the triangle.
+#         * \param[in] p2 second point of the triangle.
+#         * \param[in] p3 third point of the triangle.
+#         * \param[out] circumcenter resulting circumcenter
+#         * \param[out] radius the radius of the circumscribed circle.
+#         */
+#       inline void
+#       getTriangleCircumcenterAndSize (const pcl::PointXY &p1, const pcl::PointXY &p2, const pcl::PointXY &p3, pcl::PointXY &circomcenter, double &radius);
+# 
+#       /** \brief computes UV coordinates of point, observed by one particular camera
+#         * \param[in] pt XYZ point to project on camera plane
+#         * \param[in] cam the camera used for projection
+#         * \param[out] UV_coordinates the resulting UV coordinates. Set to (-1.0,-1.0) if the point is not visible by the camera
+#         * \returns false if the point is not visible by the camera
+#         */
+#       inline bool
+#       getPointUVCoordinates (const pcl::PointXYZ &pt, const Camera &cam, pcl::PointXY &UV_coordinates);
+# 
+#       /** \brief Returns true if all the vertices of one face are projected on the camera's image plane.
+#         * \param[in] camera camera on which to project the face.
+#         * \param[in] p1 first point of the face.
+#         * \param[in] p2 second point of the face.
+#         * \param[in] p3 third point of the face.
+#         * \param[out] proj1 UV coordinates corresponding to p1.
+#         * \param[out] proj2 UV coordinates corresponding to p2.
+#         * \param[out] proj3 UV coordinates corresponding to p3.
+#         */
+#       inline bool
+#       isFaceProjected (const Camera &camera, 
+#                        const pcl::PointXYZ &p1, const pcl::PointXYZ &p2, const pcl::PointXYZ &p3, 
+#                        pcl::PointXY &proj1, pcl::PointXY &proj2, pcl::PointXY &proj3);
+# 
+#       /** \brief Returns True if a point lays within a triangle
+#         * \details see http://www.blackpawn.com/texts/pointinpoly/default.html
+#         * \param[in] p1 first point of the triangle.
+#         * \param[in] p2 second point of the triangle.
+#         * \param[in] p3 third point of the triangle.
+#         * \param[in] pt the querry point.
+#         */
+#       inline bool
+#       checkPointInsideTriangle (const pcl::PointXY &p1, const pcl::PointXY &p2, const pcl::PointXY &p3, const pcl::PointXY &pt);
+# 
+#       /** \brief Class get name method. */
+#       std::string
+#       getClassName () const
+#       {
+#         return ("TextureMapping");
+#       }
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+###
+
+# vector.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/vector.h (1.7.2)
+# namespace pcl {
+# namespace poisson {
+# 
+#     template<class T>
+#     class Vector
+#     {
+#     public:
+#       Vector ();
+#       Vector (const Vector<T>& V);
+#       Vector (size_t N);
+#       Vector (size_t N, T* pV);
+#       ~Vector();
+# 
+#       const T& operator () (size_t i) const;
+#       T& operator () (size_t i);
+#       const T& operator [] (size_t i) const;
+#       T& operator [] (size_t i);
+# 
+#       void SetZero();
+# 
+#       size_t Dimensions() const;
+#       void Resize( size_t N );
+# 
+#       Vector operator * (const T& A) const;
+#       Vector operator / (const T& A) const;
+#       Vector operator - (const Vector& V) const;
+#       Vector operator + (const Vector& V) const;
+# 
+#       Vector& operator *= (const T& A);
+#       Vector& operator /= (const T& A);
+#       Vector& operator += (const Vector& V);
+#       Vector& operator -= (const Vector& V);
+# 
+#       Vector& AddScaled (const Vector& V,const T& scale);
+#       Vector& SubtractScaled (const Vector& V,const T& scale);
+#       static void Add (const Vector& V1,const T& scale1,const Vector& V2,const T& scale2,Vector& Out);
+#       static void Add (const Vector& V1,const T& scale1,const Vector& V2,Vector& Out);
+# 
+#       Vector operator - () const;
+# 
+#       Vector& operator = (const Vector& V);
+# 
+#       T Dot (const Vector& V) const;
+# 
+#       T Length() const;
+# 
+#       T Norm (size_t Ln) const;
+#       void Normalize();
+# 
+#       T* m_pV;
+#     protected:
+#       size_t m_N;
+# 
+#     };
+# 
+#     template<class T,int Dim>
+#     class NVector
+#     {
+#     public:
+#       NVector ();
+#       NVector (const NVector& V);
+#       NVector (size_t N);
+#       NVector (size_t N, T* pV);
+#       ~NVector ();
+# 
+#       const T* operator () (size_t i) const;
+#       T* operator () (size_t i);
+#       const T* operator [] (size_t i) const;
+#       T* operator [] (size_t i);
+# 
+#       void SetZero();
+# 
+#       size_t Dimensions() const;
+#       void Resize( size_t N );
+# 
+#       NVector operator * (const T& A) const;
+#       NVector operator / (const T& A) const;
+#       NVector operator - (const NVector& V) const;
+#       NVector operator + (const NVector& V) const;
+# 
+#       NVector& operator *= (const T& A);
+#       NVector& operator /= (const T& A);
+#       NVector& operator += (const NVector& V);
+#       NVector& operator -= (const NVector& V);
+# 
+#       NVector& AddScaled (const NVector& V,const T& scale);
+#       NVector& SubtractScaled (const NVector& V,const T& scale);
+#       static void Add (const NVector& V1,const T& scale1,const NVector& V2,const T& scale2,NVector& Out);
+#       static void Add (const NVector& V1,const T& scale1,const NVector& V2, NVector& Out);
+# 
+#       NVector operator - () const;
+# 
+#       NVector& operator = (const NVector& V);
+# 
+#       T Dot (const NVector& V) const;
+# 
+#       T Length () const;
+# 
+#       T Norm (size_t Ln) const;
+#       void Normalize ();
+# 
+#       T* m_pV;
+#     protected:
+#       size_t m_N;
+# 
+#     };
+# 
+#   }
+# }
+###
+
+# vtk.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_smoothing.h (1.7.2)
+# #include <vtkPolyData.h>
+# #include <vtkSmartPointer.h>
+###
+
+# pcl\surface\vtk_smoothing\vtk_mesh_quadric_decimation.h (1.7.2)
+
+# vtk_mesh_smoothing_laplacian.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_smoothing_laplacian.h (1.7.2)
+# namespace pcl
+# {
+#   /** \brief PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library.
+#     * Please check out the original documentation for more details on the inner workings of the algorithm
+#     * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#     * data structure to the vtkPolyData data structure and back.
+#     */
+#   class PCL_EXPORTS MeshSmoothingLaplacianVTK : public MeshProcessing
+#   {
+#     public:
+#       /** \brief Empty constructor that sets the values of the algorithm parameters to the VTK defaults */
+#       MeshSmoothingLaplacianVTK ()
+#         : MeshProcessing ()
+#         , vtk_polygons_ ()
+#         , num_iter_ (20)
+#         , convergence_ (0.0f)
+#         , relaxation_factor_ (0.01f)
+#         , feature_edge_smoothing_ (false)
+#         , feature_angle_ (45.f)
+#         , edge_angle_ (15.f)
+#         , boundary_smoothing_ (true)
+#       {};
+# 
+#       /** \brief Set the number of iterations for the smoothing filter.
+#         * \param[in] num_iter the number of iterations
+#         */
+#       inline void
+#       setNumIter (int num_iter)
+#       {
+#         num_iter_ = num_iter;
+#       };
+# 
+#       /** \brief Get the number of iterations. */
+#       inline int
+#       getNumIter ()
+#       {
+#         return num_iter_;
+#       };
+# 
+#       /** \brief Specify a convergence criterion for the iteration process. Smaller numbers result in more smoothing iterations.
+#        * \param[in] convergence convergence criterion for the Laplacian smoothing
+#        */
+#       inline void
+#       setConvergence (float convergence)
+#       {
+#         convergence_ = convergence;
+#       };
+# 
+#       /** \brief Get the convergence criterion. */
+#       inline float
+#       getConvergence ()
+#       {
+#         return convergence_;
+#       };
+# 
+#       /** \brief Specify the relaxation factor for Laplacian smoothing. As in all iterative methods,
+#        * the stability of the process is sensitive to this parameter.
+#        * In general, small relaxation factors and large numbers of iterations are more stable than larger relaxation
+#        * factors and smaller numbers of iterations.
+#        * \param[in] relaxation_factor the relaxation factor of the Laplacian smoothing algorithm
+#        */
+#       inline void
+#       setRelaxationFactor (float relaxation_factor)
+#       {
+#         relaxation_factor_ = relaxation_factor;
+#       };
+# 
+#       /** \brief Get the relaxation factor of the Laplacian smoothing */
+#       inline float
+#       getRelaxationFactor ()
+#       {
+#         return relaxation_factor_;
+#       };
+# 
+#       /** \brief Turn on/off smoothing along sharp interior edges.
+#        * \param[in] status decision whether to enable/disable smoothing along sharp interior edges
+#        */
+#       inline void
+#       setFeatureEdgeSmoothing (bool feature_edge_smoothing)
+#       {
+#         feature_edge_smoothing_ = feature_edge_smoothing;
+#       };
+# 
+#       /** \brief Get the status of the feature edge smoothing */
+#       inline bool
+#       getFeatureEdgeSmoothing ()
+#       {
+#         return feature_edge_smoothing_;
+#       };
+# 
+#       /** \brief Specify the feature angle for sharp edge identification.
+#        * \param[in] feature_angle the angle threshold for considering an edge to be sharp
+#        */
+#       inline void
+#       setFeatureAngle (float feature_angle)
+#       {
+#         feature_angle_ = feature_angle;
+#       };
+# 
+#       /** \brief Get the angle threshold for considering an edge to be sharp */
+#       inline float
+#       getFeatureAngle ()
+#       {
+#         return feature_angle_;
+#       };
+# 
+#       /** \brief Specify the edge angle to control smoothing along edges (either interior or boundary).
+#        * \param[in] edge_angle the angle to control smoothing along edges
+#        */
+#       inline void
+#       setEdgeAngle (float edge_angle)
+#       {
+#         edge_angle_ = edge_angle;
+#       };
+# 
+#       /** \brief Get the edge angle to control smoothing along edges */
+#       inline float
+#       getEdgeAngle ()
+#       {
+#         return edge_angle_;
+#       };
+# 
+#       /** \brief Turn on/off the smoothing of vertices on the boundary of the mesh.
+#        * \param[in] boundary_smoothing decision whether boundary smoothing is on or off
+#        */
+#       inline void
+#       setBoundarySmoothing (bool boundary_smoothing)
+#       {
+#         boundary_smoothing_ = boundary_smoothing;
+#       };
+# 
+#       /** \brief Get the status of the boundary smoothing */
+#       inline bool
+#       getBoundarySmoothing ()
+#       {
+#         return boundary_smoothing_;
+#       }
+# 
+#     protected:
+#       void
+#       performProcessing (pcl::PolygonMesh &output);
+# 
+#     private:
+#       vtkSmartPointer<vtkPolyData> vtk_polygons_;
+# 
+#       /// Parameters
+#       int num_iter_;
+#       float convergence_;
+#       float relaxation_factor_;
+#       bool feature_edge_smoothing_;
+#       float feature_angle_;
+#       float edge_angle_;
+#       bool boundary_smoothing_;
+#   };
+###
+
+# vtk_mesh_smoothing_windowed_sinc.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_smoothing_windowed_sinc.h (1.7.2)
+# namespace pcl
+# /** \brief PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library.
+#   * Please check out the original documentation for more details on the inner workings of the algorithm
+#   * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#   * data structure to the vtkPolyData data structure and back.
+#   */
+# class PCL_EXPORTS MeshSmoothingWindowedSincVTK : public MeshProcessing
+#       public:
+#       /** \brief Empty constructor that sets the values of the algorithm parameters to the VTK defaults */
+#       MeshSmoothingWindowedSincVTK ()
+#         : MeshProcessing (),
+#           num_iter_ (20),
+#           pass_band_ (0.1f),
+#           feature_edge_smoothing_ (false),
+#           feature_angle_ (45.f),
+#           edge_angle_ (15.f),
+#           boundary_smoothing_ (true),
+#           normalize_coordinates_ (false)
+#       {};
+# 
+#       /** \brief Set the number of iterations for the smoothing filter.
+#         * \param[in] num_iter the number of iterations
+#       inline void setNumIter (int num_iter)
+#       /** \brief Get the number of iterations. */
+#       inline int getNumIter ()
+#       /** \brief Set the pass band value for windowed sinc filtering.
+#         * \param[in] pass_band value for the pass band.
+#       inline void setPassBand (float pass_band)
+#       /** \brief Get the pass band value. */
+#       inline float getPassBand ()
+#       /** \brief Turn on/off coordinate normalization. The positions can be translated and scaled such that they fit
+#        * within a [-1, 1] prior to the smoothing computation. The default is off. The numerical stability of the
+#        * solution can be improved by turning normalization on. If normalization is on, the coordinates will be rescaled
+#        * to the original coordinate system after smoothing has completed.
+#        * \param[in] normalize_coordinates decision whether to normalize coordinates or not
+#       inline void setNormalizeCoordinates (bool normalize_coordinates)
+#       /** \brief Get whether the coordinate normalization is active or not */
+#       inline bool getNormalizeCoordinates ()
+#       /** \brief Turn on/off smoothing along sharp interior edges.
+#        * \param[in] status decision whether to enable/disable smoothing along sharp interior edges
+#       inline void setFeatureEdgeSmoothing (bool feature_edge_smoothing)
+#       /** \brief Get the status of the feature edge smoothing */
+#       inline bool getFeatureEdgeSmoothing ()
+#       /** \brief Specify the feature angle for sharp edge identification.
+#        * \param[in] feature_angle the angle threshold for considering an edge to be sharp
+#       inline void setFeatureAngle (float feature_angle)
+#       /** \brief Get the angle threshold for considering an edge to be sharp */
+#       inline float getFeatureAngle ()
+#       /** \brief Specify the edge angle to control smoothing along edges (either interior or boundary).
+#        * \param[in] edge_angle the angle to control smoothing along edges
+#       inline void setEdgeAngle (float edge_angle)
+#       /** \brief Get the edge angle to control smoothing along edges */
+#       inline float getEdgeAngle ()
+#       /** \brief Turn on/off the smoothing of vertices on the boundary of the mesh.
+#        * \param[in] boundary_smoothing decision whether boundary smoothing is on or off
+#       inline void setBoundarySmoothing (bool boundary_smoothing)
+#       /** \brief Get the status of the boundary smoothing */
+#       inline bool getBoundarySmoothing ()
+#       protected:
+#       void performProcessing (pcl::PolygonMesh &output);
+###
+
+# vtk_mesh_subdivision.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_subdivision.h (1.7.2)
+# namespace pcl
+# /** \brief PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter
+#   * depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library.
+#   * Please check out the original documentation for more details on the inner workings of the algorithm
+#   * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#   * data structure to the vtkPolyData data structure and back.
+#   */
+# class PCL_EXPORTS MeshSubdivisionVTK : public MeshProcessing
+#       public:
+#       /** \brief Empty constructor */
+#       MeshSubdivisionVTK ();
+#       enum MeshSubdivisionVTKFilterType
+#       { LINEAR, LOOP, BUTTERFLY };
+#       /** \brief Set the mesh subdivision filter type
+#         * \param[in] type the filter type
+#       inline void setFilterType (MeshSubdivisionVTKFilterType type)
+#       /** \brief Get the mesh subdivision filter type */
+#       inline MeshSubdivisionVTKFilterType getFilterType ()
+#       protected:
+#       void performProcessing (pcl::PolygonMesh &output);
+###
+
+# vtk_utils.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_utils.h (1.7.2)
+# namespace pcl
+# class PCL_EXPORTS VTKUtils
+#       public:
+#       /** \brief Convert a PCL PolygonMesh to a VTK vtkPolyData.
+#         * \param[in] triangles PolygonMesh to be converted to vtkPolyData, stored in the object.
+#         */
+#       static int
+#       convertToVTK (const pcl::PolygonMesh &triangles, vtkSmartPointer<vtkPolyData> &triangles_out_vtk);
+#       /** \brief Convert the vtkPolyData object back to PolygonMesh.
+#         * \param[out] triangles the PolygonMesh to store the vtkPolyData in.
+#         */
+#       static void
+#       convertToPCL (vtkSmartPointer<vtkPolyData> &vtk_polygons, pcl::PolygonMesh &triangles);
+#       /** \brief Convert vtkPolyData object to a PCL PolygonMesh
+#         * \param[in] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#         * \param[out] mesh PCL Polygon Mesh to fill
+#         * \return Number of points in the point cloud of mesh.
+#         */
+#       static int
+#       vtk2mesh (const vtkSmartPointer<vtkPolyData>& poly_data, pcl::PolygonMesh& mesh);
+#       /** \brief Convert a PCL PolygonMesh to a vtkPolyData object
+#         * \param[in] mesh Reference to PCL Polygon Mesh
+#         * \param[out] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#         * \return Number of points in the point cloud of mesh.
+#         */
+#       static int
+#       mesh2vtk (const pcl::PolygonMesh& mesh, vtkSmartPointer<vtkPolyData> &poly_data);
+###
+
+###############################################################################
+# Enum
+###############################################################################
diff --git a/pcl/pcl_surface_172.pxd b/pcl/pcl_surface_172.pxd
new file mode 100644
index 0000000..41a2021
--- /dev/null
+++ b/pcl/pcl_surface_172.pxd
@@ -0,0 +1,5132 @@
+# -*- coding: utf-8 -*-
+
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_kdtree as pclkdt
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# reconstruction.h
+# namespace pcl
+# brief Pure abstract class. All types of meshing/reconstruction
+# algorithms in \b libpcl_surface must inherit from this, in order to make
+# sure we have a consistent API. The methods that we care about here are:
+#  - \b setSearchMethod(&SearchPtr): passes a search locator
+#  - \b reconstruct(&PolygonMesh): creates a PolygonMesh object from the input data
+# author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+# 
+# template <typename PointInT>
+# class PCLSurfaceBase: public PCLBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass PCLSurfaceBase[In](cpp.PCLBase[In]):
+        PCLSurfaceBase()
+        
+        # brief Provide an optional pointer to a search object.
+        # param[in] tree a pointer to the spatial search object.
+        # inline void setSearchMethod (const KdTreePtr &tree)
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # brief Get a pointer to the search method used.
+        # inline KdTreePtr getSearchMethod ()
+        pclkdt.KdTreePtr_t getSearchMethod ()
+
+#       /** \brief Base method for surface reconstruction for all points given in
+#         * <setInputCloud (), setIndices ()> 
+#         * \param[out] output the resultant reconstructed surface model
+#       virtual void reconstruct (pcl::PolygonMesh &output) = 0;
+
+#       protected:
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+#       /** \brief Abstract class get name method. */
+#       virtual std::string getClassName () const { return (""); }
+###
+
+# /** \brief SurfaceReconstruction represents a base surface reconstruction
+#   * class. All \b surface reconstruction methods take in a point cloud and
+#   * generate a new surface from it, by either re-sampling the data or
+#   * generating new data altogether. These methods are thus \b not preserving
+#   * the topology of the original data.
+#   * \note Reconstruction methods that always preserve the original input
+#   * point cloud data as the surface vertices and simply construct the mesh on
+#   * top should inherit from \ref MeshConstruction.
+#   * \author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+#   * \ingroup surface
+#   */
+# template <typename PointInT>
+# class SurfaceReconstruction: public PCLSurfaceBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass SurfaceReconstruction[In](PCLSurfaceBase[In]):
+        SurfaceReconstruction()
+#       public:
+#       using PCLSurfaceBase<PointInT>::input_;
+#       using PCLSurfaceBase<PointInT>::indices_;
+#       using PCLSurfaceBase<PointInT>::initCompute;
+#       using PCLSurfaceBase<PointInT>::deinitCompute;
+#       using PCLSurfaceBase<PointInT>::tree_;
+#       using PCLSurfaceBase<PointInT>::getClassName;
+#       
+#       /** \brief Base method for surface reconstruction for all points given in
+#        * <setInputCloud (), setIndices ()> 
+#        * \param[out] output the resultant reconstructed surface model
+#        */
+#       virtual void reconstruct (pcl::PolygonMesh &output);
+#       /** \brief Base method for surface reconstruction for all points given in
+#         * <setInputCloud (), setIndices ()> 
+#         * \param[out] points the resultant points lying on the new surface
+#         * \param[out] polygons the resultant polygons, as a set of
+#         * vertices. The Vertices structure contains an array of point indices.
+#         */
+#       virtual void 
+#       reconstruct (pcl::PointCloud<PointInT> &points,
+#                    std::vector<pcl::Vertices> &polygons);
+#       protected:
+#       /** \brief A flag specifying whether or not the derived reconstruction
+#         * algorithm needs the search object \a tree.*/
+#       bool check_tree_;
+#       /** \brief Abstract surface reconstruction method. 
+#         * \param[out] output the output polygonal mesh 
+#         */
+#       virtual void performReconstruction (pcl::PolygonMesh &output) = 0;
+#       /** \brief Abstract surface reconstruction method. 
+#         * \param[out] points the resultant points lying on the surface
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       virtual void 
+#       performReconstruction (pcl::PointCloud<PointInT> &points, 
+#                              std::vector<pcl::Vertices> &polygons) = 0;
+###
+
+# brief MeshConstruction represents a base surface reconstruction
+# class. All \b mesh constructing methods that take in a point cloud and
+# generate a surface that uses the original data as vertices should inherit
+# from this class.
+# 
+# note Reconstruction methods that generate a new surface or create new
+# vertices in locations different than the input data should inherit from
+# \ref SurfaceReconstruction.
+# 
+# author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+# \ingroup surface
+# 
+# template <typename PointInT>
+# class MeshConstruction: public PCLSurfaceBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass MeshConstruction[In](PCLSurfaceBase[In]):
+        MeshConstruction()
+        # public:
+        # using PCLSurfaceBase<PointInT>::input_;
+        # using PCLSurfaceBase<PointInT>::indices_;
+        # using PCLSurfaceBase<PointInT>::initCompute;
+        # using PCLSurfaceBase<PointInT>::deinitCompute;
+        # using PCLSurfaceBase<PointInT>::tree_;
+        # using PCLSurfaceBase<PointInT>::getClassName;
+        
+        # brief Base method for surface reconstruction for all points given in <setInputCloud (), setIndices ()> 
+        # param[out] output the resultant reconstructed surface model
+        # 
+        # note This method copies the input point cloud data from
+        # PointCloud<T> to PointCloud2, and is implemented here for backwards
+        # compatibility only!
+        # 
+        # virtual void reconstruct (pcl::PolygonMesh &output);
+        # brief Base method for mesh construction for all points given in <setInputCloud (), setIndices ()> 
+        # param[out] polygons the resultant polygons, as a set of vertices.
+        # The Vertices structure contains an array of point indices.
+        # 
+        # virtual void reconstruct (std::vector<pcl::Vertices> &polygons);
+        # 
+        # protected:
+        # /** \brief A flag specifying whether or not the derived reconstruction
+        #   * algorithm needs the search object \a tree.*/
+        # bool check_tree_;
+        # /** \brief Abstract surface reconstruction method. 
+        #   * \param[out] output the output polygonal mesh 
+        #   */
+        # virtual void performReconstruction (pcl::PolygonMesh &output) = 0;
+        # /** \brief Abstract surface reconstruction method. 
+        #   * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+        #   */
+        # virtual void performReconstruction (std::vector<pcl::Vertices> &polygons) = 0;
+###
+
+# processing.h
+# namespace pcl
+# brief @b CloudSurfaceProcessing represents the base class for algorithms that take a point cloud as an input and
+# produce a new output cloud that has been modified towards a better surface representation. These types of
+# algorithms include surface smoothing, hole filling, cloud upsampling etc.
+# author Alexandru E. Ichim
+# ingroup surface
+# 
+# template <typename PointInT, typename PointOutT>
+# class CloudSurfaceProcessing : public PCLBase<PointInT>
+cdef extern from "pcl/surface/processing.h" namespace "pcl":
+    cdef cppclass CloudSurfaceProcessing[In, Out](cpp.PCLBase[In]):
+        CloudSurfaceProcessing()
+#       public:
+#       using PCLBase<PointInT>::input_;
+#       using PCLBase<PointInT>::indices_;
+#       using PCLBase<PointInT>::initCompute;
+#       using PCLBase<PointInT>::deinitCompute;
+#       public:
+#       /** \brief Process the input cloud and store the results
+#         * \param[out] output the cloud where the results will be stored
+#       virtual void process (pcl::PointCloud<PointOutT> &output);
+#       protected:
+#       /** \brief Abstract cloud processing method */
+#       virtual void performProcessing (pcl::PointCloud<PointOutT> &output) = 0;
+### 
+
+# /** \brief @b MeshProcessing represents the base class for mesh processing algorithms.
+#   * \author Alexandru E. Ichim
+#   * \ingroup surface
+#   */
+# class PCL_EXPORTS MeshProcessing
+#       public:
+#       typedef PolygonMesh::ConstPtr PolygonMeshConstPtr;
+#       /** \brief Constructor. */
+#       MeshProcessing () : input_mesh_ () {};
+#       /** \brief Destructor. */
+#       virtual ~MeshProcessing () {}
+#       /** \brief Set the input mesh that we want to process
+#         * \param[in] input the input polygonal mesh
+#       void setInputMesh (const pcl::PolygonMeshConstPtr &input) 
+#       /** \brief Process the input surface mesh and store the results
+#         * \param[out] output the resultant processed surface model
+#       void process (pcl::PolygonMesh &output);
+#       protected:
+#       /** \brief Initialize computation. Must be called before processing starts. */
+#       virtual bool initCompute ();
+#       /** \brief UnInitialize computation. Must be called after processing ends. */
+#       virtual void deinitCompute ();
+#       /** \brief Abstract surface processing method. */
+#       virtual void performProcessing (pcl::PolygonMesh &output) = 0;
+#       /** \brief Abstract class get name method. */
+#       virtual std::string getClassName () const { return (""); }
+#       /** \brief Input polygonal mesh. */
+#       pcl::PolygonMeshConstPtr input_mesh_;
+###
+
+
+# (1.6.0)allocator.h
+# (1.7.2) -> pcl/surface/3rdparty/poisson4
+# namespace pcl 
+# namespace poisson 
+# class AllocatorState
+# cdef extern from "pcl/surface/3rdparty/poisson4/allocator.h" namespace "pcl::poisson":
+#     cdef cppclass AllocatorState:
+#         AllocatorState()
+#         # public:
+#         # int index,remains;
+
+
+# (1.6.0) -> allocator.h
+# (1.7.2) -> pcl\surface\3rdparty\poisson4 ?
+# template<class T>
+# class Allocator
+# cdef extern from "pcl/surface/3rdparty/poisson4/allocator.h" namespace "pcl::poisson":
+#     cdef cppclass Allocator[T]:
+#         Allocator()
+        # int blockSize;
+        # int index, remains;
+        # std::vector<T*> memory;
+        # public:
+        # /** This method is the allocators destructor. It frees up any of the memory that
+        #   * it has allocated. 
+        # void reset ()
+        # /** This method returns the memory state of the allocator. */
+        # AllocatorState getState () const
+        # /** This method rolls back the allocator so that it makes all of the memory previously
+        #   * allocated available for re-allocation. Note that it does it not call the constructor
+        #   * again, so after this method has been called, assumptions about the state of the values
+        #   * in memory are no longer valid. 
+        # void rollBack ()
+        # /** This method rolls back the allocator to the previous memory state and makes all of the memory previously
+        #   * allocated available for re-allocation. Note that it does it not call the constructor
+        #   * again, so after this method has been called, assumptions about the state of the values
+        #   * in memory are no longer valid. 
+        # void rollBack (const AllocatorState& state)
+        # /** This method initiallizes the constructor and the blockSize variable specifies the
+        #   * the number of objects that should be pre-allocated at a time. 
+        # void set (const int& blockSize)
+        # /** This method returns a pointer to an array of elements objects. If there is left over pre-allocated
+        #   * memory, this method simply returns a pointer to the next free piece of memory, otherwise it pre-allocates
+        #   * more memory. Note that if the number of objects requested is larger than the value blockSize with which
+        #   * the allocator was initialized, the request for memory will fail.
+        # T* newElements (const int& elements = 1)
+###
+
+# bilateral_upsampling.h
+# namespace pcl
+# /** \brief Bilateral filtering implementation, based on the following paper:
+#   *   * Kopf, Johannes and Cohen, Michael F. and Lischinski, Dani and Uyttendaele, Matt - Joint Bilateral Upsampling,
+#   *   * ACM Transations in Graphics, July 2007
+#   * Takes in a colored organized point cloud (i.e. PointXYZRGB or PointXYZRGBA), that might contain nan values for the
+#   * depth information, and it will returned an upsampled version of this cloud, based on the formula:
+#   * \f[
+#   *    \tilde{S}_p = \frac{1}{k_p} \sum_{q_d \in \Omega} {S_{q_d} f(||p_d - q_d|| g(||\tilde{I}_p-\tilde{I}_q||})
+#   * \f]
+#   * where S is the depth image, I is the RGB image and f and g are Gaussian functions centered at 0 and with
+#   * standard deviations \f$\sigma_{color}\f$ and \f$\sigma_{depth}\f$
+#   */
+# template <typename PointInT, typename PointOutT>
+# class BilateralUpsampling: public CloudSurfaceProcessing<PointInT, PointOutT>
+cdef extern from "pcl/surface/bilateral_upsampling.h" namespace "pcl":
+    cdef cppclass BilateralUpsampling[In, Out](CloudSurfaceProcessing[In, Out]):
+        BilateralUpsampling()
+        # public:
+        # using PCLBase<PointInT>::input_;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::initCompute;
+        # using PCLBase<PointInT>::deinitCompute;
+        # using CloudSurfaceProcessing<PointInT, PointOutT>::process;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # Eigen::Matrix3f KinectVGAProjectionMatrix, KinectSXGAProjectionMatrix;
+        # /** \brief Method that sets the window size for the filter
+        #   * \param[in] window_size the given window size
+        # inline void setWindowSize (int window_size)
+        # /** \brief Returns the filter window size */
+        # inline int getWindowSize () const
+        # /** \brief Method that sets the sigma color parameter
+        #   * \param[in] sigma_color the new value to be set
+        # inline void setSigmaColor (const float &sigma_color)
+        # /** \brief Returns the current sigma color value */
+        # inline float getSigmaColor () const
+        # /** \brief Method that sets the sigma depth parameter
+        #   * \param[in] sigma_depth the new value to be set
+        # inline void setSigmaDepth (const float &sigma_depth)
+        # /** \brief Returns the current sigma depth value */
+        # inline float getSigmaDepth () const
+        # /** \brief Method that sets the projection matrix to be used when unprojecting the points in the depth image
+        #   * back to (x,y,z) positions.
+        #   * \note There are 2 matrices already set in the class, used for the 2 modes available for the Kinect. They
+        #   * are tuned to be the same as the ones in the OpenNiGrabber
+        #   * \param[in] projection_matrix the new projection matrix to be set */
+        # inline void setProjectionMatrix (const Eigen::Matrix3f &projection_matrix)
+        # /** \brief Returns the current projection matrix */
+        # inline Eigen::Matrix3f getProjectionMatrix () const
+        # /** \brief Method that does the actual processing on the input cloud.
+        #   * \param[out] output the container of the resulting upsampled cloud */
+        # void process (pcl::PointCloud<PointOutT> &output)
+        # protected:
+        # void performProcessing (pcl::PointCloud<PointOutT> &output);
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+
+# binary_node.h (1.6.0)
+# pcl/surface/3rdparty\poisson4\binary_node.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# template<class Real>
+# class BinaryNode
+# cdef extern from "pcl/surface/3rdparty/poisson4/binary_node.h" namespace "pcl::poisson":
+#    cdef cppclass BinaryNode[Real]:
+#        BinaryNode()
+        # public:
+        # static inline int CenterCount (int depth){return 1<<depth;}
+        # static inline int CumulativeCenterCount (int maxDepth){return  (1<< (maxDepth+1))-1;}
+        # static inline int Index (int depth,  int offSet){return  (1<<depth)+offSet-1;}
+        # static inline int CornerIndex (int maxDepth, int depth, int offSet, int forwardCorner)
+        # static inline Real CornerIndexPosition (int index, int maxDepth)
+        # static inline Real Width (int depth)
+        # 
+        # // Fix for Bug #717 with Visual Studio that generates wrong code for this function
+        # // when global optimization is enabled (release mode).
+        # #ifdef _MSC_VER
+        #   static __declspec(noinline) void CenterAndWidth (int depth, int offset, Real& center, Real& width)
+        # #else
+        # static inline void CenterAndWidth (int depth, int offset, Real& center, Real& width)
+        # # #endif
+        # 
+        # #ifdef _MSC_VER
+        # static __declspec(noinline) void CenterAndWidth (int idx, Real& center, Real& width)
+        # #else
+        # static inline void CenterAndWidth (int idx, Real& center, Real& width)
+        # #endif
+        # static inline void DepthAndOffset (int idx,  int& depth, int& offset)
+###
+
+# concave_hull.h
+# namespace pcl
+# template<typename PointInT>
+# class ConcaveHull : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/concave_hull.h" namespace "pcl":
+    cdef cppclass ConcaveHull[In](MeshConstruction[In]):
+        ConcaveHull()
+        # public:
+        # \brief Compute a concave hull for all points given 
+        # \param points the resultant points lying on the concave hull 
+        # \param polygons the resultant concave hull polygons, as a set of
+        # vertices. The Vertices structure contains an array of point indices.
+        # void reconstruct (PointCloud &points, std::vector<pcl::Vertices> &polygons);
+        
+        # /** \brief Compute a concave hull for all points given 
+        #  * \param output the resultant concave hull vertices
+        # void reconstruct (PointCloud &output);
+        void reconstruct (cpp.PointCloud_t output)
+        void reconstruct (cpp.PointCloud_PointXYZI_t output)
+        void reconstruct (cpp.PointCloud_PointXYZRGB_t output)
+        void reconstruct (cpp.PointCloud_PointXYZRGBA_t output)
+        
+        # /** \brief Set the alpha value, which limits the size of the resultant
+        #   * hull segments (the smaller the more detailed the hull).  
+        #   * \param alpha positive, non-zero value, defining the maximum length
+        #   * from a vertex to the facet center (center of the voronoi cell).
+        # inline void setAlpha (double alpha)
+        void setAlpha (double alpha)
+        # Returns the alpha parameter, see setAlpha().
+        # inline double getAlpha ()
+        double getAlpha ()
+        
+        # If set, the voronoi cells center will be saved in _voronoi_centers_
+        # voronoi_centers
+        # inline void setVoronoiCenters (PointCloudPtr voronoi_centers)
+        
+        # \brief If keep_information_is set to true the convex hull
+        # points keep other information like rgb, normals, ...
+        # \param value where to keep the information or not, default is false
+        # void setKeepInformation (bool value)
+        
+        # brief Returns the dimensionality (2 or 3) of the calculated hull.
+        # inline int getDim () const
+        # brief Returns the dimensionality (2 or 3) of the calculated hull.
+        # inline int getDimension () const
+        # brief Sets the dimension on the input data, 2D or 3D.
+        # param[in] dimension The dimension of the input data.  If not set, this will be determined automatically.
+        # void setDimension (int dimension)
+        
+        # protected:
+        # /** \brief The actual reconstruction method.
+        #   * \param points the resultant points lying on the concave hull 
+        #   * \param polygons the resultant concave hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   */
+        # void performReconstruction (PointCloud &points, 
+        #                        std::vector<pcl::Vertices> &polygons);
+        # virtual void performReconstruction (PolygonMesh &output);
+        # virtual void performReconstruction (std::vector<pcl::Vertices> &polygons);
+        # /** \brief The method accepts facets only if the distance from any vertex to the facet->center 
+        #   * (center of the voronoi cell) is smaller than alpha 
+        # double alpha_;
+        # /** \brief If set to true, the reconstructed point cloud describing the hull is obtained from 
+        #   * the original input cloud by performing a nearest neighbor search from Qhull output. 
+        # bool keep_information_;
+        # /** \brief the centers of the voronoi cells */
+        # PointCloudPtr voronoi_centers_;
+        # /** \brief the dimensionality of the concave hull */
+        # int dim_;
+        
+
+
+ctypedef ConcaveHull[cpp.PointXYZ] ConcaveHull_t
+ctypedef ConcaveHull[cpp.PointXYZI] ConcaveHull_PointXYZI_t
+ctypedef ConcaveHull[cpp.PointXYZRGB] ConcaveHull_PointXYZRGB_t
+ctypedef ConcaveHull[cpp.PointXYZRGBA] ConcaveHull_PointXYZRGBA_t
+
+###
+
+# convex_hull.h
+# namespace pcl
+# /** \brief Sort 2D points in a vector structure
+#   * \param p1 the first point
+#   * \param p2 the second point
+#   * \ingroup surface
+#   */
+# inline bool
+# comparePoints2D (const std::pair<int, Eigen::Vector4f> & p1, const std::pair<int, Eigen::Vector4f> & p2)
+# 
+# template<typename PointInT>
+# class ConvexHull : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/convex_hull.h" namespace "pcl":
+    cdef cppclass ConvexHull[In](MeshConstruction[In]):
+        ConvexHull()
+        # protected:
+        # using PCLBase<PointInT>::input_;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::initCompute;
+        # using PCLBase<PointInT>::deinitCompute;
+        # public:
+        # using MeshConstruction<PointInT>::reconstruct;
+        # typedef pcl::PointCloud<PointInT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # 
+        # /** \brief Compute a convex hull for all points given 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        # void reconstruct (PointCloud &points, 
+        #              std::vector<pcl::Vertices> &polygons);
+        # /** \brief Compute a convex hull for all points given 
+        #   * \param[out] output the resultant convex hull vertices
+        # void reconstruct (PointCloud &output);
+        # /** \brief If set to true, the qhull library is called to compute the total area and volume of the convex hull.
+        #   * NOTE: When this option is activated, the qhull library produces output to the console.
+        #   * \param[in] value wheter to compute the area and the volume, default is false
+        # void setComputeAreaVolume (bool value)
+        # /** \brief Returns the total area of the convex hull. */
+        # double getTotalArea () const
+        # /** \brief Returns the total volume of the convex hull. Only valid for 3-dimensional sets.
+        #   *  For 2D-sets volume is zero. 
+        # double getTotalVolume () const
+        # /** \brief Sets the dimension on the input data, 2D or 3D.
+        #   * \param[in] dimension The dimension of the input data.  If not set, this will be determined automatically.
+        # void setDimension (int dimension)
+        # /** \brief Returns the dimensionality (2 or 3) of the calculated hull. */
+        # inline int getDimension () const
+        # 
+        # protected:
+        # /** \brief The actual reconstruction method. 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   * \param[in] fill_polygon_data true if polygons should be filled, false otherwise
+        #   */
+        # void
+        # performReconstruction (PointCloud &points, 
+        #                        std::vector<pcl::Vertices> &polygons, 
+        #                        bool fill_polygon_data = false);
+        # /** \brief The reconstruction method for 2D data.  Does not require dimension to be set. 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   * \param[in] fill_polygon_data true if polygons should be filled, false otherwise
+        # void
+        # performReconstruction2D (PointCloud &points, 
+        #                          std::vector<pcl::Vertices> &polygons, 
+        #                          bool fill_polygon_data = false);
+        # /** \brief The reconstruction method for 3D data.  Does not require dimension to be set. 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   * \param[in] fill_polygon_data true if polygons should be filled, false otherwise
+        # void
+        # performReconstruction3D (PointCloud &points, 
+        #                          std::vector<pcl::Vertices> &polygons, 
+        #                          bool fill_polygon_data = false);
+        # /** \brief A reconstruction method that returns a polygonmesh.
+        #   *
+        #   * \param[out] output a PolygonMesh representing the convex hull of the input data.
+        #   */
+        # virtual void
+        # performReconstruction (PolygonMesh &output);
+        # 
+        # /** \brief A reconstruction method that returns the polygon of the convex hull.
+        #   *
+        #   * \param[out] polygons the polygon(s) representing the convex hull of the input data.
+        #   */
+        # virtual void
+        # performReconstruction (std::vector<pcl::Vertices> &polygons);
+        # 
+        # /** \brief Automatically determines the dimension of input data - 2D or 3D. */
+        # void 
+        # calculateInputDimension ();
+        # 
+        # /** \brief Class get name method. */
+        # std::string getClassName () const
+        # 
+        # /* \brief True if we should compute the area and volume of the convex hull. */
+        # bool compute_area_;
+        # /* \brief The area of the convex hull. */
+        # double total_area_;
+        # /* \brief The volume of the convex hull (only for 3D hulls, zero for 2D). */
+        # double total_volume_;
+        # /** \brief The dimensionality of the concave hull (2D or 3D). */
+        # int dimension_;
+        # /** \brief How close can a 2D plane's normal be to an axis to make projection problematic. */
+        # double projection_angle_thresh_;
+        # /** \brief Option flag string to be used calling qhull. */
+        # std::string qhull_flags;
+        # /* \brief x-axis - for checking valid projections. */
+        # const Eigen::Vector3f x_axis_;
+        # /* \brief y-axis - for checking valid projections. */
+        # const Eigen::Vector3f y_axis_;
+        # /* \brief z-axis - for checking valid projections. */
+        # const Eigen::Vector3f z_axis_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+
+# ear_clipping.h
+# namespace pcl
+# /** \brief The ear clipping triangulation algorithm.
+#   * The code is inspired by Flavien Brebion implementation, which is
+#   * in n^3 and does not handle holes.
+#   * \author Nicolas Burrus
+#   * \ingroup surface
+# class PCL_EXPORTS EarClipping : public MeshProcessing
+#       public:
+#       using MeshProcessing::input_mesh_;
+#       using MeshProcessing::initCompute;
+#       /** \brief Empty constructor */
+#       EarClipping () : MeshProcessing (), points_ ()
+#       { 
+#       };
+# 
+#       protected:
+#       /** \brief a Pointer to the point cloud data. */
+#       pcl::PointCloud<pcl::PointXYZ>::Ptr points_;
+# 
+#       /** \brief This method should get called before starting the actual computation. */
+#       bool initCompute ();
+#       /** \brief The actual surface reconstruction method. 
+#         * \param[out] output the output polygonal mesh 
+#         */
+#       void performProcessing (pcl::PolygonMesh &output);
+# 
+#       /** \brief Triangulate one polygon. 
+#         * \param[in] vertices the set of vertices
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void triangulate (const Vertices& vertices, PolygonMesh& output);
+# 
+#       /** \brief Compute the signed area of a polygon. 
+#         * \param[in] vertices the vertices representing the polygon 
+#         */
+#       float area (const std::vector<uint32_t>& vertices);
+# 
+#       /** \brief Check if the triangle (u,v,w) is an ear. 
+#         * \param[in] u the first triangle vertex 
+#         * \param[in] v the second triangle vertex 
+#         * \param[in] w the third triangle vertex 
+#         * \param[in] vertices a set of input vertices
+#         */
+#       bool isEar (int u, int v, int w, const std::vector<uint32_t>& vertices);
+# 
+#       /** \brief Check if p is inside the triangle (u,v,w). 
+#         * \param[in] u the first triangle vertex 
+#         * \param[in] v the second triangle vertex 
+#         * \param[in] w the third triangle vertex 
+#         * \param[in] p the point to check
+#         */
+#       bool isInsideTriangle (const Eigen::Vector2f& u,
+#                         const Eigen::Vector2f& v,
+#                         const Eigen::Vector2f& w,
+#                         const Eigen::Vector2f& p);
+# 
+# 
+#       /** \brief Compute the cross product between 2D vectors.
+#        * \param[in] p1 the first 2D vector
+#        * \param[in] p2 the first 2D vector
+#        */
+#       float crossProduct (const Eigen::Vector2f& p1, const Eigen::Vector2f& p2) const
+###
+
+# factor.h(1.6.0)
+# pcl/surface/3rdparty/poisson4/factor.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# 
+#     double ArcTan2 (const double& y, const double& x);
+#     double Angle (const double in[2]);
+#     void Sqrt (const double in[2], double out[2]);
+#     void Add (const double in1[2], const double in2[2], double out[2]);
+#     void Subtract (const double in1[2], const double in2[2], double out[2]);
+#     void Multiply (const double in1[2], const double in2[2], double out[2]);
+#     void Divide (const double in1[2], const double in2[2], double out[2]);
+# 
+#     int Factor (double a1, double a0, double roots[1][2], const double& EPS);
+#     int Factor (double a2, double a1, double a0, double roots[2][2], const double& EPS);
+#     int Factor (double a3, double a2, double a1, double a0, double roots[3][2], const double& EPS);
+#     int Factor (double a4, double a3, double a2, double a1, double a0, double roots[4][2], const double& EPS);
+# 
+#     int Solve (const double* eqns, const double* values, double* solutions, const int& dim);
+###
+
+# function_data.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/function_data.h (1.7.2)
+# namespace pcl 
+# namespace poisson 
+# template<int Degree,class Real>
+# class FunctionData
+# cdef extern from "pcl/surface/function_data.h" namespace "pcl::poisson":
+#     cdef cppclass FunctionData:
+#         FunctionData()
+#         int useDotRatios;
+#         int normalize;
+#         public:
+#         const static int DOT_FLAG;
+#         const static int D_DOT_FLAG;
+#         const static int D2_DOT_FLAG;
+#         const static int VALUE_FLAG;
+#         const static int D_VALUE_FLAG;
+#         int depth, res, res2;
+#         Real *dotTable, *dDotTable, *d2DotTable;
+#         Real *valueTables, *dValueTables;
+#         PPolynomial<Degree> baseFunction;
+#         PPolynomial<Degree-1> dBaseFunction;
+#         PPolynomial<Degree+1>* baseFunctions;
+#         virtual void setDotTables (const int& flags);
+#         virtual void clearDotTables (const int& flags);
+#         virtual void setValueTables (const int& flags, const double& smooth = 0);
+#         virtual void setValueTables (const int& flags, const double& valueSmooth, const double& normalSmooth);
+#         virtual void clearValueTables (void);
+#         void set (const int& maxDepth, const PPolynomial<Degree>& F, const int& normalize, const int& useDotRatios = 1);
+#         Real dotProduct (const double& center1, const double& width1,
+#                          const double& center2, const double& width2) const;
+#         Real dDotProduct (const double& center1, const double& width1,
+#                           const double& center2, const double& width2) const;
+#         Real d2DotProduct (const double& center1, const double& width1,
+#                            const double& center2, const double& width2) const;
+#         static inline int SymmetricIndex (const int& i1, const int& i2);
+#         static inline int SymmetricIndex (const int& i1, const int& i2, int& index);
+###
+
+# geometry.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/geometry.h (1.7.2)
+# namespace pcl
+# namespace poisson 
+#   {
+#     template<class Real>
+#     Real Random (void);
+# 
+#     template<class Real>
+#     struct Point3D{Real coords[3];};
+# 
+#     template<class Real>
+#     Point3D<Real> RandomBallPoint (void);
+# 
+#     template<class Real>
+#     Point3D<Real> RandomSpherePoint (void);
+# 
+#     template<class Real>
+#     double Length (const Point3D<Real>& p);
+# 
+#     template<class Real>
+#     double SquareLength (const Point3D<Real>& p);
+# 
+#     template<class Real>
+#     double Distance (const Point3D<Real>& p1, const Point3D<Real>& p2);
+# 
+#     template<class Real>
+#     double SquareDistance (const Point3D<Real>& p1, const Point3D<Real>& p2);
+# 
+#     template <class Real>
+#     void CrossProduct (const Point3D<Real>& p1, const Point3D<Real>& p2, Point3D<Real>& p);
+# 
+#     class Edge
+#     {
+#       public:
+#         double p[2][2];
+#         double Length (void) const
+#         {
+#           double d[2];
+#           d[0]=p[0][0]-p[1][0];
+#           d[1]=p[0][1]-p[1][1];
+# 
+#           return sqrt (d[0]*d[0]+d[1]*d[1]);
+#         }
+#     };
+#     
+#     class Triangle
+#     {
+#       public:
+#         double p[3][3];
+#         
+#         double 
+#         Area (void) const
+#         {
+#           double v1[3], v2[3], v[3];
+#           for (int d=0;d<3;d++)
+#           {
+#             v1[d] = p[1][d]-p[0][d];
+#             v2[d] = p[2][d]-p[0][d];
+#           }
+#           v[0] =  v1[1]*v2[2]-v1[2]*v2[1];
+#           v[1] = -v1[0]*v2[2]+v1[2]*v2[0];
+#           v[2] =  v1[0]*v2[1]-v1[1]*v2[0];
+# 
+#           return (sqrt (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) / 2);
+#         }
+# 
+#         double 
+#         AspectRatio (void) const
+#         {
+#           double d=0;
+#           int i, j;
+#           for (i = 0; i < 3; i++)
+#           {
+#             for (i = 0; i < 3; i++)
+#               for (j = 0; j < 3; j++)
+#               {
+#                 d += (p[(i+1)%3][j]-p[i][j])* (p[(i+1)%3][j]-p[i][j]);
+#               }
+#           }
+#           return (Area () / d);
+#         }
+#     };
+# 
+#     class CoredPointIndex
+#     {
+#       public:
+#         int index;
+#         char inCore;
+# 
+#         int operator == (const CoredPointIndex& cpi) const {return (index==cpi.index) && (inCore==cpi.inCore);};
+#         int operator != (const CoredPointIndex& cpi) const {return (index!=cpi.index) || (inCore!=cpi.inCore);};
+#     };
+# 
+#     class EdgeIndex
+#     {
+#       public:
+#         int idx[2];
+#     };
+# 
+#     class CoredEdgeIndex
+#     {
+#       public:
+#         CoredPointIndex idx[2];
+#     };
+# 
+#     class TriangleIndex
+#     {
+#       public:
+#         int idx[3];
+#     };
+# 
+#     class TriangulationEdge
+#     {
+#       public:
+#         TriangulationEdge (void);
+#         int pIndex[2];
+#         int tIndex[2];
+#     };
+# 
+#     class TriangulationTriangle
+#     {
+#       public:
+#         TriangulationTriangle (void);
+#         int eIndex[3];
+#     };
+# 
+#     template<class Real>
+#     class Triangulation
+#     {
+#       public:
+#         Triangulation () : points (),  edges (),  triangles (),  edgeMap () {}
+# 
+#         std::vector<Point3D<Real> >        points;
+#         std::vector<TriangulationEdge>     edges;
+#         std::vector<TriangulationTriangle> triangles;
+# 
+#         int 
+#         factor (const int& tIndex, int& p1, int& p2, int& p3);
+#         
+#         double 
+#         area (void);
+# 
+#         double 
+#         area (const int& tIndex);
+# 
+#         double 
+#         area (const int& p1, const int& p2, const int& p3);
+# 
+#         int 
+#         flipMinimize (const int& eIndex);
+# 
+#         int 
+#         addTriangle (const int& p1, const int& p2, const int& p3);
+# 
+#       protected:
+#         hash_map<long long, int> edgeMap;
+#         static long long EdgeIndex (const int& p1, const int& p2);
+#         double area (const Triangle& t);
+#     };
+# 
+# 
+#     template<class Real> void 
+#     EdgeCollapse (const Real& edgeRatio,
+#                   std::vector<TriangleIndex>& triangles,
+#                   std::vector< Point3D<Real> >& positions,
+#                   std::vector<Point3D<Real> >* normals);
+#     
+#     template<class Real> void 
+#     TriangleCollapse (const Real& edgeRatio,
+#                       std::vector<TriangleIndex>& triangles,
+#                       std::vector<Point3D<Real> >& positions,
+#                       std::vector<Point3D<Real> >* normals);
+# 
+#     struct CoredVertexIndex
+#     {
+#       int idx;
+#       bool inCore;
+#     };
+# 
+#     class CoredMeshData
+#     {
+#       public:
+#         CoredMeshData () : inCorePoints () {}
+# 
+#         virtual ~CoredMeshData () {}
+# 
+#         std::vector<Point3D<float> > inCorePoints;
+#         
+#         virtual void 
+#         resetIterator () = 0;
+# 
+#         virtual int 
+#         addOutOfCorePoint (const Point3D<float>& p) = 0;
+# 
+#         virtual int 
+#         addPolygon (const std::vector< CoredVertexIndex >& vertices) = 0;
+# 
+#         virtual int 
+#         nextOutOfCorePoint (Point3D<float>& p) = 0;
+#         
+#         virtual int 
+#         nextPolygon (std::vector<CoredVertexIndex >& vertices) = 0;
+# 
+#         virtual int 
+#         outOfCorePointCount () = 0;
+#         
+#         virtual int 
+#         polygonCount () = 0;
+#     };
+# 
+#     class CoredVectorMeshData : public CoredMeshData
+#     {
+#       std::vector<Point3D<float> > oocPoints;
+#       std::vector< std::vector< int > > polygons;
+#       int polygonIndex;
+#       int oocPointIndex;
+# 
+#       public:
+#         CoredVectorMeshData ();
+#         
+#         virtual ~CoredVectorMeshData () {}
+# 
+#         void resetIterator (void);
+# 
+#         int addOutOfCorePoint (const Point3D<float>& p);
+#         int addPolygon (const std::vector< CoredVertexIndex >& vertices);
+# 
+#         int nextOutOfCorePoint (Point3D<float>& p);
+#         int nextPolygon (std::vector< CoredVertexIndex >& vertices);
+# 
+#         int outOfCorePointCount (void);
+#         int polygonCount (void);
+#     };
+# 
+#     class CoredFileMeshData : public CoredMeshData
+#     {
+#       FILE *oocPointFile ,  *polygonFile;
+#       int oocPoints ,  polygons;
+#       public:
+#         CoredFileMeshData ();
+#         virtual ~CoredFileMeshData ();
+# 
+#         void resetIterator (void);
+# 
+#         int addOutOfCorePoint (const Point3D<float>& p);
+#         int addPolygon (const std::vector< CoredVertexIndex >& vertices);
+# 
+#         int nextOutOfCorePoint (Point3D<float>& p);
+#         int nextPolygon (std::vector< CoredVertexIndex >& vertices);
+# 
+#         int outOfCorePointCount (void);
+#         int polygonCount (void);
+#     };
+#   }
+# 
+###
+
+# gp3.h
+# namespace pcl
+#   /** \brief Returns if a point X is visible from point R (or the origin)
+#     * when taking into account the segment between the points S1 and S2
+#     * \param X 2D coordinate of the point
+#     * \param S1 2D coordinate of the segment's first point
+#     * \param S2 2D coordinate of the segment's secont point
+#     * \param R 2D coorddinate of the reference point (defaults to 0,0)
+#     * \ingroup surface
+#     */
+#   inline bool 
+#   isVisible (const Eigen::Vector2f &X, const Eigen::Vector2f &S1, const Eigen::Vector2f &S2, 
+#              const Eigen::Vector2f &R = Eigen::Vector2f::Zero ())
+# 
+# /** \brief GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points
+#   * based on local 2D projections. It assumes locally smooth surfaces and relatively smooth transitions between
+#   * areas with different point densities.
+#   * \author Zoltan Csaba Marton
+#   * \ingroup surface
+#   */
+# template <typename PointInT>
+# class GreedyProjectionTriangulation : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/gp3.h" namespace "pcl::poisson":
+    cdef cppclass GreedyProjectionTriangulation[In](MeshConstruction[In]):
+        GreedyProjectionTriangulation()
+#       public:
+#       using MeshConstruction<PointInT>::tree_;
+#       using MeshConstruction<PointInT>::input_;
+#       using MeshConstruction<PointInT>::indices_;
+#       typedef typename pcl::KdTree<PointInT> KdTree;
+#       typedef typename pcl::KdTree<PointInT>::Ptr KdTreePtr;
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       typedef typename PointCloudIn::Ptr PointCloudInPtr;
+#       typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+#       // FIXME this enum should have a type.  Not be anonymous. 
+#       // Otherplaces where consts are used probably should be fixed.
+#       enum 
+#       { 
+#         NONE = -1,    // not-defined
+#         FREE = 0,    
+#         FRINGE = 1,  
+#         BOUNDARY = 2,
+#         COMPLETED = 3
+#       };
+# 
+#       /** \brief Set the multiplier of the nearest neighbor distance to obtain the final search radius for each point
+#        *  (this will make the algorithm adapt to different point densities in the cloud).
+#        * \param[in] mu the multiplier
+#       inline void setMu (double mu)
+#       /** \brief Get the nearest neighbor distance multiplier. */
+#       inline double getMu ()
+#       /** \brief Set the maximum number of nearest neighbors to be searched for.
+#         * \param[in] nnn the maximum number of nearest neighbors
+#       inline void setMaximumNearestNeighbors (int nnn)
+#       /** \brief Get the maximum number of nearest neighbors to be searched for. */
+#       inline int getMaximumNearestNeighbors ()
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors used for triangulating.
+#         * \param[in] radius the sphere radius that is to contain all k-nearest neighbors
+#         * \note This distance limits the maximum edge length!
+#       inline void setSearchRadius (double radius)
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       inline double getSearchRadius ()
+#       /** \brief Set the minimum angle each triangle should have.
+#         * \param[in] minimum_angle the minimum angle each triangle should have
+#         * \note As this is a greedy approach, this will have to be violated from time to time
+#       inline void setMinimumAngle (double minimum_angle)
+#       /** \brief Get the parameter for distance based weighting of neighbors. */
+#       inline double getMinimumAngle ()
+#       /** \brief Set the maximum angle each triangle can have.
+#         * \param[in] maximum_angle the maximum angle each triangle can have
+#         * \note For best results, its value should be around 120 degrees
+#       inline void setMaximumAngle (double maximum_angle)
+#       /** \brief Get the parameter for distance based weighting of neighbors. */
+#       inline double getMaximumAngle ()
+#       /** \brief Don't consider points for triangulation if their normal deviates more than this value from the query point's normal.
+#         * \param[in] eps_angle maximum surface angle
+#         * \note As normal estimation methods usually give smooth transitions at sharp edges, this ensures correct triangulation
+#         *       by avoiding connecting points from one side to points from the other through forcing the use of the edge points.
+#       inline void setMaximumSurfaceAngle (double eps_angle)
+#       /** \brief Get the maximum surface angle. */
+#       inline double getMaximumSurfaceAngle ()
+#       /** \brief Set the flag if the input normals are oriented consistently.
+#         * \param[in] consistent set it to true if the normals are consistently oriented
+#       inline void setNormalConsistency (bool consistent)
+#       /** \brief Get the flag for consistently oriented normals. */
+#       inline bool getNormalConsistency ()
+#       /** \brief Set the flag to order the resulting triangle vertices consistently (positive direction around normal).
+#         * @note Assumes consistently oriented normals (towards the viewpoint) -- see setNormalConsistency ()
+#         * \param[in] consistent_ordering set it to true if triangle vertices should be ordered consistently
+#       inline void setConsistentVertexOrdering (bool consistent_ordering)
+#       /** \brief Get the flag signaling consistently ordered triangle vertices. */
+#       inline bool getConsistentVertexOrdering ()
+#       /** \brief Get the state of each point after reconstruction.
+#         * \note Options are defined as constants: FREE, FRINGE, COMPLETED, BOUNDARY and NONE
+#       inline std::vector<int> getPointStates ()
+#       /** \brief Get the ID of each point after reconstruction.
+#         * \note parts are numbered from 0, a -1 denotes unconnected points
+#       inline std::vector<int> getPartIDs ()
+#       /** \brief Get the sfn list. */
+#       inline std::vector<int> getSFN ()
+#       /** \brief Get the ffn list. */
+#       inline std::vector<int> getFFN ()
+#       protected:
+#       /** \brief The nearest neighbor distance multiplier to obtain the final search radius. */
+#       double mu_;
+#       /** \brief The nearest neighbors search radius for each point and the maximum edge length. */
+#       double search_radius_;
+#       /** \brief The maximum number of nearest neighbors accepted by searching. */
+#       int nnn_;
+#       /** \brief The preferred minimum angle for the triangles. */
+#       double minimum_angle_;
+#       /** \brief The maximum angle for the triangles. */
+#       double maximum_angle_;
+#       /** \brief Maximum surface angle. */
+#       double eps_angle_;
+#       /** \brief Set this to true if the normals of the input are consistently oriented. */
+#       bool consistent_;
+#       /** \brief Set this to true if the output triangle vertices should be consistently oriented. */
+#       bool consistent_ordering_;
+###
+
+# grid_projection.h
+# namespace pcl
+# {
+#   /** \brief The 12 edges of a cell. */
+#   const int I_SHIFT_EP[12][2] = {
+#     {0, 4}, {1, 5}, {2, 6}, {3, 7}, 
+#     {0, 1}, {1, 2}, {2, 3}, {3, 0},
+#     {4, 5}, {5, 6}, {6, 7}, {7, 4}
+#   };
+# 
+#   const int I_SHIFT_PT[4] = {
+#     0, 4, 5, 7
+#   };
+# 
+#   const int I_SHIFT_EDGE[3][2] = {
+#     {0,1}, {1,3}, {1,2}
+#   };
+# 
+# 
+#   /** \brief Grid projection surface reconstruction method.
+#     * \author Rosie Li
+#     *
+#     * \note If you use this code in any academic work, please cite:
+#     *   - Ruosi Li, Lu Liu, Ly Phan, Sasakthi Abeysinghe, Cindy Grimm, Tao Ju.
+#     *     Polygonizing extremal surfaces with manifold guarantees.
+#     *     In Proceedings of the 14th ACM Symposium on Solid and Physical Modeling, 2010.
+#      * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class GridProjection : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+#       /** \brief Data leaf. */
+#       struct Leaf
+#       {
+#         Leaf () : data_indices (), pt_on_surface (), vect_at_grid_pt () {}
+# 
+#         std::vector<int> data_indices;
+#         Eigen::Vector4f pt_on_surface; 
+#         Eigen::Vector3f vect_at_grid_pt;
+#       };
+# 
+#       typedef boost::unordered_map<int, Leaf, boost::hash<int>, std::equal_to<int>, Eigen::aligned_allocator<int> > HashMap;
+# 
+#       /** \brief Constructor. */ 
+#       GridProjection ();
+# 
+#       /** \brief Constructor. 
+#         * \param in_resolution set the resolution of the grid
+#         */ 
+#       GridProjection (double in_resolution);
+# 
+#       /** \brief Destructor. */
+#       ~GridProjection ();
+# 
+#       /** \brief Set the size of the grid cell
+#         * \param resolution  the size of the grid cell
+#         */
+#       inline void 
+#       setResolution (double resolution)
+#       {
+#         leaf_size_ = resolution;
+#       }
+# 
+#       inline double 
+#       getResolution () const
+#       {
+#         return (leaf_size_);
+#       }
+# 
+#       /** \brief When averaging the vectors, we find the union of all the input data 
+#         *  points within the padding area,and do a weighted average. Say if the padding
+#         *  size is 1, when we process cell (x,y,z), we will find union of input data points
+#         *  from (x-1) to (x+1), (y-1) to (y+1), (z-1) to (z+1)(in total, 27 cells). In this
+#         *  way, even the cells itself doesnt contain any data points, we will stil process it
+#         *  because there are data points in the padding area. This can help us fix holes which 
+#         *  is smaller than the padding size.
+#         * \param padding_size The num of padding cells we want to create 
+#         */
+#       inline void 
+#       setPaddingSize (int padding_size)
+#       {
+#         padding_size_ = padding_size;
+#       }
+#       inline int 
+#       getPaddingSize () const
+#       {
+#         return (padding_size_);
+#       }
+# 
+#       /** \brief Set this only when using the k nearest neighbors search 
+#         * instead of finding the point union
+#         * \param k The number of nearest neighbors we are looking for
+#         */
+#       inline void 
+#       setNearestNeighborNum (int k)
+#       {
+#         k_ = k;
+#       }
+#       inline int 
+#       getNearestNeighborNum () const
+#       {
+#         return (k_);
+#       }
+# 
+#       /** \brief Binary search is used in projection. given a point x, we find another point
+#         *  which is 3*cell_size_ far away from x. Then we do a binary search between these 
+#         *  two points to find where the projected point should be.
+#         */
+#       inline void 
+#       setMaxBinarySearchLevel (int max_binary_search_level)
+#       {
+#         max_binary_search_level_ = max_binary_search_level;
+#       }
+#       inline int 
+#       getMaxBinarySearchLevel () const
+#       {
+#         return (max_binary_search_level_);
+#       }
+# 
+#       ///////////////////////////////////////////////////////////
+#       inline const HashMap& 
+#       getCellHashMap () const
+#       {
+#         return (cell_hash_map_);
+#       }
+# 
+#       inline const std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> >& 
+#       getVectorAtDataPoint () const
+#       {
+#         return (vector_at_data_point_);
+#       }
+#       
+#       inline const std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& 
+#       getSurface () const
+#       {
+#         return (surface_);
+#       }
+# 
+#     protected:
+#       /** \brief Get the bounding box for the input data points, also calculating the
+#         * cell size, and the gaussian scale factor
+#         */
+#       void 
+#       getBoundingBox ();
+# 
+#       /** \brief The actual surface reconstruction method.
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       bool
+#       reconstructPolygons (std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Create the surface. 
+#         *
+#         * The 1st step is filling the padding, so that all the cells in the padding
+#         * area are in the hash map. The 2nd step is store the vector, and projected
+#         * point. The 3rd step is finding all the edges intersects the surface, and
+#         * creating surface.
+#         *
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void 
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Create the surface. 
+#         *
+#         * The 1st step is filling the padding, so that all the cells in the padding
+#         * area are in the hash map. The 2nd step is store the vector, and projected
+#         * point. The 3rd step is finding all the edges intersects the surface, and
+#         * creating surface.
+#         *
+#         * \param[out] points the resultant points lying on the surface
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       void 
+#       performReconstruction (pcl::PointCloud<PointNT> &points, 
+#                              std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief When the input data points don't fill into the 1*1*1 box, 
+#         * scale them so that they can be filled in the unit box. Otherwise, 
+#         * it will be some drawing problem when doing visulization
+#         * \param scale_factor scale all the input data point by scale_factor
+#         */
+#       void 
+#       scaleInputDataPoint (double scale_factor);
+# 
+#       /** \brief Get the 3d index (x,y,z) of the cell based on the location of
+#         * the cell
+#         * \param p the coordinate of the input point
+#         * \param index the output 3d index
+#         */
+#       inline void 
+#       getCellIndex (const Eigen::Vector4f &p, Eigen::Vector3i& index) const
+#       {
+#         for (int i = 0; i < 3; ++i)
+#           index[i] = static_cast<int> ((p[i] - min_p_(i)) / leaf_size_);
+#       }
+# 
+#       /** \brief Given the 3d index (x, y, z) of the cell, get the 
+#         * coordinates of the cell center
+#         * \param index the output 3d index
+#         * \param center the resultant cell center
+#         */
+#       inline void
+#       getCellCenterFromIndex (const Eigen::Vector3i &index, Eigen::Vector4f &center) const
+#       {
+#         for (int i = 0; i < 3; ++i)
+#           center[i] = 
+#             min_p_[i] + static_cast<float> (index[i]) * 
+#             static_cast<float> (leaf_size_) + 
+#             static_cast<float> (leaf_size_) / 2.0f;
+#       }
+# 
+#       /** \brief Given cell center, caluate the coordinates of the eight vertices of the cell
+#         * \param cell_center the coordinates of the cell center
+#         * \param pts the coordinates of the 8 vertices
+#         */
+#       void 
+#       getVertexFromCellCenter (const Eigen::Vector4f &cell_center, 
+#                                std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > &pts) const;
+# 
+#       /** \brief Given an index (x, y, z) in 3d, translate it into the index 
+#         * in 1d
+#         * \param index the index of the cell in (x,y,z) 3d format
+#         */
+#       inline int 
+#       getIndexIn1D (const Eigen::Vector3i &index) const
+#       {
+#         //assert(data_size_ > 0);
+#         return (index[0] * data_size_ * data_size_ + 
+#                 index[1] * data_size_ + index[2]);
+#       }
+# 
+#       /** \brief Given an index in 1d, translate it into the index (x, y, z) 
+#         * in 3d
+#         * \param index_1d the input 1d index
+#         * \param index_3d the output 3d index
+#         */
+#       inline void 
+#       getIndexIn3D (int index_1d, Eigen::Vector3i& index_3d) const
+#       {
+#         //assert(data_size_ > 0);
+#         index_3d[0] = index_1d / (data_size_ * data_size_);
+#         index_1d -= index_3d[0] * data_size_ * data_size_;
+#         index_3d[1] = index_1d / data_size_;
+#         index_1d -= index_3d[1] * data_size_;
+#         index_3d[2] = index_1d;
+#       }
+# 
+#       /** \brief For a given 3d index of a cell, test whether the cells within its
+#         * padding area exist in the hash table, if no, create an entry for that cell.
+#         * \param index the index of the cell in (x,y,z) format
+#         */
+#       void 
+#       fillPad (const Eigen::Vector3i &index);
+# 
+#       /** \brief Obtain the index of a cell and the pad size.
+#         * \param index the input index
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       void 
+#       getDataPtsUnion (const Eigen::Vector3i &index, std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Given the index of a cell, exam it's up, left, front edges, and add
+#         * the vectices to m_surface list.the up, left, front edges only share 4
+#         * points, we first get the vectors at these 4 points and exam whether those
+#         * three edges are intersected by the surface \param index the input index
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       void 
+#       createSurfaceForCell (const Eigen::Vector3i &index, std::vector <int> &pt_union_indices);
+# 
+# 
+#       /** \brief Given the coordinates of one point, project it onto the surface, 
+#         * return the projected point. Do a binary search between p and p+projection_distance 
+#         * to find the projected point
+#         * \param p the coordinates of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param projection the resultant point projected
+#         */
+#       void
+#       getProjection (const Eigen::Vector4f &p, std::vector<int> &pt_union_indices, Eigen::Vector4f &projection);
+# 
+#       /** \brief Given the coordinates of one point, project it onto the surface,
+#         * return the projected point. Find the plane which fits all the points in
+#         *  pt_union_indices, projected p to the plane to get the projected point.
+#         * \param p the coordinates of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param projection the resultant point projected
+#         */
+#       void 
+#       getProjectionWithPlaneFit (const Eigen::Vector4f &p, 
+#                                  std::vector<int> &pt_union_indices, 
+#                                  Eigen::Vector4f &projection);
+# 
+# 
+#       /** \brief Given the location of a point, get it's vector
+#         * \param p the coordinates of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param vo the resultant vector
+#         */
+#       void
+#       getVectorAtPoint (const Eigen::Vector4f &p, 
+#                         std::vector <int> &pt_union_indices, Eigen::Vector3f &vo);
+# 
+#       /** \brief Given the location of a point, get it's vector
+#         * \param p the coordinates of the input point
+#         * \param k_indices the k nearest neighbors of the query point
+#         * \param k_squared_distances the squared distances of the k nearest 
+#         * neighbors to the query point
+#         * \param vo the resultant vector
+#         */
+#       void
+#       getVectorAtPointKNN (const Eigen::Vector4f &p, 
+#                            std::vector<int> &k_indices, 
+#                            std::vector<float> &k_squared_distances,
+#                            Eigen::Vector3f &vo);
+# 
+#       /** \brief Get the magnitude of the vector by summing up the distance.
+#         * \param p the coordinate of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       double 
+#       getMagAtPoint (const Eigen::Vector4f &p, const std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Get the 1st derivative
+#         * \param p the coordinate of the input point
+#         * \param vec the vector at point p
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       double 
+#       getD1AtPoint (const Eigen::Vector4f &p, const Eigen::Vector3f &vec, 
+#                     const std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Get the 2nd derivative
+#         * \param p the coordinate of the input point
+#         * \param vec the vector at point p
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       double 
+#       getD2AtPoint (const Eigen::Vector4f &p, const Eigen::Vector3f &vec, 
+#                     const std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Test whether the edge is intersected by the surface by 
+#         * doing the dot product of the vector at two end points. Also test 
+#         * whether the edge is intersected by the maximum surface by examing 
+#         * the 2nd derivative of the intersection point 
+#         * \param end_pts the two points of the edge
+#         * \param vect_at_end_pts 
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       bool 
+#       isIntersected (const std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > &end_pts, 
+#                      std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > &vect_at_end_pts, 
+#                      std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Find point where the edge intersects the surface.
+#         * \param level binary search level
+#         * \param end_pts the two end points on the edge
+#         * \param vect_at_end_pts the vectors at the two end points
+#         * \param start_pt the starting point we use for binary search
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param intersection the resultant intersection point
+#         */
+#       void
+#       findIntersection (int level, 
+#                         const std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > &end_pts, 
+#                         const std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > &vect_at_end_pts, 
+#                         const Eigen::Vector4f &start_pt, 
+#                         std::vector<int> &pt_union_indices,
+#                         Eigen::Vector4f &intersection);
+# 
+#       /** \brief Go through all the entries in the hash table and update the
+#        * cellData. 
+#        *
+#        * When creating the hash table, the pt_on_surface field store the center
+#        * point of the cell.After calling this function, the projection operator will
+#        * project the center point onto the surface, and the pt_on_surface field will
+#        * be updated using the projected point.Also the vect_at_grid_pt field will be
+#        * updated using the vector at the upper left front vertex of the cell.
+#        *
+#        * \param index_1d the index of the cell after flatting it's 3d index into a 1d array
+#        * \param index_3d the index of the cell in (x,y,z) 3d format
+#        * \param pt_union_indices the union of input data points within the cell and pads
+#        * \param cell_data information stored in the cell
+#        */
+#       void
+#       storeVectAndSurfacePoint (int index_1d, const Eigen::Vector3i &index_3d, 
+#                                 std::vector<int> &pt_union_indices, const Leaf &cell_data);
+# 
+#       /** \brief Go through all the entries in the hash table and update the cellData. 
+#         * When creating the hash table, the pt_on_surface field store the center point
+#         * of the cell.After calling this function, the projection operator will project the 
+#         * center point onto the surface, and the pt_on_surface field will be updated 
+#         * using the projected point.Also the vect_at_grid_pt field will be updated using 
+#         * the vector at the upper left front vertex of the cell. When projecting the point 
+#         * and calculating the vector, using K nearest neighbors instead of using the 
+#         * union of input data point within the cell and pads.
+#         *
+#         * \param index_1d the index of the cell after flatting it's 3d index into a 1d array
+#         * \param index_3d the index of the cell in (x,y,z) 3d format
+#         * \param cell_data information stored in the cell
+#         */
+#       void 
+#       storeVectAndSurfacePointKNN (int index_1d, const Eigen::Vector3i &index_3d, const Leaf &cell_data);
+# 
+#     private:
+#       /** \brief Map containing the set of leaves. */
+#       HashMap cell_hash_map_;
+# 
+#       /** \brief Min and max data points. */
+#       Eigen::Vector4f min_p_, max_p_;
+# 
+#       /** \brief The size of a leaf. */
+#       double leaf_size_;
+# 
+#       /** \brief Gaussian scale. */
+#       double gaussian_scale_;
+# 
+#       /** \brief Data size. */
+#       int data_size_;
+# 
+#       /** \brief Max binary search level. */
+#       int max_binary_search_level_;
+# 
+#       /** \brief Number of neighbors (k) to use. */
+#       int k_;
+# 
+#       /** \brief Padding size. */
+#       int padding_size_;
+# 
+#       /** \brief The point cloud input (XYZ+Normals). */
+#       PointCloudPtr data_;
+# 
+#       /** \brief Store the surface normal(vector) at the each input data point. */
+#       std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > vector_at_data_point_;
+#       
+#       /** \brief An array of points which lay on the output surface. */
+#       std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > surface_;
+# 
+#       /** \brief Bit map which tells if there is any input data point in the cell. */
+#       boost::dynamic_bitset<> occupied_cell_list_;
+# 
+#       /** \brief Class get name method. */
+#       std::string getClassName () const { return ("GridProjection"); }
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# hash.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/hash.h (1.7.2)
+###
+
+# marching_cubes.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2)
+# 
+# namespace pcl
+# {
+#   /*
+#    * Tables, and functions, derived from Paul Bourke's Marching Cubes implementation:
+#    * http://paulbourke.net/geometry/polygonise/
+#    * Cube vertex indices:
+#    *   y_dir 4 ________ 5
+#    *         /|       /|
+#    *       /  |     /  |
+#    *   7 /_______ /    |
+#    *    |     |  |6    |
+#    *    |    0|__|_____|1 x_dir
+#    *    |    /   |    /
+#    *    |  /     |  /
+#    z_dir|/_______|/
+#    *   3          2
+#    */
+#   const unsigned int edgeTable[256] = {
+#     0x0  , 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
+#     0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
+#     0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
+#     0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
+#     0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c,
+#     0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
+#     0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac,
+#     0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
+#     0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c,
+#     0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
+#     0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc,
+#     0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
+#     0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c,
+#     0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
+#     0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc ,
+#     0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
+#     0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
+#     0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
+#     0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
+#     0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
+#     0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
+#     0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
+#     0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
+#     0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460,
+#     0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
+#     0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0,
+#     0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
+#     0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230,
+#     0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
+#     0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190,
+#     0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
+#     0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0
+#   };
+#   const int triTable[256][16] = {
+#     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+#     {8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
+#     {3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
+#     {4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+#     {4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
+#     {9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
+#     {10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
+#     {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+#     {5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
+#     {8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
+#     {2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+#     {2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
+#     {11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
+#     {5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
+#     {11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
+#     {11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
+#     {2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
+#     {6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+#     {3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
+#     {6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+#     {6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
+#     {8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
+#     {7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
+#     {3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+#     {0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
+#     {9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
+#     {8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+#     {5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
+#     {0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
+#     {6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
+#     {10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+#     {1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
+#     {0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
+#     {3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+#     {6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
+#     {9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
+#     {8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
+#     {3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
+#     {10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
+#     {10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+#     {2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
+#     {7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+#     {2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
+#     {1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
+#     {11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
+#     {8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
+#     {0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
+#     {7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
+#     {7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
+#     {10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
+#     {0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
+#     {7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
+#     {6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
+#     {4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
+#     {10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
+#     {8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
+#     {1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
+#     {10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
+#     {10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
+#     {9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
+#     {7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
+#     {3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
+#     {7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
+#     {3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
+#     {6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
+#     {9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
+#     {1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
+#     {4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
+#     {7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
+#     {6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
+#     {0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
+#     {6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
+#     {0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
+#     {11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
+#     {6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
+#     {5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
+#     {9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
+#     {1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
+#     {10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
+#     {0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
+#     {11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
+#     {9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
+#     {7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
+#     {2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
+#     {9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
+#     {9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
+#     {1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
+#     {0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
+#     {10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
+#     {2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
+#     {0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
+#     {0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
+#     {9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
+#     {5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
+#     {5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
+#     {8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
+#     {9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
+#     {1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
+#     {3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
+#     {4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
+#     {9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
+#     {11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
+#     {2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
+#     {9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
+#     {3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
+#     {1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
+#     {4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
+#     {0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
+#     {1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
+#   };
+# 
+# 
+#   /** \brief The marching cubes surface reconstruction algorithm. This is an abstract class that takes a grid and
+#     * extracts the isosurface as a mesh, based on the original marching cubes paper:
+#     *
+#     * Lorensen W.E., Cline H.E., "Marching cubes: A high resolution 3d surface construction algorithm",
+#     * SIGGRAPH '87
+#     *
+#     * \author Alexandru E. Ichim
+#     * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class MarchingCubes : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubes ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubes ();
+# 
+# 
+#       /** \brief Method that sets the iso level of the surface to be extracted.
+#         * \param[in] iso_level the iso level.
+#         */
+#       inline void
+#       setIsoLevel (float iso_level)
+#       { iso_level_ = iso_level; }
+# 
+#       /** \brief Method that returns the iso level of the surface to be extracted. */
+#       inline float
+#       getIsoLevel ()
+#       { return iso_level_; }
+# 
+#       /** \brief Method that sets the marching cubes grid resolution.
+#         * \param[in] res_x the resolution of the grid along the x-axis
+#         * \param[in] res_y the resolution of the grid along the y-axis
+#         * \param[in] res_z the resolution of the grid along the z-axis
+#         */
+#       inline void
+#       setGridResolution (int res_x, int res_y, int res_z)
+#       { res_x_ = res_x; res_y_ = res_y; res_z_ = res_z; }
+# 
+# 
+#       /** \brief Method to get the marching cubes grid resolution.
+#         * \param[in] res_x the resolution of the grid along the x-axis
+#         * \param[in] res_y the resolution of the grid along the y-axis
+#         * \param[in] res_z the resolution of the grid along the z-axis
+#         */
+#       inline void
+#       getGridResolution (int &res_x, int &res_y, int &res_z)
+#       { res_x = res_x_; res_y = res_y_; res_z = res_z_; }
+# 
+#       /** \brief Method that sets the parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits. Does not affect the resolution of the grid, it just
+#         * changes the voxel size accordingly.
+#         * \param[in] percentage the percentage of the bounding box that should be left empty between the bounding box and
+#         * the grid limits.
+#         */
+#       inline void
+#       setPercentageExtendGrid (float percentage)
+#       { percentage_extend_grid_ = percentage; }
+# 
+#       /** \brief Method that gets the parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits, as a percentage of the bounding box.
+#         */
+#       inline float
+#       getPercentageExtendGrid ()
+#       { return percentage_extend_grid_; }
+# 
+# protected:
+#       /** \brief The data structure storing the 3D grid */
+#       std::vector<float> grid_;
+# 
+#       /** \brief The grid resolution */
+#       int res_x_, res_y_, res_z_;
+# 
+#       /** \brief Parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits, as a percentage of the bounding box.*/
+#       float percentage_extend_grid_;
+# 
+#       /** \brief Min and max data points. */
+#       Eigen::Vector4f min_p_, max_p_;
+# 
+#       /** \brief The iso level to be extracted. */
+#       float iso_level_;
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       virtual void
+#       voxelizeData () = 0;
+# 
+#       /** \brief Interpolate along the voxel edge.
+#         * \param[in] p1 The first point on the edge
+#         * \param[in] p2 The second point on the edge
+#         * \param[in] val_p1 The scalar value at p1
+#         * \param[in] val_p2 The scalar value at p2
+#         * \param[out] output The interpolated point along the edge
+#         */
+#       void
+#       interpolateEdge (Eigen::Vector3f &p1, Eigen::Vector3f &p2, float val_p1, float val_p2, Eigen::Vector3f &output);
+# 
+# 
+#       /** \brief Calculate out the corresponding polygons in the leaf node
+#         * \param leaf_node the leaf node to be checked
+#         * \param index_3d the 3d index of the leaf node to be checked
+#         * \param cloud point cloud to store the vertices of the polygon
+#        */
+#       void
+#       createSurface (std::vector<float> &leaf_node,
+#                      Eigen::Vector3i &index_3d,
+#                      pcl::PointCloud<PointNT> &cloud);
+# 
+#       /** \brief Get the bounding box for the input data points. */
+#       void
+#       getBoundingBox ();
+# 
+# 
+#       /** \brief Method that returns the scalar value at the given grid position.
+#         * \param[in] pos The 3D position in the grid
+#         */
+#       float
+#       getGridValue (Eigen::Vector3i pos);
+# 
+#       /** \brief Method that returns the scalar values of the neighbors of a given 3D position in the grid.
+#         * \param[in] index3d the point in the grid
+#         * \param[out] leaf the set of values
+#         */
+#       void
+#       getNeighborList1D (std::vector<float> &leaf,
+#                          Eigen::Vector3i &index3d);
+# 
+#       /** \brief Class get name method. */
+#       std::string getClassName () const { return ("MarchingCubes"); }
+# 
+#       /** \brief Extract the surface.
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#        void
+#        performReconstruction (pcl::PolygonMesh &output);
+# 
+#        /** \brief Extract the surface.
+#          * \param[out] points the points of the extracted mesh
+#          * \param[out] polygons the connectivity between the point of the extracted mesh.
+#          */
+#        void
+#        performReconstruction (pcl::PointCloud<PointNT> &points,
+#                               std::vector<pcl::Vertices> &polygons);
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# marching_cubes_hoppe.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2) ?
+# namespace pcl
+# {
+#    /** \brief The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance
+#      * from tangent planes, proposed by Hoppe et. al. in:
+#      * Hoppe H., DeRose T., Duchamp T., MC-Donald J., Stuetzle W., "Surface reconstruction from unorganized points",
+#      * SIGGRAPH '92
+#      * \author Alexandru E. Ichim
+#      * \ingroup surface
+#      */
+#   template <typename PointNT>
+#   class MarchingCubesHoppe : public MarchingCubes<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+#       using MarchingCubes<PointNT>::grid_;
+#       using MarchingCubes<PointNT>::res_x_;
+#       using MarchingCubes<PointNT>::res_y_;
+#       using MarchingCubes<PointNT>::res_z_;
+#       using MarchingCubes<PointNT>::min_p_;
+#       using MarchingCubes<PointNT>::max_p_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubesHoppe ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubesHoppe ();
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       void
+#       voxelizeData ();
+# 
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# marching_cubes_poisson.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2)
+# namespace pcl {
+#   namespace poisson {
+# 
+# 
+#     class Square
+#     {
+#     public:
+#       const static int CORNERS = 4, EDGES = 4, NEIGHBORS = 4;
+#       static int  CornerIndex (const int& x, const int& y);
+#       static void FactorCornerIndex (const int& idx, int& x, int& y);
+#       static int  EdgeIndex (const int& orientation, const int& i);
+#       static void FactorEdgeIndex (const int& idx, int& orientation, int& i);
+# 
+#       static int  ReflectCornerIndex (const int& idx, const int& edgeIndex);
+#       static int  ReflectEdgeIndex (const int& idx, const int& edgeIndex);
+# 
+#       static void EdgeCorners (const int& idx, int& c1, int &c2);
+#     };
+# 
+#     class Cube{
+#     public:
+#       const static int CORNERS = 8, EDGES = 12, NEIGHBORS = 6;
+# 
+#       static int CornerIndex (const int& x, const int& y, const int& z);
+#       static void FactorCornerIndex (const int& idx, int& x, int& y, int& z);
+#       static int EdgeIndex (const int& orientation, const int& i, const int& j);
+#       static void FactorEdgeIndex (const int& idx, int& orientation, int& i, int &j);
+#       static int FaceIndex (const int& dir, const int& offSet);
+#       static int FaceIndex (const int& x, const int& y, const int& z);
+#       static void FactorFaceIndex (const int& idx, int& x, int &y, int& z);
+#       static void FactorFaceIndex (const int& idx, int& dir, int& offSet);
+# 
+#       static int AntipodalCornerIndex (const int& idx);
+#       static int FaceReflectCornerIndex (const int& idx, const int& faceIndex);
+#       static int FaceReflectEdgeIndex (const int& idx, const int& faceIndex);
+#       static int FaceReflectFaceIndex (const int& idx, const int& faceIndex);
+#       static int EdgeReflectCornerIndex   (const int& idx, const int& edgeIndex);
+#       static int EdgeReflectEdgeIndex (const int& edgeIndex);
+# 
+#       static int FaceAdjacentToEdges (const int& eIndex1, const int& eIndex2);
+#       static void FacesAdjacentToEdge (const int& eIndex, int& f1Index, int& f2Index);
+# 
+#       static void EdgeCorners (const int& idx, int& c1, int &c2);
+#       static void FaceCorners (const int& idx, int& c1, int &c2, int& c3, int& c4);
+#     };
+# 
+#     class MarchingSquares
+#     {
+#       static double Interpolate (const double& v1, const double& v2);
+#       static void SetVertex (const int& e, const double values[Square::CORNERS], const double& iso);
+#     public:
+#       const static int MAX_EDGES = 2;
+#       static const int edgeMask[1<<Square::CORNERS];
+#       static const int edges[1<<Square::CORNERS][2*MAX_EDGES+1];
+#       static double vertexList[Square::EDGES][2];
+# 
+#       static int GetIndex (const double values[Square::CORNERS], const double& iso);
+#       static int IsAmbiguous (const double v[Square::CORNERS] ,const double& isoValue);
+#       static int AddEdges (const double v[Square::CORNERS], const double& isoValue, Edge* edges);
+#       static int AddEdgeIndices (const double v[Square::CORNERS], const double& isoValue, int* edges);
+#     };
+# 
+#     class MarchingCubes
+#     {
+#       static double Interpolate (const double& v1, const double& v2);
+#       static void SetVertex (const int& e, const double values[Cube::CORNERS], const double& iso);
+#       static int GetFaceIndex (const double values[Cube::CORNERS], const double& iso, const int& faceIndex);
+# 
+#       static float Interpolate (const float& v1, const float& v2);
+#       static void SetVertex (const int& e, const float values[Cube::CORNERS], const float& iso);
+#       static int GetFaceIndex (const float values[Cube::CORNERS], const float& iso, const int& faceIndex);
+# 
+#       static int GetFaceIndex (const int& mcIndex, const int& faceIndex);
+#     public:
+#       const static int MAX_TRIANGLES=5;
+#       static const int edgeMask[1<<Cube::CORNERS];
+#       static const int triangles[1<<Cube::CORNERS][3*MAX_TRIANGLES+1];
+#       static const int cornerMap[Cube::CORNERS];
+#       static double vertexList[Cube::EDGES][3];
+# 
+#       static int AddTriangleIndices (const int& mcIndex, int* triangles);
+# 
+#       static int GetIndex (const double values[Cube::CORNERS],const double& iso);
+#       static int IsAmbiguous (const double v[Cube::CORNERS],const double& isoValue,const int& faceIndex);
+#       static int HasRoots (const double v[Cube::CORNERS],const double& isoValue);
+#       static int HasRoots (const double v[Cube::CORNERS],const double& isoValue,const int& faceIndex);
+#       static int AddTriangles (const double v[Cube::CORNERS],const double& isoValue,Triangle* triangles);
+#       static int AddTriangleIndices (const double v[Cube::CORNERS],const double& isoValue,int* triangles);
+# 
+#       static int GetIndex (const float values[Cube::CORNERS], const float& iso);
+#       static int IsAmbiguous (const float v[Cube::CORNERS], const float& isoValue, const int& faceIndex);
+#       static int HasRoots (const float v[Cube::CORNERS], const float& isoValue);
+#       static int HasRoots (const float v[Cube::CORNERS], const float& isoValue, const int& faceIndex);
+#       static int AddTriangles (const float v[Cube::CORNERS], const float& isoValue, Triangle* triangles);
+#       static int AddTriangleIndices (const float v[Cube::CORNERS], const float& isoValue, int* triangles);
+# 
+#       static int IsAmbiguous (const int& mcIndex, const int& faceIndex);
+#       static int HasRoots (const int& mcIndex);
+#       static int HasFaceRoots (const int& mcIndex, const int& faceIndex);
+#       static int HasEdgeRoots (const int& mcIndex, const int& edgeIndex);
+#     };
+# 
+# 
+###
+
+# marching_cubes_rbf.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2) ?
+# namespace pcl
+# {
+#   /** \brief The marching cubes surface reconstruction algorithm, using a signed distance function based on radial
+#     * basis functions. Partially based on:
+#     * Carr J.C., Beatson R.K., Cherrie J.B., Mitchell T.J., Fright W.R., McCallum B.C. and Evans T.R.,
+#     * "Reconstruction and representation of 3D objects with radial basis functions"
+#     * SIGGRAPH '01
+#     *
+#     * \author Alexandru E. Ichim
+#     * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class MarchingCubesRBF : public MarchingCubes<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+#       using MarchingCubes<PointNT>::grid_;
+#       using MarchingCubes<PointNT>::res_x_;
+#       using MarchingCubes<PointNT>::res_y_;
+#       using MarchingCubes<PointNT>::res_z_;
+#       using MarchingCubes<PointNT>::min_p_;
+#       using MarchingCubes<PointNT>::max_p_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubesRBF ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubesRBF ();
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       void
+#       voxelizeData ();
+# 
+# 
+#       /** \brief Set the off-surface points displacement value.
+#         * \param[in] epsilon the value
+#         */
+#       inline void
+#       setOffSurfaceDisplacement (float epsilon)
+#       { off_surface_epsilon_ = epsilon; }
+# 
+#       /** \brief Get the off-surface points displacement value. */
+#       inline float
+#       getOffSurfaceDisplacement ()
+#       { return off_surface_epsilon_; }
+# 
+# 
+#     protected:
+#       /** \brief the Radial Basis Function kernel. */
+#       double
+#       kernel (Eigen::Vector3d c, Eigen::Vector3d x);
+# 
+#       /** \brief The off-surface displacement value. */
+#       float off_surface_epsilon_;
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# }
+###
+
+# mls.h
+cdef extern from "pcl/surface/mls.h" namespace "pcl":
+    cdef cppclass MovingLeastSquares[I,O]:
+        MovingLeastSquares()
+        void setInputCloud (shared_ptr[cpp.PointCloud[I]])
+        void setSearchRadius (double)
+        void setComputeNormals (bool compute_normals)
+        void setPolynomialOrder(bool)
+        void setPolynomialFit(int)
+        # void process(cpp.PointCloud[O] &) except +
+        void process(cpp.PointCloud[O] &) except +
+        
+        # KdTree
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        pclkdt.KdTreePtr_t getSearchMethod ()
+
+ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointXYZ] MovingLeastSquares_t
+ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointXYZI] MovingLeastSquares_PointXYZI_t
+ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointXYZRGB] MovingLeastSquares_PointXYZRGB_t
+ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointXYZRGBA] MovingLeastSquares_PointXYZRGBA_t
+# NG
+# ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointNormal] MovingLeastSquares_t
+# ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointNormal] MovingLeastSquares_PointXYZI_t
+# ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointNormal] MovingLeastSquares_PointXYZRGB_t
+# ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointNormal] MovingLeastSquares_PointXYZRGBA_t
+
+
+# namespace pcl
+# {
+#   /** \brief MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm 
+#     * for data smoothing and improved normal estimation. It also contains methods for upsampling the 
+#     * resulting cloud based on the parametric fit.
+#     * Reference paper: "Computing and Rendering Point Set Surfaces" by Marc Alexa, Johannes Behr, 
+#     * Daniel Cohen-Or, Shachar Fleishman, David Levin and Claudio T. Silva
+#     * www.sci.utah.edu/~shachar/Publications/crpss.pdf
+#     * \author Zoltan Csaba Marton, Radu B. Rusu, Alexandru E. Ichim, Suat Gedikli
+#     * \ingroup surface
+#     */
+#   template <typename PointInT, typename PointOutT>
+#   class MovingLeastSquares: public CloudSurfaceProcessing<PointInT, PointOutT>
+#   {
+#     public:
+#       using PCLBase<PointInT>::input_;
+#       using PCLBase<PointInT>::indices_;
+#       using PCLBase<PointInT>::fake_indices_;
+#       using PCLBase<PointInT>::initCompute;
+#       using PCLBase<PointInT>::deinitCompute;
+# 
+#       typedef typename pcl::search::Search<PointInT> KdTree;
+#       typedef typename pcl::search::Search<PointInT>::Ptr KdTreePtr;
+#       typedef pcl::PointCloud<pcl::Normal> NormalCloud;
+#       typedef pcl::PointCloud<pcl::Normal>::Ptr NormalCloudPtr;
+# 
+#       typedef pcl::PointCloud<PointOutT> PointCloudOut;
+#       typedef typename PointCloudOut::Ptr PointCloudOutPtr;
+#       typedef typename PointCloudOut::ConstPtr PointCloudOutConstPtr;
+# 
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       typedef typename PointCloudIn::Ptr PointCloudInPtr;
+#       typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+# 
+#       typedef boost::function<int (int, double, std::vector<int> &, std::vector<float> &)> SearchMethod;
+# 
+#       enum UpsamplingMethod { NONE, SAMPLE_LOCAL_PLANE, RANDOM_UNIFORM_DENSITY, VOXEL_GRID_DILATION };
+# 
+#       /** \brief Empty constructor. */
+#       MovingLeastSquares () : CloudSurfaceProcessing<PointInT, PointOutT> (),
+#                               normals_ (),
+#                               search_method_ (),
+#                               tree_ (),
+#                               order_ (2),
+#                               polynomial_fit_ (true),
+#                               search_radius_ (0.0),
+#                               sqr_gauss_param_ (0.0),
+#                               compute_normals_ (false),
+#                               upsample_method_ (NONE),
+#                               upsampling_radius_ (0.0),
+#                               upsampling_step_ (0.0),
+#                               rng_uniform_distribution_ (),
+#                               desired_num_points_in_radius_ (0),
+#                               mls_results_ (),
+#                               voxel_size_ (1.0),
+#                               dilation_iteration_num_ (0),
+#                               nr_coeff_ ()
+#                               {};
+# 
+# 
+#       /** \brief Set whether the algorithm should also store the normals computed
+#         * \note This is optional, but need a proper output cloud type
+#         */
+#       inline void
+#       setComputeNormals (bool compute_normals) { compute_normals_ = compute_normals; }
+# 
+#       /** \brief Provide a pointer to the search object.
+#         * \param[in] tree a pointer to the spatial search object.
+#         */
+#       inline void
+#       setSearchMethod (const KdTreePtr &tree)
+#       {
+#         tree_ = tree;
+#         // Declare the search locator definition
+#         int (KdTree::*radiusSearch)(int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn) const = &KdTree::radiusSearch;
+#         search_method_ = boost::bind (radiusSearch, boost::ref (tree_), _1, _2, _3, _4, 0);
+#       }
+# 
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr 
+#       getSearchMethod () { return (tree_); }
+# 
+#       /** \brief Set the order of the polynomial to be fit.
+#         * \param[in] order the order of the polynomial
+#         */
+#       inline void 
+#       setPolynomialOrder (int order) { order_ = order; }
+# 
+#       /** \brief Get the order of the polynomial to be fit. */
+#       inline int 
+#       getPolynomialOrder () { return (order_); }
+# 
+#       /** \brief Sets whether the surface and normal are approximated using a polynomial, or only via tangent estimation.
+#         * \param[in] polynomial_fit set to true for polynomial fit
+#         */
+#       inline void 
+#       setPolynomialFit (bool polynomial_fit) { polynomial_fit_ = polynomial_fit; }
+# 
+#       /** \brief Get the polynomial_fit value (true if the surface and normal are approximated using a polynomial). */
+#       inline bool 
+#       getPolynomialFit () { return (polynomial_fit_); }
+# 
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+#         * \param[in] radius the sphere radius that is to contain all k-nearest neighbors
+#         * \note Calling this method resets the squared Gaussian parameter to radius * radius !
+#         */
+#       inline void 
+#       setSearchRadius (double radius) { search_radius_ = radius; sqr_gauss_param_ = search_radius_ * search_radius_; }
+# 
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       inline double 
+#       getSearchRadius () { return (search_radius_); }
+# 
+#       /** \brief Set the parameter used for distance based weighting of neighbors (the square of the search radius works
+#         * best in general).
+#         * \param[in] sqr_gauss_param the squared Gaussian parameter
+#         */
+#       inline void 
+#       setSqrGaussParam (double sqr_gauss_param) { sqr_gauss_param_ = sqr_gauss_param; }
+# 
+#       /** \brief Get the parameter for distance based weighting of neighbors. */
+#       inline double 
+#       getSqrGaussParam () const { return (sqr_gauss_param_); }
+# 
+#       /** \brief Set the upsampling method to be used
+#         * \note Options are: * NONE - no upsampling will be done, only the input points will be projected to their own
+#         *                             MLS surfaces
+#         *                    * SAMPLE_LOCAL_PLANE - the local plane of each input point will be sampled in a circular
+#         *                                           fashion using the \ref upsampling_radius_ and the \ref upsampling_step_
+#         *                                           parameters
+#         *                    * RANDOM_UNIFORM_DENSITY - the local plane of each input point will be sampled using an
+#         *                                               uniform random distribution such that the density of points is
+#         *                                               constant throughout the cloud - given by the \ref \ref desired_num_points_in_radius_
+#         *                                               parameter
+#         *                    * VOXEL_GRID_DILATION - the input cloud will be inserted into a voxel grid with voxels of
+#         *                                            size \ref voxel_size_; this voxel grid will be dilated \ref dilation_iteration_num_
+#         *                                            times and the resulting points will be projected to the MLS surface
+#         *                                            of the closest point in the input cloud; the result is a point cloud
+#         *                                            with filled holes and a constant point density
+#         */
+#       inline void
+#       setUpsamplingMethod (UpsamplingMethod method) { upsample_method_ = method; }
+# 
+# 
+#       /** \brief Set the radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         * \param[in] radius the radius of the circle
+#         */
+#       inline void
+#       setUpsamplingRadius (double radius) { upsampling_radius_ = radius; }
+# 
+#       /** \brief Get the radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       inline double
+#       getUpsamplingRadius () { return upsampling_radius_; }
+# 
+#       /** \brief Set the step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         * \param[in] step_size the step size
+#         */
+#       inline void
+#       setUpsamplingStepSize (double step_size) { upsampling_step_ = step_size; }
+# 
+# 
+#       /** \brief Get the step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       inline double
+#       getUpsamplingStepSize () { return upsampling_step_; }
+# 
+#       /** \brief Set the parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         * \param[in] desired_num_points_in_radius the desired number of points in the output cloud in a sphere of
+#         * radius \ref search_radius_ around each point
+#         */
+#       inline void
+#       setPointDensity (int desired_num_points_in_radius) { desired_num_points_in_radius_ = desired_num_points_in_radius; }
+# 
+# 
+#       /** \brief Get the parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       inline int
+#       getPointDensity () { return desired_num_points_in_radius_; }
+# 
+#       /** \brief Set the voxel size for the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         * \param[in] voxel_size the edge length of a cubic voxel in the voxel grid
+#         */
+#       inline void
+#       setDilationVoxelSize (float voxel_size) { voxel_size_ = voxel_size; }
+# 
+# 
+#       /** \brief Get the voxel size for the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         */
+#       inline float
+#       getDilationVoxelSize () { return voxel_size_; }
+# 
+#       /** \brief Set the number of dilation steps of the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         * \param[in] iterations the number of dilation iterations
+#         */
+#       inline void
+#       setDilationIterations (int iterations) { dilation_iteration_num_ = iterations; }
+# 
+#       /** \brief Get the number of dilation steps of the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         */
+#       inline int
+#       getDilationIterations () { return dilation_iteration_num_; }
+# 
+#       /** \brief Base method for surface reconstruction for all points given in <setInputCloud (), setIndices ()>
+#         * \param[out] output the resultant reconstructed surface model
+#         */
+#       void 
+#       process (PointCloudOut &output);
+# 
+#     protected:
+#       /** \brief The point cloud that will hold the estimated normals, if set. */
+#       NormalCloudPtr normals_;
+# 
+#       /** \brief The search method template for indices. */
+#       SearchMethod search_method_;
+# 
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+# 
+#       /** \brief The order of the polynomial to be fit. */
+#       int order_;
+# 
+#       /** True if the surface and normal be approximated using a polynomial, false if tangent estimation is sufficient. */
+#       bool polynomial_fit_;
+# 
+#       /** \brief The nearest neighbors search radius for each point. */
+#       double search_radius_;
+# 
+#       /** \brief Parameter for distance based weighting of neighbors (search_radius_ * search_radius_ works fine) */
+#       double sqr_gauss_param_;
+# 
+#       /** \brief Parameter that specifies whether the normals should be computed for the input cloud or not */
+#       bool compute_normals_;
+# 
+#       /** \brief Parameter that specifies the upsampling method to be used */
+#       UpsamplingMethod upsample_method_;
+# 
+#       /** \brief Radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       double upsampling_radius_;
+# 
+#       /** \brief Step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       double upsampling_step_;
+# 
+#       /** \brief Random number generator using an uniform distribution of floats
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       boost::variate_generator<boost::mt19937, boost::uniform_real<float> > *rng_uniform_distribution_;
+# 
+#       /** \brief Parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       int desired_num_points_in_radius_;
+# 
+#       
+#       /** \brief Data structure used to store the results of the MLS fitting
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       struct MLSResult
+#       {
+#         MLSResult () : plane_normal (), u (), v (), c_vec (), num_neighbors (), curvature (), valid (false) {}
+# 
+#         MLSResult (Eigen::Vector3d &a_plane_normal,
+#                    Eigen::Vector3d &a_u,
+#                    Eigen::Vector3d &a_v,
+#                    Eigen::VectorXd a_c_vec,
+#                    int a_num_neighbors,
+#                    float &a_curvature);
+# 
+#         Eigen::Vector3d plane_normal, u, v;
+#         Eigen::VectorXd c_vec;
+#         int num_neighbors;
+#         float curvature;
+#         bool valid;
+#       };
+# 
+#       /** \brief Stores the MLS result for each point in the input cloud
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       std::vector<MLSResult> mls_results_;
+# 
+#       
+#       /** \brief A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       class MLSVoxelGrid
+#       {
+#         public:
+#           struct Leaf { Leaf () : valid (true) {} bool valid; };
+# 
+#           MLSVoxelGrid (PointCloudInConstPtr& cloud,
+#                         IndicesPtr &indices,
+#                         float voxel_size);
+# 
+#           void
+#           dilate ();
+# 
+#           inline void
+#           getIndexIn1D (const Eigen::Vector3i &index, uint64_t &index_1d) const
+#           {
+#             index_1d = index[0] * data_size_ * data_size_ +
+#                        index[1] * data_size_ + index[2];
+#           }
+# 
+#           inline void
+#           getIndexIn3D (uint64_t index_1d, Eigen::Vector3i& index_3d) const
+#           {
+#             index_3d[0] = static_cast<Eigen::Vector3i::Scalar> (index_1d / (data_size_ * data_size_));
+#             index_1d -= index_3d[0] * data_size_ * data_size_;
+#             index_3d[1] = static_cast<Eigen::Vector3i::Scalar> (index_1d / data_size_);
+#             index_1d -= index_3d[1] * data_size_;
+#             index_3d[2] = static_cast<Eigen::Vector3i::Scalar> (index_1d);
+#           }
+# 
+#           inline void
+#           getCellIndex (const Eigen::Vector3f &p, Eigen::Vector3i& index) const
+#           {
+#             for (int i = 0; i < 3; ++i)
+#               index[i] = static_cast<Eigen::Vector3i::Scalar> ((p[i] - bounding_min_(i)) / voxel_size_);
+#           }
+# 
+#           inline void
+#           getPosition (const uint64_t &index_1d, Eigen::Vector3f &point) const
+#           {
+#             Eigen::Vector3i index_3d;
+#             getIndexIn3D (index_1d, index_3d);
+#             for (int i = 0; i < 3; ++i)
+#               point[i] = static_cast<Eigen::Vector3f::Scalar> (index_3d[i]) * voxel_size_ + bounding_min_[i];
+#           }
+# 
+#           typedef std::map<uint64_t, Leaf> HashMap;
+#           HashMap voxel_grid_;
+#           Eigen::Vector4f bounding_min_, bounding_max_;
+#           uint64_t data_size_;
+#           float voxel_size_;
+#       };
+# 
+# 
+#       /** \brief Voxel size for the VOXEL_GRID_DILATION upsampling method */
+#       float voxel_size_;
+# 
+#       /** \brief Number of dilation steps for the VOXEL_GRID_DILATION upsampling method */
+#       int dilation_iteration_num_; 
+# 
+#       /** \brief Number of coefficients, to be computed from the requested order.*/
+#       int nr_coeff_;
+# 
+#       /** \brief Search for the closest nearest neighbors of a given point using a radius search
+#         * \param[in] index the index of the query point
+#         * \param[out] indices the resultant vector of indices representing the k-nearest neighbors
+#         * \param[out] sqr_distances the resultant squared distances from the query point to the k-nearest neighbors
+#         */
+#       inline int
+#       searchForNeighbors (int index, std::vector<int> &indices, std::vector<float> &sqr_distances)
+#       {
+#         return (search_method_ (index, search_radius_, indices, sqr_distances));
+#       }
+# 
+#       /** \brief Smooth a given point and its neighborghood using Moving Least Squares.
+#         * \param[in] index the inex of the query point in the \ref input cloud
+#         * \param[in] input the input point cloud that \ref nn_indices refer to
+#         * \param[in] nn_indices the set of nearest neighbors indices for \ref pt
+#         * \param[in] nn_sqr_dists the set of nearest neighbors squared distances for \ref pt
+#         * \param[out] projected_points the set of points projected points around the query point
+#         * (in the case of upsampling method NONE, only the query point projected to its own fitted surface will be returned,
+#         * in the case of the other upsampling methods, multiple points will be returned)
+#         * \param[out] projected_points_normals the normals corresponding to the projected points
+#         */
+#       void
+#       computeMLSPointNormal (int index,
+#                              const PointCloudIn &input,
+#                              const std::vector<int> &nn_indices,
+#                              std::vector<float> &nn_sqr_dists,
+#                              PointCloudOut &projected_points,
+#                              NormalCloud &projected_points_normals);
+# 
+#       /** \brief Fits a point (sample point) given in the local plane coordinates of an input point (query point) to
+#         * the MLS surface of the input point
+#         * \param[in] u_disp the u coordinate of the sample point in the local plane of the query point
+#         * \param[in] v_disp the v coordinate of the sample point in the local plane of the query point
+#         * \param[in] u the axis corresponding to the u-coordinates of the local plane of the query point
+#         * \param[in] v the axis corresponding to the v-coordinates of the local plane of the query point
+#         * \param[in] plane_normal the normal to the local plane of the query point
+#         * \param[in] curvature the curvature of the surface at the query point
+#         * \param[in] query_point the absolute 3D position of the query point
+#         * \param[in] c_vec the coefficients of the polynomial fit on the MLS surface of the query point
+#         * \param[in] num_neighbors the number of neighbors of the query point in the input cloud
+#         * \param[out] result_point the absolute 3D position of the resulting projected point
+#         * \param[out] result_normal the normal of the resulting projected point
+#         */
+#       void
+#       projectPointToMLSSurface (float &u_disp, float &v_disp,
+#                                 Eigen::Vector3d &u, Eigen::Vector3d &v,
+#                                 Eigen::Vector3d &plane_normal,
+#                                 float &curvature,
+#                                 Eigen::Vector3f &query_point,
+#                                 Eigen::VectorXd &c_vec,
+#                                 int num_neighbors,
+#                                 PointOutT &result_point,
+#                                 pcl::Normal &result_normal);
+#     public:
+#         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# mls_omp.h
+# namespace pcl
+# {
+#   /** \brief MovingLeastSquaresOMP represent an OpenMP implementation of the MLS (Moving Least Squares) algorithm for 
+#     * data smoothing and improved normal estimation.
+#     * \author Radu B. Rusu
+#     * \ingroup surface
+#     */
+#   template <typename PointInT, typename PointOutT>
+#   class MovingLeastSquaresOMP : public MovingLeastSquares<PointInT, PointOutT>
+#   {
+#     using MovingLeastSquares<PointInT, PointOutT>::input_;
+#     using MovingLeastSquares<PointInT, PointOutT>::indices_;
+#     using MovingLeastSquares<PointInT, PointOutT>::fake_indices_;
+#     using MovingLeastSquares<PointInT, PointOutT>::initCompute;
+#     using MovingLeastSquares<PointInT, PointOutT>::deinitCompute;
+#     using MovingLeastSquares<PointInT, PointOutT>::nr_coeff_;
+#     using MovingLeastSquares<PointInT, PointOutT>::order_;
+#     using MovingLeastSquares<PointInT, PointOutT>::normals_;
+#     using MovingLeastSquares<PointInT, PointOutT>::upsample_method_;
+#     using MovingLeastSquares<PointInT, PointOutT>::voxel_size_;
+#     using MovingLeastSquares<PointInT, PointOutT>::dilation_iteration_num_;
+#     using MovingLeastSquares<PointInT, PointOutT>::tree_;
+#     using MovingLeastSquares<PointInT, PointOutT>::mls_results_;
+#     using MovingLeastSquares<PointInT, PointOutT>::search_radius_;
+#     using MovingLeastSquares<PointInT, PointOutT>::compute_normals_;
+#     using MovingLeastSquares<PointInT, PointOutT>::searchForNeighbors;
+#       
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::NormalCloud NormalCloud;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::MLSVoxelGrid MLSVoxelGrid;
+# 
+#     public:
+#       /** \brief Empty constructor. */
+#       MovingLeastSquaresOMP () : threads_ (1)
+#       {};
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       MovingLeastSquaresOMP (unsigned int nr_threads) : threads_ (0)
+#       {
+#         setNumberOfThreads (nr_threads);
+#       }
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void 
+#       setNumberOfThreads (unsigned int nr_threads)
+#       { 
+#         if (nr_threads == 0)
+#           nr_threads = 1;
+#         threads_ = nr_threads; 
+#       }
+# 
+###
+
+# multi_grid_octree_data.h
+# pcl/surface/3rdparty/poisson4/multi_grid_octree_data.h (1.7.2)
+# namespace pcl 
+# {
+#   namespace poisson 
+#   {
+#     typedef float Real;
+#     typedef float FunctionDataReal;
+#     typedef OctNode<class TreeNodeData,Real> TreeOctNode;
+# 
+#     class RootInfo
+#     {
+#       public:
+#         const TreeOctNode* node;
+#         int edgeIndex;
+#         long long key;
+#     };
+# 
+#     class VertexData
+#     {
+#       public:
+#         static long long 
+#         EdgeIndex (const TreeOctNode* node, const int& eIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         EdgeIndex (const TreeOctNode* node, const int& eIndex, const int& maxDepth);
+# 
+#         static long long 
+#         FaceIndex (const TreeOctNode* node, const int& fIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         FaceIndex (const TreeOctNode* node, const int& fIndex, const int& maxDepth);
+# 
+#         static long long 
+#         CornerIndex (const int& depth, const int offSet[DIMENSION] ,const int& cIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CornerIndex (const TreeOctNode* node, const int& cIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CornerIndex (const TreeOctNode* node, const int& cIndex, const int& maxDepth);
+# 
+#         static long long 
+#         CenterIndex (const int& depth, const int offSet[DIMENSION], const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CenterIndex (const TreeOctNode* node, const int& maxDepth, int index[DIMENSION]);
+#         
+#         static long long 
+#         CenterIndex (const TreeOctNode* node, const int& maxDepth);
+#     };
+# 
+#     class SortedTreeNodes
+#     {
+#       public:
+#         TreeOctNode** treeNodes;
+#         int *nodeCount;
+#         int maxDepth;
+#         SortedTreeNodes ();
+#         ~SortedTreeNodes ();
+#         void 
+#         set (TreeOctNode& root,const int& setIndex);
+#     };
+# 
+#     class TreeNodeData
+#     {
+#       public:
+#         static int UseIndex;
+#         union
+#         {
+#           int mcIndex;
+#           struct
+#           {
+#             int nodeIndex;
+#             Real centerWeightContribution;
+#           };
+#         };
+#         Real value;
+# 
+#         TreeNodeData (void);
+#         ~TreeNodeData (void);
+#     };
+# 
+#     template<int Degree>
+#     class Octree
+#     {
+#       TreeOctNode::NeighborKey neighborKey;
+#       TreeOctNode::NeighborKey2 neighborKey2;
+# 
+#       Real radius;
+#       int width;
+# 
+#       void 
+#       setNodeIndices (TreeOctNode& tree,int& idx);
+#       
+#       Real 
+#       GetDotProduct (const int index[DIMENSION]) const;
+# 
+#       Real 
+#       GetLaplacian (const int index[DIMENSION]) const;
+# 
+#       Real 
+#       GetDivergence (const int index[DIMENSION], const Point3D<Real>& normal) const;
+# 
+#       class DivergenceFunction
+#       {
+#         public:
+#           Point3D<Real> normal;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+# 
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class LaplacianProjectionFunction
+#       {
+#         public:
+#           double value;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+# 
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class LaplacianMatrixFunction
+#       {
+#         public:
+#           int x2,y2,z2,d2;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+#           int elementCount,offset;
+#           MatrixEntry<float>* rowElements;
+# 
+#           int 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class RestrictedLaplacianMatrixFunction
+#       {
+#         public:
+#           int depth,offset[3];
+#           Octree<Degree>* ot;
+#           Real radius;
+#           int index[DIMENSION], scratch[DIMENSION];
+#           int elementCount;
+#           MatrixEntry<float>* rowElements;
+# 
+#           int 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       ///////////////////////////
+#       // Evaluation Functions  //
+#       ///////////////////////////
+#       class PointIndexValueFunction
+#       {
+#         public:
+#           int res2;
+#           FunctionDataReal* valueTables;
+#           int index[DIMENSION];
+#           Real value;
+# 
+#           void 
+#           Function (const TreeOctNode* node);
+#       };
+# 
+#       class PointIndexValueAndNormalFunction
+#       {
+#         public:
+#           int res2;
+#           FunctionDataReal* valueTables;
+#           FunctionDataReal* dValueTables;
+#           Real value;
+#           Point3D<Real> normal;
+#           int index[DIMENSION];
+# 
+#           void 
+#           Function (const TreeOctNode* node);
+#       };
+# 
+#       class AdjacencyCountFunction
+#       {
+#         public:
+#           int adjacencyCount;
+# 
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class AdjacencySetFunction
+#       {
+#         public:
+#           int *adjacencies,adjacencyCount;
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class RefineFunction
+#       {
+#         public:
+#           int depth;
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class FaceEdgesFunction 
+#       {
+#         public:
+#           int fIndex,maxDepth;
+#           std::vector<std::pair<long long,long long> >* edges;
+#           hash_map<long long, std::pair<RootInfo,int> >* vertexCount;
+# 
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       int 
+#       SolveFixedDepthMatrix (const int& depth, const SortedTreeNodes& sNodes);
+#       
+#       int 
+#       SolveFixedDepthMatrix (const int& depth, const int& startingDepth, const SortedTreeNodes& sNodes);
+# 
+#       int 
+#       GetFixedDepthLaplacian (SparseSymmetricMatrix<float>& matrix, const int& depth, const SortedTreeNodes& sNodes);
+# 
+#       int 
+#       GetRestrictedFixedDepthLaplacian (SparseSymmetricMatrix<float>& matrix,
+#                                         const int& depth,
+#                                         const int* entries,
+#                                         const int& entryCount,
+#                                         const TreeOctNode* rNode,
+#                                         const Real& radius,
+#                                         const SortedTreeNodes& sNodes);
+# 
+#       void 
+#       SetIsoSurfaceCorners (const Real& isoValue, const int& subdivisionDepth, const int& fullDepthIso);
+# 
+#       static int 
+#       IsBoundaryFace (const TreeOctNode* node, const int& faceIndex, const int& subdivideDepth);
+#       
+#       static int 
+#       IsBoundaryEdge (const TreeOctNode* node, const int& edgeIndex, const int& subdivideDepth);
+#       
+#       static int 
+#       IsBoundaryEdge (const TreeOctNode* node, const int& dir, const int& x, const int& y, const int& subidivideDepth);
+#       
+#       void 
+#       PreValidate (const Real& isoValue, const int& maxDepth, const int& subdivideDepth);
+#       
+#       void 
+#       PreValidate (TreeOctNode* node, const Real& isoValue, const int& maxDepth, const int& subdivideDepth);
+#       
+#       void 
+#       Validate (TreeOctNode* node,
+#                 const Real& isoValue,
+#                 const int& maxDepth,
+#                 const int& fullDepthIso,
+#                 const int& subdivideDepth);
+# 
+#       void 
+#       Validate (TreeOctNode* node, const Real& isoValue, const int& maxDepth, const int& fullDepthIso);
+# 
+#       void 
+#       Subdivide (TreeOctNode* node, const Real& isoValue, const int& maxDepth);
+# 
+#       int 
+#       SetBoundaryMCRootPositions (const int& sDepth,const Real& isoValue,
+#                                   hash_map<long long,int>& boundaryRoots,
+#                                   hash_map<long long,
+#                                   std::pair<Real,Point3D<Real> > >& boundaryNormalHash,
+#                                   CoredMeshData* mesh,
+#                                   const int& nonLinearFit);
+# 
+#       int 
+#       SetMCRootPositions (TreeOctNode* node,
+#                           const int& sDepth,
+#                           const Real& isoValue,
+#                           hash_map<long long, int>& boundaryRoots,
+#                           hash_map<long long, int>* interiorRoots,
+#                           hash_map<long long, std::pair<Real,Point3D<Real> > >& boundaryNormalHash,
+#                           hash_map<long long, std::pair<Real,Point3D<Real> > >* interiorNormalHash,
+#                           std::vector<Point3D<float> >* interiorPositions,
+#                           CoredMeshData* mesh,
+#                           const int& nonLinearFit);
+# 
+#       int 
+#       GetMCIsoTriangles (TreeOctNode* node,
+#                          CoredMeshData* mesh,
+#                          hash_map<long long,int>& boundaryRoots,
+#                          hash_map<long long,int>* interiorRoots,
+#                          std::vector<Point3D<float> >* interiorPositions,
+#                          const int& offSet,
+#                          const int& sDepth, 
+#                          bool addBarycenter, 
+#                          bool polygonMesh);
+# 
+#       static int 
+#       AddTriangles (CoredMeshData* mesh,
+#                     std::vector<CoredPointIndex> edges[3],
+#                     std::vector<Point3D<float> >* interiorPositions, 
+#                     const int& offSet);
+#       
+#       static int 
+#       AddTriangles (CoredMeshData* mesh, 
+#                     std::vector<CoredPointIndex>& edges, std::vector<Point3D<float> >* interiorPositions, 
+#                     const int& offSet, 
+#                     bool addBarycenter, 
+#                     bool polygonMesh);
+# 
+#       void 
+#       GetMCIsoEdges (TreeOctNode* node,
+#                      hash_map<long long,int>& boundaryRoots,
+#                      hash_map<long long,int>* interiorRoots,
+#                      const int& sDepth,
+#                      std::vector<std::pair<long long,long long> >& edges);
+# 
+#       static int 
+#       GetEdgeLoops (std::vector<std::pair<long long,long long> >& edges,
+#                     std::vector<std::vector<std::pair<long long,long long> > >& loops);
+# 
+#       static int 
+#       InteriorFaceRootCount (const TreeOctNode* node,const int &faceIndex,const int& maxDepth);
+# 
+#       static int 
+#       EdgeRootCount (const TreeOctNode* node,const int& edgeIndex,const int& maxDepth);
+# 
+#       int 
+#       GetRoot (const RootInfo& ri,
+#                const Real& isoValue,
+#                const int& maxDepth,Point3D<Real> & position,
+#                hash_map<long long,std::pair<Real,Point3D<Real> > >& normalHash,
+#                Point3D<Real>* normal,
+#                const int& nonLinearFit);
+# 
+#       int 
+#       GetRoot (const RootInfo& ri,
+#                const Real& isoValue,
+#                Point3D<Real> & position,
+#                hash_map<long long,
+#                std::pair<Real,Point3D<Real> > >& normalHash,
+#                const int& nonLinearFit);
+# 
+#       static int 
+#       GetRootIndex (const TreeOctNode* node,const int& edgeIndex,const int& maxDepth,RootInfo& ri);
+# 
+#       static int 
+#       GetRootIndex (const TreeOctNode* node, 
+#                     const int& edgeIndex,
+#                     const int& maxDepth,
+#                     const int& sDepth,
+#                     RootInfo& ri);
+#       
+#       static int 
+#       GetRootIndex (const long long& key,
+#                     hash_map<long long,int>& boundaryRoots,
+#                     hash_map<long long,int>* interiorRoots,
+#                     CoredPointIndex& index);
+#       
+#       static int 
+#       GetRootPair (const RootInfo& root,const int& maxDepth,RootInfo& pair);
+# 
+#       int 
+#       NonLinearUpdateWeightContribution (TreeOctNode* node,
+#                                          const Point3D<Real>& position,
+#                                          const Real& weight = Real(1.0));
+# 
+#       Real 
+#       NonLinearGetSampleWeight (TreeOctNode* node,
+#                                 const Point3D<Real>& position);
+#       
+#       void 
+#       NonLinearGetSampleDepthAndWeight (TreeOctNode* node,
+#                                         const Point3D<Real>& position,
+#                                         const Real& samplesPerNode,
+#                                         Real& depth,
+#                                         Real& weight);
+# 
+#       int 
+#       NonLinearSplatOrientedPoint (TreeOctNode* node,
+#                                    const Point3D<Real>& point,
+#                                    const Point3D<Real>& normal);
+#       
+#       void 
+#       NonLinearSplatOrientedPoint (const Point3D<Real>& point,
+#                                    const Point3D<Real>& normal,
+#                                    const int& kernelDepth,
+#                                    const Real& samplesPerNode,
+#                                    const int& minDepth,
+#                                    const int& maxDepth);
+# 
+#       int 
+#       HasNormals (TreeOctNode* node,const Real& epsilon);
+# 
+#       Real 
+#       getCenterValue (const TreeOctNode* node);
+# 
+#       Real 
+#       getCornerValue (const TreeOctNode* node,const int& corner);
+# 
+#       void 
+#       getCornerValueAndNormal (const TreeOctNode* node,const int& corner,Real& value,Point3D<Real>& normal);
+# 
+#       public:
+#         static double maxMemoryUsage;
+#         static double 
+#         MemoryUsage ();
+# 
+#         std::vector<Point3D<Real> >* normals;
+#         Real postNormalSmooth;
+#         TreeOctNode tree;
+#         FunctionData<Degree,FunctionDataReal> fData;
+#         Octree ();
+# 
+#         void 
+#         setFunctionData (const PPolynomial<Degree>& ReconstructionFunction,
+#                          const int& maxDepth,
+#                          const int& normalize,
+#                          const Real& normalSmooth = -1);
+#         
+#         void 
+#         finalize1 (const int& refineNeighbors=-1);
+#         
+#         void 
+#         finalize2 (const int& refineNeighbors=-1);
+# 
+#         //int setTree(char* fileName,const int& maxDepth,const int& binary,const int& kernelDepth,const Real& samplesPerNode,
+#         //    const Real& scaleFactor,Point3D<Real>& center,Real& scale,const int& resetSampleDepths,const int& useConfidence);
+# 
+#         template<typename PointNT> int
+#         setTree (boost::shared_ptr<const pcl::PointCloud<PointNT> > input_,
+#                  const int& maxDepth,
+#                  const int& kernelDepth,
+#                  const Real& samplesPerNode,
+#                  const Real& scaleFactor,
+#                  Point3D<Real>& center,
+#                  Real& scale,
+#                  const int& resetSamples,
+#                  const int& useConfidence);
+# 
+# 
+#         void 
+#         SetLaplacianWeights (void);
+#         
+#         void 
+#         ClipTree (void);
+# 
+#         int 
+#         LaplacianMatrixIteration (const int& subdivideDepth);
+# 
+#         Real 
+#         GetIsoValue (void);
+#         
+#         void 
+#         GetMCIsoTriangles (const Real& isoValue,
+#                            CoredMeshData* mesh,
+#                            const int& fullDepthIso = 0,
+#                            const int& nonLinearFit = 1, 
+#                            bool addBarycenter = false, 
+#                            bool polygonMesh = false);
+#         
+#         void 
+#         GetMCIsoTriangles (const Real& isoValue,
+#                            const int& subdivideDepth,
+#                            CoredMeshData* mesh,
+#                            const int& fullDepthIso = 0,
+#                            const int& nonLinearFit = 1, 
+#                            bool addBarycenter = false, 
+#                            bool polygonMesh = false );
+#     };
+#   }
+# }
+# 
+###
+
+# octree_poisson.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/octree_poisson.h (1.7.2)
+# namespace pcl 
+# {
+#   namespace poisson 
+#   {
+# 
+#     template<class NodeData,class Real=float>
+#     class OctNode
+#     {
+#       private:
+#         static int UseAlloc;
+# 
+#         class AdjacencyCountFunction
+#         {
+#           public:
+#             int count;
+#             void Function(const OctNode<NodeData,Real>* node1,const OctNode<NodeData,Real>* node2);
+#         };
+# 
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeFaces (OctNode* node,
+#                                  NodeAdjacencyFunction* F,
+#                                  const int& cIndex1, const int& cIndex2, const int& cIndex3, const int& cIndex4);
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeEdges (OctNode* node,
+#                                  NodeAdjacencyFunction* F,
+#                                  const int& cIndex1, const int& cIndex2);
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeNodes (OctNode* node, NodeAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                 OctNode* node1, const int& radius1,
+#                                                 OctNode* node2, const int& radius2,
+#                                                 const int& cWidth2,
+#                                                 NodeAdjacencyFunction* F);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void __ProcessTerminatingNodeAdjacentNodes(const int& dx, const int& dy, const int& dz,
+#                                                           OctNode* node1, const int& radius1,
+#                                                           OctNode* node2, const int& radius2,
+#                                                           const int& cWidth2,
+#                                                           TerminatingNodeAdjacencyFunction* F);
+#         template<class PointAdjacencyFunction>
+#         static void __ProcessPointAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                  OctNode* node2, const int& radius2,
+#                                                  const int& cWidth2,
+#                                                  PointAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessFixedDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                           OctNode* node1, const int& radius1,
+#                                                           OctNode* node2, const int& radius2,
+#                                                           const int& cWidth2,
+#                                                           const int& depth,
+#                                                           NodeAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessMaxDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                         OctNode* node1, const int& radius1,
+#                                                         OctNode* node2, const int& radius2,
+#                                                         const int& cWidth2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F);
+# 
+#         // This is made private because the division by two has been pulled out.
+#         static inline int Overlap (const int& c1, const int& c2, const int& c3, const int& dWidth);
+#         inline static int ChildOverlap (const int& dx, const int& dy, const int& dz, const int& d, const int& cRadius2);
+# 
+#         const OctNode* __faceNeighbor (const int& dir, const int& off) const;
+#         const OctNode* __edgeNeighbor (const int& o, const int i[2], const int idx[2]) const;
+#         OctNode* __faceNeighbor (const int& dir, const int& off, const int& forceChildren);
+#         OctNode* __edgeNeighbor (const int& o, const int i[2], const int idx[2], const int& forceChildren);
+#       public:
+#         static const int DepthShift,OffsetShift,OffsetShift1,OffsetShift2,OffsetShift3;
+#         static const int DepthMask,OffsetMask;
+# 
+#         static Allocator<OctNode> AllocatorOctNode;
+#         static int UseAllocator (void);
+#         static void SetAllocator (int blockSize);
+# 
+#         OctNode* parent;
+#         OctNode* children;
+#         short d,off[3];
+#         NodeData nodeData;
+# 
+# 
+#         OctNode (void);
+#         ~OctNode (void);
+#         int initChildren (void);
+# 
+#         void depthAndOffset (int& depth, int offset[3]) const;
+#         int depth (void) const;
+#         static inline void DepthAndOffset (const long long& index, int& depth, int offset[3]);
+#         static inline void CenterAndWidth (const long long& index, Point3D<Real>& center, Real& width);
+#         static inline int Depth (const long long& index);
+#         static inline void Index (const int& depth, const int offset[3], short& d, short off[3]);
+#         void centerAndWidth (Point3D<Real>& center, Real& width) const;
+# 
+#         int leaves (void) const;
+#         int maxDepthLeaves (const int& maxDepth) const;
+#         int nodes (void) const;
+#         int maxDepth (void) const;
+# 
+#         const OctNode* root (void) const;
+# 
+#         const OctNode* nextLeaf (const OctNode* currentLeaf = NULL) const;
+#         OctNode* nextLeaf (OctNode* currentLeaf = NULL);
+#         const OctNode* nextNode (const OctNode* currentNode = NULL) const;
+#         OctNode* nextNode (OctNode* currentNode = NULL);
+#         const OctNode* nextBranch (const OctNode* current) const;
+#         OctNode* nextBranch (OctNode* current);
+# 
+#         void setFullDepth (const int& maxDepth);
+# 
+#         void printLeaves (void) const;
+#         void printRange (void) const;
+# 
+#         template<class NodeAdjacencyFunction>
+#         void processNodeFaces (OctNode* node,NodeAdjacencyFunction* F, const int& fIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeEdges (OctNode* node, NodeAdjacencyFunction* F, const int& eIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeCorners (OctNode* node, NodeAdjacencyFunction* F, const int& cIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeNodes (OctNode* node, NodeAdjacencyFunction* F, const int& processCurrent=1);
+# 
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessNodeAdjacentNodes (const int& maxDepth,
+#                                               OctNode* node1, const int& width1,
+#                                               OctNode* node2, const int& width2,
+#                                               NodeAdjacencyFunction* F,
+#                                               const int& processCurrent=1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                               OctNode* node1, const int& radius1,
+#                                               OctNode* node2, const int& radius2,
+#                                               const int& width2,
+#                                               NodeAdjacencyFunction* F,
+#                                               const int& processCurrent = 1);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void ProcessTerminatingNodeAdjacentNodes (const int& maxDepth,
+#                                                          OctNode* node1, const int& width1,
+#                                                          OctNode* node2, const int& width2,
+#                                                          TerminatingNodeAdjacencyFunction* F,
+#                                                          const int& processCurrent = 1);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void ProcessTerminatingNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                          OctNode* node1, const int& radius1,
+#                                                          OctNode* node2, const int& radius2,
+#                                                          const int& width2,
+#                                                          TerminatingNodeAdjacencyFunction* F,
+#                                                          const int& processCurrent = 1);
+#         template<class PointAdjacencyFunction>
+#         static void ProcessPointAdjacentNodes (const int& maxDepth,
+#                                                const int center1[3],
+#                                                OctNode* node2, const int& width2,
+#                                                PointAdjacencyFunction* F,
+#                                                const int& processCurrent = 1);
+#         template<class PointAdjacencyFunction>
+#         static void ProcessPointAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                OctNode* node2, const int& radius2, const int& width2,
+#                                                PointAdjacencyFunction* F,
+#                                                const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessFixedDepthNodeAdjacentNodes (const int& maxDepth,
+#                                                         OctNode* node1, const int& width1,
+#                                                         OctNode* node2, const int& width2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F,
+#                                                         const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessFixedDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                         OctNode* node1, const int& radius1,
+#                                                         OctNode* node2, const int& radius2,
+#                                                         const int& width2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F,
+#                                                         const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessMaxDepthNodeAdjacentNodes (const int& maxDepth,
+#                                                       OctNode* node1, const int& width1,
+#                                                       OctNode* node2, const int& width2,
+#                                                       const int& depth,
+#                                                       NodeAdjacencyFunction* F,
+#                                                       const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessMaxDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                       OctNode* node1, const int& radius1,
+#                                                       OctNode* node2, const int& radius2,
+#                                                       const int& width2,
+#                                                       const int& depth,
+#                                                       NodeAdjacencyFunction* F,
+#                                                       const int& processCurrent = 1);
+# 
+#         static int CornerIndex (const Point3D<Real>& center, const Point3D<Real> &p);
+# 
+#         OctNode* faceNeighbor (const int& faceIndex, const int& forceChildren = 0);
+#         const OctNode* faceNeighbor (const int& faceIndex) const;
+#         OctNode* edgeNeighbor (const int& edgeIndex, const int& forceChildren = 0);
+#         const OctNode* edgeNeighbor (const int& edgeIndex) const;
+#         OctNode* cornerNeighbor (const int& cornerIndex, const int& forceChildren = 0);
+#         const OctNode* cornerNeighbor (const int& cornerIndex) const;
+# 
+#         OctNode* getNearestLeaf (const Point3D<Real>& p);
+#         const OctNode* getNearestLeaf (const Point3D<Real>& p) const;
+# 
+#         static int CommonEdge (const OctNode* node1, const int& eIndex1,
+#                                const OctNode* node2, const int& eIndex2);
+#         static int CompareForwardDepths (const void* v1, const void* v2);
+#         static int CompareForwardPointerDepths (const void* v1, const void* v2);
+#         static int CompareBackwardDepths (const void* v1, const void* v2);
+#         static int CompareBackwardPointerDepths (const void* v1, const void* v2);
+# 
+# 
+#         template<class NodeData2>
+#         OctNode& operator = (const OctNode<NodeData2, Real>& node);
+# 
+#         static inline int Overlap2 (const int &depth1,
+#                                     const int offSet1[DIMENSION],
+#                                     const Real& multiplier1,
+#                                     const int &depth2,
+#                                     const int offSet2[DIMENSION],
+#                                     const Real& multiplier2);
+# 
+# 
+#         int write (const char* fileName) const;
+#         int write (FILE* fp) const;
+#         int read (const char* fileName);
+#         int read (FILE* fp);
+# 
+#         class Neighbors{
+#         public:
+#           OctNode* neighbors[3][3][3];
+#           Neighbors (void);
+#           void clear (void);
+#         };
+#         class NeighborKey{
+#         public:
+#           Neighbors* neighbors;
+# 
+#           NeighborKey (void);
+#           ~NeighborKey (void);
+# 
+#           void set (const int& depth);
+#           Neighbors& setNeighbors (OctNode* node);
+#           Neighbors& getNeighbors (OctNode* node);
+#         };
+#         class Neighbors2{
+#         public:
+#           const OctNode* neighbors[3][3][3];
+#           Neighbors2 (void);
+#           void clear (void);
+#         };
+#         class NeighborKey2{
+#         public:
+#           Neighbors2* neighbors;
+# 
+#           NeighborKey2 (void);
+#           ~NeighborKey2 (void);
+# 
+#           void set (const int& depth);
+#           Neighbors2& getNeighbors (const OctNode* node);
+#         };
+# 
+#         void centerIndex (const int& maxDepth, int index[DIMENSION]) const;
+#         int width (const int& maxDepth) const;
+#     };
+# 
+#   }
+# }
+###
+
+# organized_fast_mesh.h
+# namespace pcl
+# {
+# 
+#   /** \brief Simple triangulation/surface reconstruction for organized point
+#     * clouds. Neighboring points (pixels in image space) are connected to
+#     * construct a triangular mesh.
+#     *
+#     * \author Dirk Holz, Radu B. Rusu
+#     * \ingroup surface
+#     */
+#   template <typename PointInT>
+#   class OrganizedFastMesh : public MeshConstruction<PointInT>
+#   {
+#     public:
+#       using MeshConstruction<PointInT>::input_;
+#       using MeshConstruction<PointInT>::check_tree_;
+# 
+#       typedef typename pcl::PointCloud<PointInT>::Ptr PointCloudPtr;
+# 
+#       typedef std::vector<pcl::Vertices> Polygons;
+# 
+#       enum TriangulationType
+#       {
+#         TRIANGLE_RIGHT_CUT,     // _always_ "cuts" a quad from top left to bottom right
+#         TRIANGLE_LEFT_CUT,      // _always_ "cuts" a quad from top right to bottom left
+#         TRIANGLE_ADAPTIVE_CUT,  // "cuts" where possible and prefers larger differences in 'z' direction
+#         QUAD_MESH               // create a simple quad mesh
+#       };
+# 
+#       /** \brief Constructor. Triangulation type defaults to \a QUAD_MESH. */
+#       OrganizedFastMesh ()
+#       : max_edge_length_squared_ (0.025f)
+#       , triangle_pixel_size_ (1)
+#       , triangulation_type_ (QUAD_MESH)
+#       , store_shadowed_faces_ (false)
+#       , cos_angle_tolerance_ (fabsf (cosf (pcl::deg2rad (12.5f))))
+#       {
+#         check_tree_ = false;
+#       };
+# 
+#       /** \brief Destructor. */
+#       ~OrganizedFastMesh () {};
+# 
+#       /** \brief Set a maximum edge length. TODO: Implement!
+#         * \param[in] max_edge_length the maximum edge length
+#         */
+#       inline void
+#       setMaxEdgeLength (float max_edge_length)
+#       {
+#         max_edge_length_squared_ = max_edge_length * max_edge_length;
+#       };
+# 
+#       /** \brief Set the edge length (in pixels) used for constructing the fixed mesh.
+#         * \param[in] triangle_size edge length in pixels
+#         * (Default: 1 = neighboring pixels are connected)
+#         */
+#       inline void
+#       setTrianglePixelSize (int triangle_size)
+#       {
+#         triangle_pixel_size_ = std::max (1, (triangle_size - 1));
+#       }
+# 
+#       /** \brief Set the triangulation type (see \a TriangulationType)
+#         * \param[in] type quad mesh, triangle mesh with fixed left, right cut,
+#         * or adaptive cut (splits a quad wrt. the depth (z) of the points)
+#         */
+#       inline void
+#       setTriangulationType (TriangulationType type)
+#       {
+#         triangulation_type_ = type;
+#       }
+# 
+#       /** \brief Store shadowed faces or not.
+#         * \param[in] enable set to true to store shadowed faces
+#         */
+#       inline void
+#       storeShadowedFaces (bool enable)
+#       {
+#         store_shadowed_faces_ = enable;
+#       }
+# 
+#     protected:
+#       /** \brief max (squared) length of edge */
+#       float max_edge_length_squared_;
+# 
+#       /** \brief size of triangle endges (in pixels) */
+#       int triangle_pixel_size_;
+# 
+#       /** \brief Type of meshin scheme (quads vs. triangles, left cut vs. right cut ... */
+#       TriangulationType triangulation_type_;
+# 
+#       /** \brief Whether or not shadowed faces are stored, e.g., for exploration */
+#       bool store_shadowed_faces_;
+# 
+#       float cos_angle_tolerance_;
+# 
+#       /** \brief Perform the actual polygonal reconstruction.
+#         * \param[out] polygons the resultant polygons
+#         */
+#       void
+#       reconstructPolygons (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create the surface.
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       virtual void
+#       performReconstruction (std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Create the surface.
+#         *
+#         * Simply uses image indices to create an initial polygonal mesh for organized point clouds.
+#         * \a indices_ are ignored!
+#         *
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Add a new triangle to the current polygon mesh
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] idx the index in the set of polygon vertices (assumes \a idx is valid in \a polygons)
+#         * \param[out] polygons the polygon mesh to be updated
+#         */
+#       inline void
+#       addTriangle (int a, int b, int c, int idx, std::vector<pcl::Vertices>& polygons)
+#       {
+#         assert (idx < static_cast<int> (polygons.size ()));
+#         polygons[idx].vertices.resize (3);
+#         polygons[idx].vertices[0] = a;
+#         polygons[idx].vertices[1] = b;
+#         polygons[idx].vertices[2] = c;
+#       }
+# 
+#       /** \brief Add a new quad to the current polygon mesh
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         * \param[in] idx the index in the set of polygon vertices (assumes \a idx is valid in \a polygons)
+#         * \param[out] polygons the polygon mesh to be updated
+#         */
+#       inline void
+#       addQuad (int a, int b, int c, int d, int idx, std::vector<pcl::Vertices>& polygons)
+#       {
+#         assert (idx < static_cast<int> (polygons.size ()));
+#         polygons[idx].vertices.resize (4);
+#         polygons[idx].vertices[0] = a;
+#         polygons[idx].vertices[1] = b;
+#         polygons[idx].vertices[2] = c;
+#         polygons[idx].vertices[3] = d;
+#       }
+# 
+#       /** \brief Set (all) coordinates of a particular point to the specified value
+#         * \param[in] point_index index of point
+#         * \param[out] mesh to modify
+#         * \param[in] value value to use when re-setting
+#         * \param[in] field_x_idx the X coordinate of the point
+#         * \param[in] field_y_idx the Y coordinate of the point
+#         * \param[in] field_z_idx the Z coordinate of the point
+#         */
+#       inline void
+#       resetPointData (const int &point_index, pcl::PolygonMesh &mesh, const float &value = 0.0f,
+#                       int field_x_idx = 0, int field_y_idx = 1, int field_z_idx = 2)
+#       {
+#         float new_value = value;
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_x_idx].offset], &new_value, sizeof (float));
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_y_idx].offset], &new_value, sizeof (float));
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_z_idx].offset], &new_value, sizeof (float));
+#       }
+# 
+#       /** \brief Check if a point is shadowed by another point
+#         * \param[in] point_a the first point
+#         * \param[in] point_b the second point
+#         */
+#       inline bool
+#       isShadowed (const PointInT& point_a, const PointInT& point_b)
+#       {
+#         Eigen::Vector3f viewpoint = Eigen::Vector3f::Zero (); // TODO: allow for passing viewpoint information
+#         Eigen::Vector3f dir_a = viewpoint - point_a.getVector3fMap ();
+#         Eigen::Vector3f dir_b = point_b.getVector3fMap () - point_a.getVector3fMap ();
+#         float distance_to_points = dir_a.norm ();
+#         float distance_between_points = dir_b.norm ();
+#         float cos_angle = dir_a.dot (dir_b) / (distance_to_points*distance_between_points);
+#         if (cos_angle != cos_angle)
+#           cos_angle = 1.0f;
+#         return (fabs (cos_angle) >= cos_angle_tolerance_);
+#         // TODO: check for both: angle almost 0/180 _and_ distance between points larger than noise level
+#       }
+# 
+#       /** \brief Check if a triangle is valid.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         */
+#       inline bool
+#       isValidTriangle (const int& a, const int& b, const int& c)
+#       {
+#         if (!pcl::isFinite (input_->points[a])) return (false);
+#         if (!pcl::isFinite (input_->points[b])) return (false);
+#         if (!pcl::isFinite (input_->points[c])) return (false);
+#         return (true);
+#       }
+# 
+#       /** \brief Check if a triangle is shadowed.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         */
+#       inline bool
+#       isShadowedTriangle (const int& a, const int& b, const int& c)
+#       {
+#         if (isShadowed (input_->points[a], input_->points[b])) return (true);
+#         if (isShadowed (input_->points[b], input_->points[c])) return (true);
+#         if (isShadowed (input_->points[c], input_->points[a])) return (true);
+#         return (false);
+#       }
+# 
+#       /** \brief Check if a quad is valid.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         */
+#       inline bool
+#       isValidQuad (const int& a, const int& b, const int& c, const int& d)
+#       {
+#         if (!pcl::isFinite (input_->points[a])) return (false);
+#         if (!pcl::isFinite (input_->points[b])) return (false);
+#         if (!pcl::isFinite (input_->points[c])) return (false);
+#         if (!pcl::isFinite (input_->points[d])) return (false);
+#         return (true);
+#       }
+# 
+#       /** \brief Check if a triangle is shadowed.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         */
+#       inline bool
+#       isShadowedQuad (const int& a, const int& b, const int& c, const int& d)
+#       {
+#         if (isShadowed (input_->points[a], input_->points[b])) return (true);
+#         if (isShadowed (input_->points[b], input_->points[c])) return (true);
+#         if (isShadowed (input_->points[c], input_->points[d])) return (true);
+#         if (isShadowed (input_->points[d], input_->points[a])) return (true);
+#         return (false);
+#       }
+# 
+#       /** \brief Create a quad mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeQuadMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create a right cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeRightCutMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create a left cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeLeftCutMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create an adaptive cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeAdaptiveCutMesh (std::vector<pcl::Vertices>& polygons);
+#   };
+# 
+###
+
+# poisson.h
+# namespace pcl
+# {
+#   /** \brief The Poisson surface reconstruction algorithm.
+#     * \note Code adapted from Misha Kazhdan: http://www.cs.jhu.edu/~misha/Code/PoissonRecon/
+#     * \note Based on the paper:
+#     *       * Michael Kazhdan, Matthew Bolitho, Hugues Hoppe, "Poisson surface reconstruction",
+#     *         SGP '06 Proceedings of the fourth Eurographics symposium on Geometry processing
+#     * \author Alexandru-Eugen Ichim
+#     * \ingroup surface
+#     */
+#   template<typename PointNT>
+#   class Poisson : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+#       /** \brief Constructor that sets all the parameters to working default values. */
+#       Poisson ();
+# 
+#       /** \brief Destructor. */
+#       ~Poisson ();
+# 
+#       /** \brief Create the surface.
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Create the surface.
+#         * \param[out] points the vertex positions of the resulting mesh
+#         * \param[out] polygons the connectivity of the resulting mesh
+#         */
+#       void
+#       performReconstruction (pcl::PointCloud<PointNT> &points,
+#                              std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Set the confidence flag
+#         * \note Enabling this flag tells the reconstructor to use the size of the normals as confidence information.
+#         * When the flag is not enabled, all normals are normalized to have unit-length prior to reconstruction.
+#         * \param[in] confidence the given flag
+#         */
+#       inline void
+#       setConfidence (bool confidence) { confidence_ = confidence; }
+# 
+#       /** \brief Get the confidence flag */
+#       inline bool
+#       getConfidence () { return confidence_; }
+# 
+#       /** \brief Set the manifold flag.
+#         * \note Enabling this flag tells the reconstructor to add the polygon barycenter when triangulating polygons
+#         * with more than three vertices.
+#         * \param[in] manifold the given flag
+#         */
+#       inline void
+#       setManifold (bool manifold) { manifold_ = manifold; }
+# 
+#       /** \brief Get the manifold flag */
+#       inline bool
+#       getManifold () { return manifold_; }
+# 
+#       /** \brief Enabling this flag tells the reconstructor to output a polygon mesh (rather than triangulating the
+#         * results of Marching Cubes).
+#         * \param[in] output_polygons the given flag
+#         */
+#       inline void
+#       setOutputPolygons (bool output_polygons) { output_polygons_ = output_polygons; }
+# 
+#       /** \brief Get whether the algorithm outputs a polygon mesh or a triangle mesh */
+#       inline bool
+#       getOutputPolygons () { return output_polygons_; }
+# 
+# 
+#       /** \brief Set the maximum depth of the tree that will be used for surface reconstruction.
+#         * \note Running at depth d corresponds to solving on a voxel grid whose resolution is no larger than
+#         * 2^d x 2^d x 2^d. Note that since the reconstructor adapts the octree to the sampling density, the specified
+#         * reconstruction depth is only an upper bound.
+#         * \param[in] depth the depth parameter
+#         */
+#       inline void
+#       setDepth (int depth) { depth_ = depth; }
+# 
+#       /** \brief Get the depth parameter */
+#       inline int
+#       getDepth () { return depth_; }
+# 
+#       /** \brief Set the the depth at which a block Gauss-Seidel solver is used to solve the Laplacian equation
+#         * \note Using this parameter helps reduce the memory overhead at the cost of a small increase in
+#         * reconstruction time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide
+#         * depth of 7 or 8 can greatly reduce the memory usage.)
+#         * \param[in] solver_divide the given parameter value
+#         */
+#       inline void
+#       setSolverDivide (int solver_divide) { solver_divide_ = solver_divide; }
+# 
+#       /** \brief Get the the depth at which a block Gauss-Seidel solver is used to solve the Laplacian equation */
+#       inline int
+#       getSolverDivide () { return solver_divide_; }
+# 
+#       /** \brief Set the depth at which a block iso-surface extractor should be used to extract the iso-surface
+#         * \note Using this parameter helps reduce the memory overhead at the cost of a small increase in extraction
+#         * time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide depth of 7 or 8
+#         * can greatly reduce the memory usage.)
+#         * \param[in] iso_divide the given parameter value
+#         */
+#       inline void
+#       setIsoDivide (int iso_divide) { iso_divide_ = iso_divide; }
+# 
+#       /** \brief Get the depth at which a block iso-surface extractor should be used to extract the iso-surface */
+#       inline int
+#       getIsoDivide () { return iso_divide_; }
+# 
+#       /** \brief Set the minimum number of sample points that should fall within an octree node as the octree
+#         * construction is adapted to sampling density
+#         * \note For noise-free samples, small values in the range [1.0 - 5.0] can be used. For more noisy samples,
+#         * larger values in the range [15.0 - 20.0] may be needed to provide a smoother, noise-reduced, reconstruction.
+#         * \param[in] samples_per_node the given parameter value
+#         */
+#       inline void
+#       setSamplesPerNode (float samples_per_node) { samples_per_node_ = samples_per_node; }
+# 
+#       /** \brief Get the minimum number of sample points that should fall within an octree node as the octree
+#         * construction is adapted to sampling density
+#         */
+#       inline float
+#       getSamplesPerNode () { return samples_per_node_; }
+# 
+#       /** \brief Set the ratio between the diameter of the cube used for reconstruction and the diameter of the
+#         * samples' bounding cube.
+#         * \param[in] scale the given parameter value
+#         */
+#       inline void
+#       setScale (float scale) { scale_ = scale; }
+# 
+#       /** Get the ratio between the diameter of the cube used for reconstruction and the diameter of the
+#         * samples' bounding cube.
+#         */
+#       inline float
+#       getScale () { return scale_; }
+# 
+#       /** \brief Set the degree parameter
+#         * \param[in] degree the given degree
+#         */
+#       inline void
+#       setDegree (int degree) { degree_ = degree; }
+# 
+#       /** \brief Get the degree parameter */
+#       inline int
+#       getDegree () { return degree_; }
+# 
+# 
+#     protected:
+#       /** \brief The point cloud input (XYZ+Normals). */
+#       PointCloudPtr data_;
+# 
+#       /** \brief Class get name method. */
+#       std::string
+#       getClassName () const { return ("Poisson"); }
+# 
+#     private:
+#       bool no_reset_samples_;
+#       bool no_clip_tree_;
+#       bool confidence_;
+#       bool manifold_;
+#       bool output_polygons_;
+# 
+#       int depth_;
+#       int solver_divide_;
+#       int iso_divide_;
+#       int refine_;
+#       int kernel_depth_;
+#       int degree_;
+# 
+#       float samples_per_node_;
+#       float scale_;
+# 
+#       template<int Degree> void
+#       execute (poisson::CoredMeshData &mesh,
+#                poisson::Point3D<float> &translate,
+#                float &scale);
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+###
+
+# polynomial.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/polynomial.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# template<int Degree>
+# class Polynomial
+#       public:
+#       double coefficients[Degree+1];
+# 
+#       Polynomial(void);
+#       template<int Degree2>
+#       Polynomial(const Polynomial<Degree2>& P);
+#       double operator() (const double& t) const;
+#       double integral (const double& tMin,const double& tMax) const;
+# 
+#       int operator == (const Polynomial& p) const;
+#       int operator != (const Polynomial& p) const;
+#       int isZero(void) const;
+#       void setZero(void);
+# 
+#       template<int Degree2>
+#       Polynomial& operator  = (const Polynomial<Degree2> &p);
+#       Polynomial& operator += (const Polynomial& p);
+#       Polynomial& operator -= (const Polynomial& p);
+#       Polynomial  operator -  (void) const;
+#       Polynomial  operator +  (const Polynomial& p) const;
+#       Polynomial  operator -  (const Polynomial& p) const;
+#       template<int Degree2>
+#       Polynomial<Degree+Degree2>  operator *  (const Polynomial<Degree2>& p) const;
+# 
+#       Polynomial& operator += (const double& s);
+#       Polynomial& operator -= (const double& s);
+#       Polynomial& operator *= (const double& s);
+#       Polynomial& operator /= (const double& s);
+#       Polynomial  operator +  (const double& s) const;
+#       Polynomial  operator -  (const double& s) const;
+#       Polynomial  operator *  (const double& s) const;
+#       Polynomial  operator /  (const double& s) const;
+# 
+#       Polynomial scale (const double& s) const;
+#       Polynomial shift (const double& t) const;
+# 
+#       Polynomial<Degree-1> derivative (void) const;
+#       Polynomial<Degree+1> integral (void) const;
+# 
+#       void printnl (void) const;
+# 
+#       Polynomial& addScaled (const Polynomial& p, const double& scale);
+# 
+#       static void Negate (const Polynomial& in, Polynomial& out);
+#       static void Subtract (const Polynomial& p1, const Polynomial& p2, Polynomial& q);
+#       static void Scale (const Polynomial& p, const double& w, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const double& w1, const Polynomial& p2, const double& w2, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const Polynomial& p2, const double& w2, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const double& w1, const Polynomial& p2, Polynomial& q);
+# 
+#       void getSolutions (const double& c, std::vector<double>& roots, const double& EPS) const;
+#     };
+#   }
+# }
+###
+
+# ppolynomial.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/ppolynomial.h (1.7.2)
+# namespace pcl
+# {
+#   namespace poisson
+#   {
+#     template <int Degree> 
+#     class StartingPolynomial
+#     {
+#       public:
+#         Polynomial<Degree> p;
+#         double start;
+# 
+#         StartingPolynomial () : p (), start () {}
+# 
+#         template <int Degree2> StartingPolynomial<Degree+Degree2> operator* (const StartingPolynomial<Degree2>&p) const;
+#         StartingPolynomial scale (const double&s) const;
+#         StartingPolynomial shift (const double&t) const;
+#         int operator < (const StartingPolynomial &sp) const;
+#         static int Compare (const void *v1,const void *v2);
+#     };
+# 
+#     template <int Degree> 
+#     class PPolynomial
+#     {
+#       public:
+#         size_t polyCount;
+#         StartingPolynomial<Degree>*polys;
+# 
+#         PPolynomial (void);
+#         PPolynomial (const PPolynomial<Degree>&p);
+#         ~PPolynomial (void);
+# 
+#         PPolynomial& operator = (const PPolynomial&p);
+# 
+#         int size (void) const;
+# 
+#         void set (const size_t&size);
+#         // Note: this method will sort the elements in sps
+#         void set (StartingPolynomial<Degree>*sps,const int&count);
+#         void reset (const size_t&newSize);
+# 
+# 
+#         double operator() (const double &t) const;
+#         double integral (const double &tMin,const double &tMax) const;
+#         double Integral (void) const;
+# 
+#         template <int Degree2> PPolynomial<Degree>& operator = (const PPolynomial<Degree2>&p);
+# 
+#         PPolynomial operator + (const PPolynomial&p) const;
+#         PPolynomial operator - (const PPolynomial &p) const;
+# 
+#         template <int Degree2> PPolynomial<Degree+Degree2> operator * (const Polynomial<Degree2> &p) const;
+# 
+#         template <int Degree2> PPolynomial<Degree+Degree2> operator* (const PPolynomial<Degree2>&p) const;
+# 
+# 
+#         PPolynomial& operator += (const double&s);
+#         PPolynomial& operator -= (const double&s);
+#         PPolynomial& operator *= (const double&s);
+#         PPolynomial& operator /= (const double&s);
+#         PPolynomial operator +  (const double&s) const;
+#         PPolynomial operator -  (const double&s) const;
+#         PPolynomial operator*  (const double&s) const;
+#         PPolynomial operator /  (const double &s) const;
+# 
+#         PPolynomial& addScaled (const PPolynomial &poly,const double &scale);
+# 
+#         PPolynomial scale (const double &s) const;
+#         PPolynomial shift (const double &t) const;
+# 
+#         PPolynomial<Degree-1> derivative (void) const;
+#         PPolynomial<Degree+1> integral (void) const;
+# 
+#         void getSolutions (const double &c,
+#                            std::vector<double> &roots,
+#                            const double &EPS,
+#                            const double &min =- DBL_MAX,
+#                            const double &max=DBL_MAX) const;
+# 
+#         void printnl (void) const;
+# 
+#         PPolynomial<Degree+1> MovingAverage (const double &radius);
+# 
+#         static PPolynomial ConstantFunction (const double &width=0.5);
+#         static PPolynomial GaussianApproximation (const double &width=0.5);
+#         void write (FILE *fp,
+#                     const int &samples,
+#                     const double &min,
+#                     const double &max) const;
+#     };
+# 
+# 
+#   }
+# }
+###
+
+# qhull.h
+# 
+# #if defined __GNUC__
+# #  pragma GCC system_header 
+# #endif
+# 
+# extern "C"
+# {
+# #ifdef HAVE_QHULL_2011
+# #  include "libqhull/libqhull.h"
+# #  include "libqhull/mem.h"
+# #  include "libqhull/qset.h"
+# #  include "libqhull/geom.h"
+# #  include "libqhull/merge.h"
+# #  include "libqhull/poly.h"
+# #  include "libqhull/io.h"
+# #  include "libqhull/stat.h"
+# #else
+# #  include "qhull/qhull.h"
+# #  include "qhull/mem.h"
+# #  include "qhull/qset.h"
+# #  include "qhull/geom.h"
+# #  include "qhull/merge.h"
+# #  include "qhull/poly.h"
+# #  include "qhull/io.h"
+# #  include "qhull/stat.h"
+# #endif
+# }
+# 
+###
+
+# simplification_remove_unused_vertices.h
+# namespace pcl
+# {
+#   namespace surface
+#   {
+#     class PCL_EXPORTS SimplificationRemoveUnusedVertices
+#     {
+#       public:
+#         /** \brief Constructor. */
+#         SimplificationRemoveUnusedVertices () {};
+#         /** \brief Destructor. */
+#         ~SimplificationRemoveUnusedVertices () {};
+# 
+#         /** \brief Simply a polygonal mesh.
+#           * \param[in] input the input mesh
+#           * \param[out] output the output mesh
+#           */
+#         inline void
+#         simplify (const pcl::PolygonMesh& input, pcl::PolygonMesh& output)
+#         {
+#           std::vector<int> indices;
+#           simplify (input, output, indices);
+#         }
+# 
+#         /** \brief Perform simplification (remove unused vertices).
+#           * \param[in] input the input mesh
+#           * \param[out] output the output mesh
+#           * \param[out] indices the resultant vector of indices
+#           */
+#         void
+#         simplify (const pcl::PolygonMesh& input, pcl::PolygonMesh& output, std::vector<int>& indices);
+# 
+#     };
+#   }
+###
+
+# sparse_matrix.h
+# pcl/surface/3rdparty/poisson4/sparse_matrix.h (1.7.2)
+# 
+# namespace pcl 
+# namespace poisson 
+# template <class T>
+# struct MatrixEntry
+#     {
+#       MatrixEntry () : N (-1), Value (0) {}
+#       MatrixEntry (int i) : N (i), Value (0) {}
+#       int N;
+#       T Value;
+#     };
+# 
+#     template <class T,int Dim>
+#     struct NMatrixEntry
+#     {
+#       NMatrixEntry () : N (-1), Value () { memset (Value, 0, sizeof (T) * Dim); }
+#       NMatrixEntry (int i) : N (i), Value () { memset (Value, 0, sizeof (T) * Dim); }
+#       int N;
+#       T Value[Dim];
+#     };
+# 
+#     template<class T> class SparseMatrix
+#     {
+#       private:
+#         static int UseAlloc;
+#       public:
+#         static Allocator<MatrixEntry<T> > AllocatorMatrixEntry;
+#         static int UseAllocator (void);
+#         static void SetAllocator (const int& blockSize);
+# 
+#         int rows;
+#         int* rowSizes;
+#         MatrixEntry<T>** m_ppElements;
+# 
+#         SparseMatrix ();
+#         SparseMatrix (int rows);
+#         void Resize (int rows);
+#         void SetRowSize (int row , int count);
+#         int Entries (void);
+# 
+#         SparseMatrix (const SparseMatrix& M);
+#         virtual ~SparseMatrix ();
+# 
+#         void SetZero ();
+#         void SetIdentity ();
+# 
+#         SparseMatrix<T>& operator = (const SparseMatrix<T>& M);
+# 
+#         SparseMatrix<T> operator * (const T& V) const;
+#         SparseMatrix<T>& operator *= (const T& V);
+# 
+# 
+#         SparseMatrix<T> operator * (const SparseMatrix<T>& M) const;
+#         SparseMatrix<T> Multiply (const SparseMatrix<T>& M) const;
+#         SparseMatrix<T> MultiplyTranspose (const SparseMatrix<T>& Mt) const;
+# 
+#         template<class T2>
+#         Vector<T2> operator * (const Vector<T2>& V) const;
+#         template<class T2>
+#         Vector<T2> Multiply (const Vector<T2>& V) const;
+#         template<class T2>
+#         void Multiply (const Vector<T2>& In, Vector<T2>& Out) const;
+# 
+# 
+#         SparseMatrix<T> Transpose() const;
+# 
+#         static int Solve (const SparseMatrix<T>& M,
+#                           const Vector<T>& b,
+#                           const int& iters,
+#                           Vector<T>& solution,
+#                           const T eps = 1e-8);
+# 
+#         template<class T2>
+#         static int SolveSymmetric (const SparseMatrix<T>& M,
+#                                    const Vector<T2>& b,
+#                                    const int& iters,
+#                                    Vector<T2>& solution,
+#                                    const T2 eps = 1e-8,
+#                                    const int& reset=1);
+# 
+#     };
+# 
+#     template<class T,int Dim> class SparseNMatrix
+#     {
+#       private:
+#         static int UseAlloc;
+#       public:
+#         static Allocator<NMatrixEntry<T,Dim> > AllocatorNMatrixEntry;
+#         static int UseAllocator (void);
+#         static void SetAllocator (const int& blockSize);
+# 
+#         int rows;
+#         int* rowSizes;
+#         NMatrixEntry<T,Dim>** m_ppElements;
+# 
+#         SparseNMatrix ();
+#         SparseNMatrix (int rows);
+#         void Resize (int rows);
+#         void SetRowSize (int row, int count);
+#         int Entries ();
+# 
+#         SparseNMatrix (const SparseNMatrix& M);
+#         ~SparseNMatrix ();
+# 
+#         SparseNMatrix& operator = (const SparseNMatrix& M);
+# 
+#         SparseNMatrix  operator *  (const T& V) const;
+#         SparseNMatrix& operator *= (const T& V);
+# 
+#         template<class T2>
+#         NVector<T2,Dim> operator * (const Vector<T2>& V) const;
+#         template<class T2>
+#         Vector<T2> operator * (const NVector<T2,Dim>& V) const;
+#     };
+# 
+#     template <class T>
+#     class SparseSymmetricMatrix : public SparseMatrix<T>
+#     {
+#       public:
+#         virtual ~SparseSymmetricMatrix () {}
+# 
+#         template<class T2>
+#         Vector<T2> operator * (const Vector<T2>& V) const;
+# 
+#         template<class T2>
+#         Vector<T2> Multiply (const Vector<T2>& V ) const;
+# 
+#         template<class T2> void 
+#         Multiply (const Vector<T2>& In, Vector<T2>& Out ) const;
+# 
+#         template<class T2> static int 
+#         Solve (const SparseSymmetricMatrix<T>& M,
+#                const Vector<T2>& b,
+#                const int& iters,
+#                Vector<T2>& solution,
+#                const T2 eps = 1e-8,
+#                const int& reset=1);
+# 
+#         template<class T2> static int 
+#         Solve (const SparseSymmetricMatrix<T>& M,
+#                const Vector<T>& diagonal,
+#                const Vector<T2>& b,
+#                const int& iters,
+#                Vector<T2>& solution,
+#                const T2 eps = 1e-8,
+#                const int& reset=1);
+#     };
+#   }
+# 
+###
+
+# surfel_smoothing.h
+# namespace pcl
+# {
+#   template <typename PointT, typename PointNT>
+#   class SurfelSmoothing : public PCLBase<PointT>
+#   {
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::initCompute;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloudIn;
+#       typedef typename pcl::PointCloud<PointT>::Ptr PointCloudInPtr;
+#       typedef pcl::PointCloud<PointNT> NormalCloud;
+#       typedef typename pcl::PointCloud<PointNT>::Ptr NormalCloudPtr;
+#       typedef pcl::search::Search<PointT> CloudKdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr CloudKdTreePtr;
+# 
+#       SurfelSmoothing (float a_scale = 0.01)
+#         : PCLBase<PointT> ()
+#         , scale_ (a_scale)
+#         , scale_squared_ (a_scale * a_scale)
+#         , normals_ ()
+#         , interm_cloud_ ()
+#         , interm_normals_ ()
+#         , tree_ ()
+#       {
+#       }
+# 
+#       void
+#       setInputNormals (NormalCloudPtr &a_normals) { normals_ = a_normals; };
+# 
+#       void
+#       setSearchMethod (const CloudKdTreePtr &a_tree) { tree_ = a_tree; };
+# 
+#       bool
+#       initCompute ();
+# 
+#       float
+#       smoothCloudIteration (PointCloudInPtr &output_positions,
+#                             NormalCloudPtr &output_normals);
+# 
+#       void
+#       computeSmoothedCloud (PointCloudInPtr &output_positions,
+#                             NormalCloudPtr &output_normals);
+# 
+# 
+#       void
+#       smoothPoint (size_t &point_index,
+#                    PointT &output_point,
+#                    PointNT &output_normal);
+# 
+#       void
+#       extractSalientFeaturesBetweenScales (PointCloudInPtr &cloud2,
+#                                            NormalCloudPtr &cloud2_normals,
+#                                            boost::shared_ptr<std::vector<int> > &output_features);
+# 
+#     private:
+#       float scale_, scale_squared_;
+#       NormalCloudPtr normals_;
+# 
+#       PointCloudInPtr interm_cloud_;
+#       NormalCloudPtr interm_normals_;
+# 
+#       CloudKdTreePtr tree_;
+# 
+#   };
+###
+
+# texture_mapping.h
+# namespace pcl
+# {
+#   namespace texture_mapping
+#   {
+#         
+#     /** \brief Structure to store camera pose and focal length. */
+#     struct Camera
+#     {
+#       Camera () : pose (), focal_length (), height (), width (), texture_file () {}
+#       Eigen::Affine3f pose;
+#       double focal_length;
+#       double height;
+#       double width;
+#       std::string texture_file;
+# 
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#     };
+# 
+#     /** \brief Structure that links a uv coordinate to its 3D point and face.
+#       */
+#     struct UvIndex
+#     {
+#       UvIndex () : idx_cloud (), idx_face () {}
+#       int idx_cloud; // Index of the PointXYZ in the camera's cloud
+#       int idx_face; // Face corresponding to that projection
+#     };
+#     
+#     typedef std::vector<Camera, Eigen::aligned_allocator<Camera> > CameraVector;
+#     
+#   }
+#   
+#   /** \brief The texture mapping algorithm
+#     * \author Khai Tran, Raphael Favier
+#     * \ingroup surface
+#     */
+#   template<typename PointInT>
+#   class TextureMapping
+#   {
+#     public:
+#      
+#       typedef boost::shared_ptr< PointInT > Ptr;
+#       typedef boost::shared_ptr< const PointInT > ConstPtr;
+# 
+#       typedef pcl::PointCloud<PointInT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef pcl::octree::OctreePointCloudSearch<PointInT> Octree;
+#       typedef typename Octree::Ptr OctreePtr;
+#       typedef typename Octree::ConstPtr OctreeConstPtr;
+#       
+#       typedef pcl::texture_mapping::Camera Camera;
+#       typedef pcl::texture_mapping::UvIndex UvIndex;
+# 
+#       /** \brief Constructor. */
+#       TextureMapping () :
+#         f_ (), vector_field_ (), tex_files_ (), tex_material_ ()
+#       {
+#       }
+# 
+#       /** \brief Destructor. */
+#       ~TextureMapping ()
+#       {
+#       }
+# 
+#       /** \brief Set mesh scale control
+#         * \param[in] f
+#         */
+#       inline void
+#       setF (float f)
+#       {
+#         f_ = f;
+#       }
+# 
+#       /** \brief Set vector field
+#         * \param[in] x data point x
+#         * \param[in] y data point y
+#         * \param[in] z data point z
+#         */
+#       inline void
+#       setVectorField (float x, float y, float z)
+#       {
+#         vector_field_ = Eigen::Vector3f (x, y, z);
+#         // normalize vector field
+#         vector_field_ = vector_field_ / std::sqrt (vector_field_.dot (vector_field_));
+#       }
+# 
+#       /** \brief Set texture files
+#         * \param[in] tex_files list of texture files
+#         */
+#       inline void
+#       setTextureFiles (std::vector<std::string> tex_files)
+#       {
+#         tex_files_ = tex_files;
+#       }
+# 
+#       /** \brief Set texture materials
+#         * \param[in] tex_material texture material
+#         */
+#       inline void
+#       setTextureMaterials (TexMaterial tex_material)
+#       {
+#         tex_material_ = tex_material;
+#       }
+# 
+#       /** \brief Map texture to a mesh synthesis algorithm
+#         * \param[in] tex_mesh texture mesh
+#         */
+#       void
+#       mapTexture2Mesh (pcl::TextureMesh &tex_mesh);
+# 
+#       /** \brief map texture to a mesh UV mapping
+#         * \param[in] tex_mesh texture mesh
+#         */
+#       void
+#       mapTexture2MeshUV (pcl::TextureMesh &tex_mesh);
+# 
+#       /** \brief map textures aquired from a set of cameras onto a mesh.
+#         * \details With UV mapping, the mesh must be divided into NbCamera + 1 sub-meshes.
+#         * Each sub-mesh corresponding to the faces visible by one camera. The last submesh containing all non-visible faces
+#         * \param[in] tex_mesh texture mesh
+#         * \param[in] cams cameras used for UV mapping
+#         */
+#       void
+#       mapMultipleTexturesToMeshUV (pcl::TextureMesh &tex_mesh, 
+#                                    pcl::texture_mapping::CameraVector &cams);
+# 
+#       /** \brief computes UV coordinates of point, observed by one particular camera
+#         * \param[in] pt XYZ point to project on camera plane
+#         * \param[in] cam the camera used for projection
+#         * \param[out] UV_coordinates the resulting uv coordinates. Set to (-1.0,-1.0) if the point is not visible by the camera
+#         * \returns false if the point is not visible by the camera
+#         */
+#       inline bool
+#       getPointUVCoordinates (const pcl::PointXYZ &pt, const Camera &cam, Eigen::Vector2f &UV_coordinates)
+#       {
+#         // if the point is in front of the camera
+#         if (pt.z > 0)
+#         {
+#           // compute image center and dimension
+#           double sizeX = cam.width;
+#           double sizeY = cam.height;
+#           double cx = (sizeX) / 2.0;
+#           double cy = (sizeY) / 2.0;
+# 
+#           double focal_x = cam.focal_length;
+#           double focal_y = cam.focal_length;
+# 
+#           // project point on image frame
+#           UV_coordinates[0] = static_cast<float> ((focal_x * (pt.x / pt.z) + cx) / sizeX); //horizontal
+#           UV_coordinates[1] = 1.0f - static_cast<float> (((focal_y * (pt.y / pt.z) + cy) / sizeY)); //vertical
+# 
+#           // point is visible!
+#           if (UV_coordinates[0] >= 0.0 && UV_coordinates[0] <= 1.0 && UV_coordinates[1] >= 0.0 && UV_coordinates[1]
+#                                                                                                                  <= 1.0)
+#             return (true);
+#         }
+# 
+#         // point is NOT visible by the camera
+#         UV_coordinates[0] = -1.0;
+#         UV_coordinates[1] = -1.0;
+#         return (false);
+#       }
+# 
+#       /** \brief Check if a point is occluded using raycasting on octree.
+#         * \param[in] pt XYZ from which the ray will start (toward the camera)
+#         * \param[in] octree the octree used for raycasting. It must be initialized with a cloud transformed into the camera's frame
+#         * \returns true if the point is occluded.
+#         */
+#       inline bool
+#       isPointOccluded (const pcl::PointXYZ &pt, const OctreePtr octree);
+# 
+#       /** \brief Remove occluded points from a point cloud
+#         * \param[in] input_cloud the cloud on which to perform occlusion detection
+#         * \param[out] filtered_cloud resulting cloud, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         * \param[out] visible_indices will contain indices of visible points
+#         * \param[out] occluded_indices will contain indices of occluded points
+#         */
+#       void
+#       removeOccludedPoints (const PointCloudPtr &input_cloud,
+#                             PointCloudPtr &filtered_cloud, const double octree_voxel_size,
+#                             std::vector<int> &visible_indices, std::vector<int> &occluded_indices);
+# 
+#       /** \brief Remove occluded points from a textureMesh
+#         * \param[in] tex_mesh input mesh, on witch to perform occlusion detection
+#         * \param[out] cleaned_mesh resulting mesh, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         */
+#       void
+#       removeOccludedPoints (const pcl::TextureMesh &tex_mesh, pcl::TextureMesh &cleaned_mesh, const double octree_voxel_size);
+# 
+# 
+#       /** \brief Remove occluded points from a textureMesh
+#         * \param[in] tex_mesh input mesh, on witch to perform occlusion detection
+#         * \param[out] filtered_cloud resulting cloud, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         */
+#       void
+#       removeOccludedPoints (const pcl::TextureMesh &tex_mesh, PointCloudPtr &filtered_cloud, const double octree_voxel_size);
+# 
+# 
+#       /** \brief Segment faces by camera visibility. Point-based segmentation.
+#         * \details With N camera, faces will be arranged into N+1 groups: 1 for each camera, plus 1 for faces not visible from any camera.
+#         * \param[in] tex_mesh input mesh that needs sorting. Must contain only 1 sub-mesh.
+#         * \param[in] sorted_mesh resulting mesh, will contain nbCamera + 1 sub-mesh.
+#         * \param[in] cameras vector containing the cameras used for texture mapping.
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         * \param[out] visible_pts cloud containing only visible points
+#         */
+#       int
+#       sortFacesByCamera (pcl::TextureMesh &tex_mesh, 
+#                          pcl::TextureMesh &sorted_mesh, 
+#                          const pcl::texture_mapping::CameraVector &cameras,
+#                          const double octree_voxel_size, PointCloud &visible_pts);
+# 
+#       /** \brief Colors a point cloud, depending on its occlusions.
+#         * \details If showNbOcclusions is set to True, each point is colored depending on the number of points occluding it.
+#         * Else, each point is given a different a 0 value is not occluded, 1 if occluded.
+#         * By default, the number of occlusions is bounded to 4.
+#         * \param[in] input_cloud input cloud on which occlusions will be computed.
+#         * \param[out] colored_cloud resulting colored cloud showing the number of occlusions per point.
+#         * \param[in] octree_voxel_size octree resolution (in meters).
+#         * \param[in] show_nb_occlusions If false, color information will only represent.
+#         * \param[in] max_occlusions Limit the number of occlusions per point.
+#         */
+#       void
+#       showOcclusions (const PointCloudPtr &input_cloud, 
+#                       pcl::PointCloud<pcl::PointXYZI>::Ptr &colored_cloud,
+#                       const double octree_voxel_size, 
+#                       const bool show_nb_occlusions = true,
+#                       const int max_occlusions = 4);
+# 
+#       /** \brief Colors the point cloud of a Mesh, depending on its occlusions.
+#         * \details If showNbOcclusions is set to True, each point is colored depending on the number of points occluding it.
+#         * Else, each point is given a different a 0 value is not occluded, 1 if occluded.
+#         * By default, the number of occlusions is bounded to 4.
+#         * \param[in] tex_mesh input mesh on which occlusions will be computed.
+#         * \param[out] colored_cloud resulting colored cloud showing the number of occlusions per point.
+#         * \param[in] octree_voxel_size octree resolution (in meters).
+#         * \param[in] show_nb_occlusions If false, color information will only represent.
+#         * \param[in] max_occlusions Limit the number of occlusions per point.
+#         */
+#       void
+#       showOcclusions (pcl::TextureMesh &tex_mesh, 
+#                       pcl::PointCloud<pcl::PointXYZI>::Ptr &colored_cloud,
+#                       double octree_voxel_size, 
+#                       bool show_nb_occlusions = true, 
+#                       int max_occlusions = 4);
+# 
+#       /** \brief Segment and texture faces by camera visibility. Face-based segmentation.
+#         * \details With N camera, faces will be arranged into N+1 groups: 1 for each camera, plus 1 for faces not visible from any camera.
+#         * The mesh will also contain uv coordinates for each face
+#         * \param[in/out] tex_mesh input mesh that needs sorting. Should contain only 1 sub-mesh.
+#         * \param[in] cameras vector containing the cameras used for texture mapping.
+#         */
+#       void 
+#       textureMeshwithMultipleCameras (pcl::TextureMesh &mesh, 
+#                                       const pcl::texture_mapping::CameraVector &cameras);
+# 
+#     protected:
+#       /** \brief mesh scale control. */
+#       float f_;
+# 
+#       /** \brief vector field */
+#       Eigen::Vector3f vector_field_;
+# 
+#       /** \brief list of texture files */
+#       std::vector<std::string> tex_files_;
+# 
+#       /** \brief list of texture materials */
+#       TexMaterial tex_material_;
+# 
+#       /** \brief Map texture to a face
+#         * \param[in] p1 the first point
+#         * \param[in] p2 the second point
+#         * \param[in] p3 the third point
+#         */
+#       std::vector<Eigen::Vector2f>
+#       mapTexture2Face (const Eigen::Vector3f &p1, const Eigen::Vector3f &p2, const Eigen::Vector3f &p3);
+# 
+#       /** \brief Returns the circumcenter of a triangle and the circle's radius.
+#         * \details see http://en.wikipedia.org/wiki/Circumcenter for formulas.
+#         * \param[in] p1 first point of the triangle.
+#         * \param[in] p2 second point of the triangle.
+#         * \param[in] p3 third point of the triangle.
+#         * \param[out] circumcenter resulting circumcenter
+#         * \param[out] radius the radius of the circumscribed circle.
+#         */
+#       inline void
+#       getTriangleCircumcenterAndSize (const pcl::PointXY &p1, const pcl::PointXY &p2, const pcl::PointXY &p3, pcl::PointXY &circomcenter, double &radius);
+# 
+#       /** \brief computes UV coordinates of point, observed by one particular camera
+#         * \param[in] pt XYZ point to project on camera plane
+#         * \param[in] cam the camera used for projection
+#         * \param[out] UV_coordinates the resulting UV coordinates. Set to (-1.0,-1.0) if the point is not visible by the camera
+#         * \returns false if the point is not visible by the camera
+#         */
+#       inline bool
+#       getPointUVCoordinates (const pcl::PointXYZ &pt, const Camera &cam, pcl::PointXY &UV_coordinates);
+# 
+#       /** \brief Returns true if all the vertices of one face are projected on the camera's image plane.
+#         * \param[in] camera camera on which to project the face.
+#         * \param[in] p1 first point of the face.
+#         * \param[in] p2 second point of the face.
+#         * \param[in] p3 third point of the face.
+#         * \param[out] proj1 UV coordinates corresponding to p1.
+#         * \param[out] proj2 UV coordinates corresponding to p2.
+#         * \param[out] proj3 UV coordinates corresponding to p3.
+#         */
+#       inline bool
+#       isFaceProjected (const Camera &camera, 
+#                        const pcl::PointXYZ &p1, const pcl::PointXYZ &p2, const pcl::PointXYZ &p3, 
+#                        pcl::PointXY &proj1, pcl::PointXY &proj2, pcl::PointXY &proj3);
+# 
+#       /** \brief Returns True if a point lays within a triangle
+#         * \details see http://www.blackpawn.com/texts/pointinpoly/default.html
+#         * \param[in] p1 first point of the triangle.
+#         * \param[in] p2 second point of the triangle.
+#         * \param[in] p3 third point of the triangle.
+#         * \param[in] pt the querry point.
+#         */
+#       inline bool
+#       checkPointInsideTriangle (const pcl::PointXY &p1, const pcl::PointXY &p2, const pcl::PointXY &p3, const pcl::PointXY &pt);
+# 
+#       /** \brief Class get name method. */
+#       std::string
+#       getClassName () const
+#       {
+#         return ("TextureMapping");
+#       }
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+###
+
+# vector.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/vector.h (1.7.2)
+# namespace pcl {
+# namespace poisson {
+# 
+#     template<class T>
+#     class Vector
+#     {
+#     public:
+#       Vector ();
+#       Vector (const Vector<T>& V);
+#       Vector (size_t N);
+#       Vector (size_t N, T* pV);
+#       ~Vector();
+# 
+#       const T& operator () (size_t i) const;
+#       T& operator () (size_t i);
+#       const T& operator [] (size_t i) const;
+#       T& operator [] (size_t i);
+# 
+#       void SetZero();
+# 
+#       size_t Dimensions() const;
+#       void Resize( size_t N );
+# 
+#       Vector operator * (const T& A) const;
+#       Vector operator / (const T& A) const;
+#       Vector operator - (const Vector& V) const;
+#       Vector operator + (const Vector& V) const;
+# 
+#       Vector& operator *= (const T& A);
+#       Vector& operator /= (const T& A);
+#       Vector& operator += (const Vector& V);
+#       Vector& operator -= (const Vector& V);
+# 
+#       Vector& AddScaled (const Vector& V,const T& scale);
+#       Vector& SubtractScaled (const Vector& V,const T& scale);
+#       static void Add (const Vector& V1,const T& scale1,const Vector& V2,const T& scale2,Vector& Out);
+#       static void Add (const Vector& V1,const T& scale1,const Vector& V2,Vector& Out);
+# 
+#       Vector operator - () const;
+# 
+#       Vector& operator = (const Vector& V);
+# 
+#       T Dot (const Vector& V) const;
+# 
+#       T Length() const;
+# 
+#       T Norm (size_t Ln) const;
+#       void Normalize();
+# 
+#       T* m_pV;
+#     protected:
+#       size_t m_N;
+# 
+#     };
+# 
+#     template<class T,int Dim>
+#     class NVector
+#     {
+#     public:
+#       NVector ();
+#       NVector (const NVector& V);
+#       NVector (size_t N);
+#       NVector (size_t N, T* pV);
+#       ~NVector ();
+# 
+#       const T* operator () (size_t i) const;
+#       T* operator () (size_t i);
+#       const T* operator [] (size_t i) const;
+#       T* operator [] (size_t i);
+# 
+#       void SetZero();
+# 
+#       size_t Dimensions() const;
+#       void Resize( size_t N );
+# 
+#       NVector operator * (const T& A) const;
+#       NVector operator / (const T& A) const;
+#       NVector operator - (const NVector& V) const;
+#       NVector operator + (const NVector& V) const;
+# 
+#       NVector& operator *= (const T& A);
+#       NVector& operator /= (const T& A);
+#       NVector& operator += (const NVector& V);
+#       NVector& operator -= (const NVector& V);
+# 
+#       NVector& AddScaled (const NVector& V,const T& scale);
+#       NVector& SubtractScaled (const NVector& V,const T& scale);
+#       static void Add (const NVector& V1,const T& scale1,const NVector& V2,const T& scale2,NVector& Out);
+#       static void Add (const NVector& V1,const T& scale1,const NVector& V2, NVector& Out);
+# 
+#       NVector operator - () const;
+# 
+#       NVector& operator = (const NVector& V);
+# 
+#       T Dot (const NVector& V) const;
+# 
+#       T Length () const;
+# 
+#       T Norm (size_t Ln) const;
+#       void Normalize ();
+# 
+#       T* m_pV;
+#     protected:
+#       size_t m_N;
+# 
+#     };
+# 
+#   }
+# }
+###
+
+# vtk.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_smoothing.h (1.7.2)
+# #include <vtkPolyData.h>
+# #include <vtkSmartPointer.h>
+###
+
+# pcl\surface\vtk_smoothing\vtk_mesh_quadric_decimation.h (1.7.2)
+
+# vtk_mesh_smoothing_laplacian.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_smoothing_laplacian.h (1.7.2)
+# namespace pcl
+# {
+#   /** \brief PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library.
+#     * Please check out the original documentation for more details on the inner workings of the algorithm
+#     * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#     * data structure to the vtkPolyData data structure and back.
+#     */
+#   class PCL_EXPORTS MeshSmoothingLaplacianVTK : public MeshProcessing
+#   {
+#     public:
+#       /** \brief Empty constructor that sets the values of the algorithm parameters to the VTK defaults */
+#       MeshSmoothingLaplacianVTK ()
+#         : MeshProcessing ()
+#         , vtk_polygons_ ()
+#         , num_iter_ (20)
+#         , convergence_ (0.0f)
+#         , relaxation_factor_ (0.01f)
+#         , feature_edge_smoothing_ (false)
+#         , feature_angle_ (45.f)
+#         , edge_angle_ (15.f)
+#         , boundary_smoothing_ (true)
+#       {};
+# 
+#       /** \brief Set the number of iterations for the smoothing filter.
+#         * \param[in] num_iter the number of iterations
+#         */
+#       inline void
+#       setNumIter (int num_iter)
+#       {
+#         num_iter_ = num_iter;
+#       };
+# 
+#       /** \brief Get the number of iterations. */
+#       inline int
+#       getNumIter ()
+#       {
+#         return num_iter_;
+#       };
+# 
+#       /** \brief Specify a convergence criterion for the iteration process. Smaller numbers result in more smoothing iterations.
+#        * \param[in] convergence convergence criterion for the Laplacian smoothing
+#        */
+#       inline void
+#       setConvergence (float convergence)
+#       {
+#         convergence_ = convergence;
+#       };
+# 
+#       /** \brief Get the convergence criterion. */
+#       inline float
+#       getConvergence ()
+#       {
+#         return convergence_;
+#       };
+# 
+#       /** \brief Specify the relaxation factor for Laplacian smoothing. As in all iterative methods,
+#        * the stability of the process is sensitive to this parameter.
+#        * In general, small relaxation factors and large numbers of iterations are more stable than larger relaxation
+#        * factors and smaller numbers of iterations.
+#        * \param[in] relaxation_factor the relaxation factor of the Laplacian smoothing algorithm
+#        */
+#       inline void
+#       setRelaxationFactor (float relaxation_factor)
+#       {
+#         relaxation_factor_ = relaxation_factor;
+#       };
+# 
+#       /** \brief Get the relaxation factor of the Laplacian smoothing */
+#       inline float
+#       getRelaxationFactor ()
+#       {
+#         return relaxation_factor_;
+#       };
+# 
+#       /** \brief Turn on/off smoothing along sharp interior edges.
+#        * \param[in] status decision whether to enable/disable smoothing along sharp interior edges
+#        */
+#       inline void
+#       setFeatureEdgeSmoothing (bool feature_edge_smoothing)
+#       {
+#         feature_edge_smoothing_ = feature_edge_smoothing;
+#       };
+# 
+#       /** \brief Get the status of the feature edge smoothing */
+#       inline bool
+#       getFeatureEdgeSmoothing ()
+#       {
+#         return feature_edge_smoothing_;
+#       };
+# 
+#       /** \brief Specify the feature angle for sharp edge identification.
+#        * \param[in] feature_angle the angle threshold for considering an edge to be sharp
+#        */
+#       inline void
+#       setFeatureAngle (float feature_angle)
+#       {
+#         feature_angle_ = feature_angle;
+#       };
+# 
+#       /** \brief Get the angle threshold for considering an edge to be sharp */
+#       inline float
+#       getFeatureAngle ()
+#       {
+#         return feature_angle_;
+#       };
+# 
+#       /** \brief Specify the edge angle to control smoothing along edges (either interior or boundary).
+#        * \param[in] edge_angle the angle to control smoothing along edges
+#        */
+#       inline void
+#       setEdgeAngle (float edge_angle)
+#       {
+#         edge_angle_ = edge_angle;
+#       };
+# 
+#       /** \brief Get the edge angle to control smoothing along edges */
+#       inline float
+#       getEdgeAngle ()
+#       {
+#         return edge_angle_;
+#       };
+# 
+#       /** \brief Turn on/off the smoothing of vertices on the boundary of the mesh.
+#        * \param[in] boundary_smoothing decision whether boundary smoothing is on or off
+#        */
+#       inline void
+#       setBoundarySmoothing (bool boundary_smoothing)
+#       {
+#         boundary_smoothing_ = boundary_smoothing;
+#       };
+# 
+#       /** \brief Get the status of the boundary smoothing */
+#       inline bool
+#       getBoundarySmoothing ()
+#       {
+#         return boundary_smoothing_;
+#       }
+# 
+#     protected:
+#       void
+#       performProcessing (pcl::PolygonMesh &output);
+# 
+#     private:
+#       vtkSmartPointer<vtkPolyData> vtk_polygons_;
+# 
+#       /// Parameters
+#       int num_iter_;
+#       float convergence_;
+#       float relaxation_factor_;
+#       bool feature_edge_smoothing_;
+#       float feature_angle_;
+#       float edge_angle_;
+#       bool boundary_smoothing_;
+#   };
+###
+
+# vtk_mesh_smoothing_windowed_sinc.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_smoothing_windowed_sinc.h (1.7.2)
+# namespace pcl
+# /** \brief PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library.
+#   * Please check out the original documentation for more details on the inner workings of the algorithm
+#   * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#   * data structure to the vtkPolyData data structure and back.
+#   */
+# class PCL_EXPORTS MeshSmoothingWindowedSincVTK : public MeshProcessing
+#       public:
+#       /** \brief Empty constructor that sets the values of the algorithm parameters to the VTK defaults */
+#       MeshSmoothingWindowedSincVTK ()
+#         : MeshProcessing (),
+#           num_iter_ (20),
+#           pass_band_ (0.1f),
+#           feature_edge_smoothing_ (false),
+#           feature_angle_ (45.f),
+#           edge_angle_ (15.f),
+#           boundary_smoothing_ (true),
+#           normalize_coordinates_ (false)
+#       {};
+# 
+#       /** \brief Set the number of iterations for the smoothing filter.
+#         * \param[in] num_iter the number of iterations
+#       inline void setNumIter (int num_iter)
+#       /** \brief Get the number of iterations. */
+#       inline int getNumIter ()
+#       /** \brief Set the pass band value for windowed sinc filtering.
+#         * \param[in] pass_band value for the pass band.
+#       inline void setPassBand (float pass_band)
+#       /** \brief Get the pass band value. */
+#       inline float getPassBand ()
+#       /** \brief Turn on/off coordinate normalization. The positions can be translated and scaled such that they fit
+#        * within a [-1, 1] prior to the smoothing computation. The default is off. The numerical stability of the
+#        * solution can be improved by turning normalization on. If normalization is on, the coordinates will be rescaled
+#        * to the original coordinate system after smoothing has completed.
+#        * \param[in] normalize_coordinates decision whether to normalize coordinates or not
+#       inline void setNormalizeCoordinates (bool normalize_coordinates)
+#       /** \brief Get whether the coordinate normalization is active or not */
+#       inline bool getNormalizeCoordinates ()
+#       /** \brief Turn on/off smoothing along sharp interior edges.
+#        * \param[in] status decision whether to enable/disable smoothing along sharp interior edges
+#       inline void setFeatureEdgeSmoothing (bool feature_edge_smoothing)
+#       /** \brief Get the status of the feature edge smoothing */
+#       inline bool getFeatureEdgeSmoothing ()
+#       /** \brief Specify the feature angle for sharp edge identification.
+#        * \param[in] feature_angle the angle threshold for considering an edge to be sharp
+#       inline void setFeatureAngle (float feature_angle)
+#       /** \brief Get the angle threshold for considering an edge to be sharp */
+#       inline float getFeatureAngle ()
+#       /** \brief Specify the edge angle to control smoothing along edges (either interior or boundary).
+#        * \param[in] edge_angle the angle to control smoothing along edges
+#       inline void setEdgeAngle (float edge_angle)
+#       /** \brief Get the edge angle to control smoothing along edges */
+#       inline float getEdgeAngle ()
+#       /** \brief Turn on/off the smoothing of vertices on the boundary of the mesh.
+#        * \param[in] boundary_smoothing decision whether boundary smoothing is on or off
+#       inline void setBoundarySmoothing (bool boundary_smoothing)
+#       /** \brief Get the status of the boundary smoothing */
+#       inline bool getBoundarySmoothing ()
+#       protected:
+#       void performProcessing (pcl::PolygonMesh &output);
+###
+
+# vtk_mesh_subdivision.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_subdivision.h (1.7.2)
+# namespace pcl
+# /** \brief PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter
+#   * depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library.
+#   * Please check out the original documentation for more details on the inner workings of the algorithm
+#   * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#   * data structure to the vtkPolyData data structure and back.
+#   */
+# class PCL_EXPORTS MeshSubdivisionVTK : public MeshProcessing
+#       public:
+#       /** \brief Empty constructor */
+#       MeshSubdivisionVTK ();
+#       enum MeshSubdivisionVTKFilterType
+#       { LINEAR, LOOP, BUTTERFLY };
+#       /** \brief Set the mesh subdivision filter type
+#         * \param[in] type the filter type
+#       inline void setFilterType (MeshSubdivisionVTKFilterType type)
+#       /** \brief Get the mesh subdivision filter type */
+#       inline MeshSubdivisionVTKFilterType getFilterType ()
+#       protected:
+#       void performProcessing (pcl::PolygonMesh &output);
+###
+
+# vtk_utils.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_utils.h (1.7.2)
+# namespace pcl
+# class PCL_EXPORTS VTKUtils
+#       public:
+#       /** \brief Convert a PCL PolygonMesh to a VTK vtkPolyData.
+#         * \param[in] triangles PolygonMesh to be converted to vtkPolyData, stored in the object.
+#         */
+#       static int
+#       convertToVTK (const pcl::PolygonMesh &triangles, vtkSmartPointer<vtkPolyData> &triangles_out_vtk);
+#       /** \brief Convert the vtkPolyData object back to PolygonMesh.
+#         * \param[out] triangles the PolygonMesh to store the vtkPolyData in.
+#         */
+#       static void
+#       convertToPCL (vtkSmartPointer<vtkPolyData> &vtk_polygons, pcl::PolygonMesh &triangles);
+#       /** \brief Convert vtkPolyData object to a PCL PolygonMesh
+#         * \param[in] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#         * \param[out] mesh PCL Polygon Mesh to fill
+#         * \return Number of points in the point cloud of mesh.
+#         */
+#       static int
+#       vtk2mesh (const vtkSmartPointer<vtkPolyData>& poly_data, pcl::PolygonMesh& mesh);
+#       /** \brief Convert a PCL PolygonMesh to a vtkPolyData object
+#         * \param[in] mesh Reference to PCL Polygon Mesh
+#         * \param[out] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#         * \return Number of points in the point cloud of mesh.
+#         */
+#       static int
+#       mesh2vtk (const pcl::PolygonMesh& mesh, vtkSmartPointer<vtkPolyData> &poly_data);
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
diff --git a/pcl/pcl_surface_180.pxd b/pcl/pcl_surface_180.pxd
new file mode 100644
index 0000000..41a2021
--- /dev/null
+++ b/pcl/pcl_surface_180.pxd
@@ -0,0 +1,5132 @@
+# -*- coding: utf-8 -*-
+
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_kdtree as pclkdt
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# reconstruction.h
+# namespace pcl
+# brief Pure abstract class. All types of meshing/reconstruction
+# algorithms in \b libpcl_surface must inherit from this, in order to make
+# sure we have a consistent API. The methods that we care about here are:
+#  - \b setSearchMethod(&SearchPtr): passes a search locator
+#  - \b reconstruct(&PolygonMesh): creates a PolygonMesh object from the input data
+# author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+# 
+# template <typename PointInT>
+# class PCLSurfaceBase: public PCLBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass PCLSurfaceBase[In](cpp.PCLBase[In]):
+        PCLSurfaceBase()
+        
+        # brief Provide an optional pointer to a search object.
+        # param[in] tree a pointer to the spatial search object.
+        # inline void setSearchMethod (const KdTreePtr &tree)
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        
+        # brief Get a pointer to the search method used.
+        # inline KdTreePtr getSearchMethod ()
+        pclkdt.KdTreePtr_t getSearchMethod ()
+
+#       /** \brief Base method for surface reconstruction for all points given in
+#         * <setInputCloud (), setIndices ()> 
+#         * \param[out] output the resultant reconstructed surface model
+#       virtual void reconstruct (pcl::PolygonMesh &output) = 0;
+
+#       protected:
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+#       /** \brief Abstract class get name method. */
+#       virtual std::string getClassName () const { return (""); }
+###
+
+# /** \brief SurfaceReconstruction represents a base surface reconstruction
+#   * class. All \b surface reconstruction methods take in a point cloud and
+#   * generate a new surface from it, by either re-sampling the data or
+#   * generating new data altogether. These methods are thus \b not preserving
+#   * the topology of the original data.
+#   * \note Reconstruction methods that always preserve the original input
+#   * point cloud data as the surface vertices and simply construct the mesh on
+#   * top should inherit from \ref MeshConstruction.
+#   * \author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+#   * \ingroup surface
+#   */
+# template <typename PointInT>
+# class SurfaceReconstruction: public PCLSurfaceBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass SurfaceReconstruction[In](PCLSurfaceBase[In]):
+        SurfaceReconstruction()
+#       public:
+#       using PCLSurfaceBase<PointInT>::input_;
+#       using PCLSurfaceBase<PointInT>::indices_;
+#       using PCLSurfaceBase<PointInT>::initCompute;
+#       using PCLSurfaceBase<PointInT>::deinitCompute;
+#       using PCLSurfaceBase<PointInT>::tree_;
+#       using PCLSurfaceBase<PointInT>::getClassName;
+#       
+#       /** \brief Base method for surface reconstruction for all points given in
+#        * <setInputCloud (), setIndices ()> 
+#        * \param[out] output the resultant reconstructed surface model
+#        */
+#       virtual void reconstruct (pcl::PolygonMesh &output);
+#       /** \brief Base method for surface reconstruction for all points given in
+#         * <setInputCloud (), setIndices ()> 
+#         * \param[out] points the resultant points lying on the new surface
+#         * \param[out] polygons the resultant polygons, as a set of
+#         * vertices. The Vertices structure contains an array of point indices.
+#         */
+#       virtual void 
+#       reconstruct (pcl::PointCloud<PointInT> &points,
+#                    std::vector<pcl::Vertices> &polygons);
+#       protected:
+#       /** \brief A flag specifying whether or not the derived reconstruction
+#         * algorithm needs the search object \a tree.*/
+#       bool check_tree_;
+#       /** \brief Abstract surface reconstruction method. 
+#         * \param[out] output the output polygonal mesh 
+#         */
+#       virtual void performReconstruction (pcl::PolygonMesh &output) = 0;
+#       /** \brief Abstract surface reconstruction method. 
+#         * \param[out] points the resultant points lying on the surface
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       virtual void 
+#       performReconstruction (pcl::PointCloud<PointInT> &points, 
+#                              std::vector<pcl::Vertices> &polygons) = 0;
+###
+
+# brief MeshConstruction represents a base surface reconstruction
+# class. All \b mesh constructing methods that take in a point cloud and
+# generate a surface that uses the original data as vertices should inherit
+# from this class.
+# 
+# note Reconstruction methods that generate a new surface or create new
+# vertices in locations different than the input data should inherit from
+# \ref SurfaceReconstruction.
+# 
+# author Radu B. Rusu, Michael Dixon, Alexandru E. Ichim
+# \ingroup surface
+# 
+# template <typename PointInT>
+# class MeshConstruction: public PCLSurfaceBase<PointInT>
+cdef extern from "pcl/surface/reconstruction.h" namespace "pcl":
+    cdef cppclass MeshConstruction[In](PCLSurfaceBase[In]):
+        MeshConstruction()
+        # public:
+        # using PCLSurfaceBase<PointInT>::input_;
+        # using PCLSurfaceBase<PointInT>::indices_;
+        # using PCLSurfaceBase<PointInT>::initCompute;
+        # using PCLSurfaceBase<PointInT>::deinitCompute;
+        # using PCLSurfaceBase<PointInT>::tree_;
+        # using PCLSurfaceBase<PointInT>::getClassName;
+        
+        # brief Base method for surface reconstruction for all points given in <setInputCloud (), setIndices ()> 
+        # param[out] output the resultant reconstructed surface model
+        # 
+        # note This method copies the input point cloud data from
+        # PointCloud<T> to PointCloud2, and is implemented here for backwards
+        # compatibility only!
+        # 
+        # virtual void reconstruct (pcl::PolygonMesh &output);
+        # brief Base method for mesh construction for all points given in <setInputCloud (), setIndices ()> 
+        # param[out] polygons the resultant polygons, as a set of vertices.
+        # The Vertices structure contains an array of point indices.
+        # 
+        # virtual void reconstruct (std::vector<pcl::Vertices> &polygons);
+        # 
+        # protected:
+        # /** \brief A flag specifying whether or not the derived reconstruction
+        #   * algorithm needs the search object \a tree.*/
+        # bool check_tree_;
+        # /** \brief Abstract surface reconstruction method. 
+        #   * \param[out] output the output polygonal mesh 
+        #   */
+        # virtual void performReconstruction (pcl::PolygonMesh &output) = 0;
+        # /** \brief Abstract surface reconstruction method. 
+        #   * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+        #   */
+        # virtual void performReconstruction (std::vector<pcl::Vertices> &polygons) = 0;
+###
+
+# processing.h
+# namespace pcl
+# brief @b CloudSurfaceProcessing represents the base class for algorithms that take a point cloud as an input and
+# produce a new output cloud that has been modified towards a better surface representation. These types of
+# algorithms include surface smoothing, hole filling, cloud upsampling etc.
+# author Alexandru E. Ichim
+# ingroup surface
+# 
+# template <typename PointInT, typename PointOutT>
+# class CloudSurfaceProcessing : public PCLBase<PointInT>
+cdef extern from "pcl/surface/processing.h" namespace "pcl":
+    cdef cppclass CloudSurfaceProcessing[In, Out](cpp.PCLBase[In]):
+        CloudSurfaceProcessing()
+#       public:
+#       using PCLBase<PointInT>::input_;
+#       using PCLBase<PointInT>::indices_;
+#       using PCLBase<PointInT>::initCompute;
+#       using PCLBase<PointInT>::deinitCompute;
+#       public:
+#       /** \brief Process the input cloud and store the results
+#         * \param[out] output the cloud where the results will be stored
+#       virtual void process (pcl::PointCloud<PointOutT> &output);
+#       protected:
+#       /** \brief Abstract cloud processing method */
+#       virtual void performProcessing (pcl::PointCloud<PointOutT> &output) = 0;
+### 
+
+# /** \brief @b MeshProcessing represents the base class for mesh processing algorithms.
+#   * \author Alexandru E. Ichim
+#   * \ingroup surface
+#   */
+# class PCL_EXPORTS MeshProcessing
+#       public:
+#       typedef PolygonMesh::ConstPtr PolygonMeshConstPtr;
+#       /** \brief Constructor. */
+#       MeshProcessing () : input_mesh_ () {};
+#       /** \brief Destructor. */
+#       virtual ~MeshProcessing () {}
+#       /** \brief Set the input mesh that we want to process
+#         * \param[in] input the input polygonal mesh
+#       void setInputMesh (const pcl::PolygonMeshConstPtr &input) 
+#       /** \brief Process the input surface mesh and store the results
+#         * \param[out] output the resultant processed surface model
+#       void process (pcl::PolygonMesh &output);
+#       protected:
+#       /** \brief Initialize computation. Must be called before processing starts. */
+#       virtual bool initCompute ();
+#       /** \brief UnInitialize computation. Must be called after processing ends. */
+#       virtual void deinitCompute ();
+#       /** \brief Abstract surface processing method. */
+#       virtual void performProcessing (pcl::PolygonMesh &output) = 0;
+#       /** \brief Abstract class get name method. */
+#       virtual std::string getClassName () const { return (""); }
+#       /** \brief Input polygonal mesh. */
+#       pcl::PolygonMeshConstPtr input_mesh_;
+###
+
+
+# (1.6.0)allocator.h
+# (1.7.2) -> pcl/surface/3rdparty/poisson4
+# namespace pcl 
+# namespace poisson 
+# class AllocatorState
+# cdef extern from "pcl/surface/3rdparty/poisson4/allocator.h" namespace "pcl::poisson":
+#     cdef cppclass AllocatorState:
+#         AllocatorState()
+#         # public:
+#         # int index,remains;
+
+
+# (1.6.0) -> allocator.h
+# (1.7.2) -> pcl\surface\3rdparty\poisson4 ?
+# template<class T>
+# class Allocator
+# cdef extern from "pcl/surface/3rdparty/poisson4/allocator.h" namespace "pcl::poisson":
+#     cdef cppclass Allocator[T]:
+#         Allocator()
+        # int blockSize;
+        # int index, remains;
+        # std::vector<T*> memory;
+        # public:
+        # /** This method is the allocators destructor. It frees up any of the memory that
+        #   * it has allocated. 
+        # void reset ()
+        # /** This method returns the memory state of the allocator. */
+        # AllocatorState getState () const
+        # /** This method rolls back the allocator so that it makes all of the memory previously
+        #   * allocated available for re-allocation. Note that it does it not call the constructor
+        #   * again, so after this method has been called, assumptions about the state of the values
+        #   * in memory are no longer valid. 
+        # void rollBack ()
+        # /** This method rolls back the allocator to the previous memory state and makes all of the memory previously
+        #   * allocated available for re-allocation. Note that it does it not call the constructor
+        #   * again, so after this method has been called, assumptions about the state of the values
+        #   * in memory are no longer valid. 
+        # void rollBack (const AllocatorState& state)
+        # /** This method initiallizes the constructor and the blockSize variable specifies the
+        #   * the number of objects that should be pre-allocated at a time. 
+        # void set (const int& blockSize)
+        # /** This method returns a pointer to an array of elements objects. If there is left over pre-allocated
+        #   * memory, this method simply returns a pointer to the next free piece of memory, otherwise it pre-allocates
+        #   * more memory. Note that if the number of objects requested is larger than the value blockSize with which
+        #   * the allocator was initialized, the request for memory will fail.
+        # T* newElements (const int& elements = 1)
+###
+
+# bilateral_upsampling.h
+# namespace pcl
+# /** \brief Bilateral filtering implementation, based on the following paper:
+#   *   * Kopf, Johannes and Cohen, Michael F. and Lischinski, Dani and Uyttendaele, Matt - Joint Bilateral Upsampling,
+#   *   * ACM Transations in Graphics, July 2007
+#   * Takes in a colored organized point cloud (i.e. PointXYZRGB or PointXYZRGBA), that might contain nan values for the
+#   * depth information, and it will returned an upsampled version of this cloud, based on the formula:
+#   * \f[
+#   *    \tilde{S}_p = \frac{1}{k_p} \sum_{q_d \in \Omega} {S_{q_d} f(||p_d - q_d|| g(||\tilde{I}_p-\tilde{I}_q||})
+#   * \f]
+#   * where S is the depth image, I is the RGB image and f and g are Gaussian functions centered at 0 and with
+#   * standard deviations \f$\sigma_{color}\f$ and \f$\sigma_{depth}\f$
+#   */
+# template <typename PointInT, typename PointOutT>
+# class BilateralUpsampling: public CloudSurfaceProcessing<PointInT, PointOutT>
+cdef extern from "pcl/surface/bilateral_upsampling.h" namespace "pcl":
+    cdef cppclass BilateralUpsampling[In, Out](CloudSurfaceProcessing[In, Out]):
+        BilateralUpsampling()
+        # public:
+        # using PCLBase<PointInT>::input_;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::initCompute;
+        # using PCLBase<PointInT>::deinitCompute;
+        # using CloudSurfaceProcessing<PointInT, PointOutT>::process;
+        # typedef pcl::PointCloud<PointOutT> PointCloudOut;
+        # Eigen::Matrix3f KinectVGAProjectionMatrix, KinectSXGAProjectionMatrix;
+        # /** \brief Method that sets the window size for the filter
+        #   * \param[in] window_size the given window size
+        # inline void setWindowSize (int window_size)
+        # /** \brief Returns the filter window size */
+        # inline int getWindowSize () const
+        # /** \brief Method that sets the sigma color parameter
+        #   * \param[in] sigma_color the new value to be set
+        # inline void setSigmaColor (const float &sigma_color)
+        # /** \brief Returns the current sigma color value */
+        # inline float getSigmaColor () const
+        # /** \brief Method that sets the sigma depth parameter
+        #   * \param[in] sigma_depth the new value to be set
+        # inline void setSigmaDepth (const float &sigma_depth)
+        # /** \brief Returns the current sigma depth value */
+        # inline float getSigmaDepth () const
+        # /** \brief Method that sets the projection matrix to be used when unprojecting the points in the depth image
+        #   * back to (x,y,z) positions.
+        #   * \note There are 2 matrices already set in the class, used for the 2 modes available for the Kinect. They
+        #   * are tuned to be the same as the ones in the OpenNiGrabber
+        #   * \param[in] projection_matrix the new projection matrix to be set */
+        # inline void setProjectionMatrix (const Eigen::Matrix3f &projection_matrix)
+        # /** \brief Returns the current projection matrix */
+        # inline Eigen::Matrix3f getProjectionMatrix () const
+        # /** \brief Method that does the actual processing on the input cloud.
+        #   * \param[out] output the container of the resulting upsampled cloud */
+        # void process (pcl::PointCloud<PointOutT> &output)
+        # protected:
+        # void performProcessing (pcl::PointCloud<PointOutT> &output);
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+
+# binary_node.h (1.6.0)
+# pcl/surface/3rdparty\poisson4\binary_node.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# template<class Real>
+# class BinaryNode
+# cdef extern from "pcl/surface/3rdparty/poisson4/binary_node.h" namespace "pcl::poisson":
+#    cdef cppclass BinaryNode[Real]:
+#        BinaryNode()
+        # public:
+        # static inline int CenterCount (int depth){return 1<<depth;}
+        # static inline int CumulativeCenterCount (int maxDepth){return  (1<< (maxDepth+1))-1;}
+        # static inline int Index (int depth,  int offSet){return  (1<<depth)+offSet-1;}
+        # static inline int CornerIndex (int maxDepth, int depth, int offSet, int forwardCorner)
+        # static inline Real CornerIndexPosition (int index, int maxDepth)
+        # static inline Real Width (int depth)
+        # 
+        # // Fix for Bug #717 with Visual Studio that generates wrong code for this function
+        # // when global optimization is enabled (release mode).
+        # #ifdef _MSC_VER
+        #   static __declspec(noinline) void CenterAndWidth (int depth, int offset, Real& center, Real& width)
+        # #else
+        # static inline void CenterAndWidth (int depth, int offset, Real& center, Real& width)
+        # # #endif
+        # 
+        # #ifdef _MSC_VER
+        # static __declspec(noinline) void CenterAndWidth (int idx, Real& center, Real& width)
+        # #else
+        # static inline void CenterAndWidth (int idx, Real& center, Real& width)
+        # #endif
+        # static inline void DepthAndOffset (int idx,  int& depth, int& offset)
+###
+
+# concave_hull.h
+# namespace pcl
+# template<typename PointInT>
+# class ConcaveHull : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/concave_hull.h" namespace "pcl":
+    cdef cppclass ConcaveHull[In](MeshConstruction[In]):
+        ConcaveHull()
+        # public:
+        # \brief Compute a concave hull for all points given 
+        # \param points the resultant points lying on the concave hull 
+        # \param polygons the resultant concave hull polygons, as a set of
+        # vertices. The Vertices structure contains an array of point indices.
+        # void reconstruct (PointCloud &points, std::vector<pcl::Vertices> &polygons);
+        
+        # /** \brief Compute a concave hull for all points given 
+        #  * \param output the resultant concave hull vertices
+        # void reconstruct (PointCloud &output);
+        void reconstruct (cpp.PointCloud_t output)
+        void reconstruct (cpp.PointCloud_PointXYZI_t output)
+        void reconstruct (cpp.PointCloud_PointXYZRGB_t output)
+        void reconstruct (cpp.PointCloud_PointXYZRGBA_t output)
+        
+        # /** \brief Set the alpha value, which limits the size of the resultant
+        #   * hull segments (the smaller the more detailed the hull).  
+        #   * \param alpha positive, non-zero value, defining the maximum length
+        #   * from a vertex to the facet center (center of the voronoi cell).
+        # inline void setAlpha (double alpha)
+        void setAlpha (double alpha)
+        # Returns the alpha parameter, see setAlpha().
+        # inline double getAlpha ()
+        double getAlpha ()
+        
+        # If set, the voronoi cells center will be saved in _voronoi_centers_
+        # voronoi_centers
+        # inline void setVoronoiCenters (PointCloudPtr voronoi_centers)
+        
+        # \brief If keep_information_is set to true the convex hull
+        # points keep other information like rgb, normals, ...
+        # \param value where to keep the information or not, default is false
+        # void setKeepInformation (bool value)
+        
+        # brief Returns the dimensionality (2 or 3) of the calculated hull.
+        # inline int getDim () const
+        # brief Returns the dimensionality (2 or 3) of the calculated hull.
+        # inline int getDimension () const
+        # brief Sets the dimension on the input data, 2D or 3D.
+        # param[in] dimension The dimension of the input data.  If not set, this will be determined automatically.
+        # void setDimension (int dimension)
+        
+        # protected:
+        # /** \brief The actual reconstruction method.
+        #   * \param points the resultant points lying on the concave hull 
+        #   * \param polygons the resultant concave hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   */
+        # void performReconstruction (PointCloud &points, 
+        #                        std::vector<pcl::Vertices> &polygons);
+        # virtual void performReconstruction (PolygonMesh &output);
+        # virtual void performReconstruction (std::vector<pcl::Vertices> &polygons);
+        # /** \brief The method accepts facets only if the distance from any vertex to the facet->center 
+        #   * (center of the voronoi cell) is smaller than alpha 
+        # double alpha_;
+        # /** \brief If set to true, the reconstructed point cloud describing the hull is obtained from 
+        #   * the original input cloud by performing a nearest neighbor search from Qhull output. 
+        # bool keep_information_;
+        # /** \brief the centers of the voronoi cells */
+        # PointCloudPtr voronoi_centers_;
+        # /** \brief the dimensionality of the concave hull */
+        # int dim_;
+        
+
+
+ctypedef ConcaveHull[cpp.PointXYZ] ConcaveHull_t
+ctypedef ConcaveHull[cpp.PointXYZI] ConcaveHull_PointXYZI_t
+ctypedef ConcaveHull[cpp.PointXYZRGB] ConcaveHull_PointXYZRGB_t
+ctypedef ConcaveHull[cpp.PointXYZRGBA] ConcaveHull_PointXYZRGBA_t
+
+###
+
+# convex_hull.h
+# namespace pcl
+# /** \brief Sort 2D points in a vector structure
+#   * \param p1 the first point
+#   * \param p2 the second point
+#   * \ingroup surface
+#   */
+# inline bool
+# comparePoints2D (const std::pair<int, Eigen::Vector4f> & p1, const std::pair<int, Eigen::Vector4f> & p2)
+# 
+# template<typename PointInT>
+# class ConvexHull : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/convex_hull.h" namespace "pcl":
+    cdef cppclass ConvexHull[In](MeshConstruction[In]):
+        ConvexHull()
+        # protected:
+        # using PCLBase<PointInT>::input_;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::initCompute;
+        # using PCLBase<PointInT>::deinitCompute;
+        # public:
+        # using MeshConstruction<PointInT>::reconstruct;
+        # typedef pcl::PointCloud<PointInT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # 
+        # /** \brief Compute a convex hull for all points given 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        # void reconstruct (PointCloud &points, 
+        #              std::vector<pcl::Vertices> &polygons);
+        # /** \brief Compute a convex hull for all points given 
+        #   * \param[out] output the resultant convex hull vertices
+        # void reconstruct (PointCloud &output);
+        # /** \brief If set to true, the qhull library is called to compute the total area and volume of the convex hull.
+        #   * NOTE: When this option is activated, the qhull library produces output to the console.
+        #   * \param[in] value wheter to compute the area and the volume, default is false
+        # void setComputeAreaVolume (bool value)
+        # /** \brief Returns the total area of the convex hull. */
+        # double getTotalArea () const
+        # /** \brief Returns the total volume of the convex hull. Only valid for 3-dimensional sets.
+        #   *  For 2D-sets volume is zero. 
+        # double getTotalVolume () const
+        # /** \brief Sets the dimension on the input data, 2D or 3D.
+        #   * \param[in] dimension The dimension of the input data.  If not set, this will be determined automatically.
+        # void setDimension (int dimension)
+        # /** \brief Returns the dimensionality (2 or 3) of the calculated hull. */
+        # inline int getDimension () const
+        # 
+        # protected:
+        # /** \brief The actual reconstruction method. 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   * \param[in] fill_polygon_data true if polygons should be filled, false otherwise
+        #   */
+        # void
+        # performReconstruction (PointCloud &points, 
+        #                        std::vector<pcl::Vertices> &polygons, 
+        #                        bool fill_polygon_data = false);
+        # /** \brief The reconstruction method for 2D data.  Does not require dimension to be set. 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   * \param[in] fill_polygon_data true if polygons should be filled, false otherwise
+        # void
+        # performReconstruction2D (PointCloud &points, 
+        #                          std::vector<pcl::Vertices> &polygons, 
+        #                          bool fill_polygon_data = false);
+        # /** \brief The reconstruction method for 3D data.  Does not require dimension to be set. 
+        #   * \param[out] points the resultant points lying on the convex hull 
+        #   * \param[out] polygons the resultant convex hull polygons, as a set of
+        #   * vertices. The Vertices structure contains an array of point indices.
+        #   * \param[in] fill_polygon_data true if polygons should be filled, false otherwise
+        # void
+        # performReconstruction3D (PointCloud &points, 
+        #                          std::vector<pcl::Vertices> &polygons, 
+        #                          bool fill_polygon_data = false);
+        # /** \brief A reconstruction method that returns a polygonmesh.
+        #   *
+        #   * \param[out] output a PolygonMesh representing the convex hull of the input data.
+        #   */
+        # virtual void
+        # performReconstruction (PolygonMesh &output);
+        # 
+        # /** \brief A reconstruction method that returns the polygon of the convex hull.
+        #   *
+        #   * \param[out] polygons the polygon(s) representing the convex hull of the input data.
+        #   */
+        # virtual void
+        # performReconstruction (std::vector<pcl::Vertices> &polygons);
+        # 
+        # /** \brief Automatically determines the dimension of input data - 2D or 3D. */
+        # void 
+        # calculateInputDimension ();
+        # 
+        # /** \brief Class get name method. */
+        # std::string getClassName () const
+        # 
+        # /* \brief True if we should compute the area and volume of the convex hull. */
+        # bool compute_area_;
+        # /* \brief The area of the convex hull. */
+        # double total_area_;
+        # /* \brief The volume of the convex hull (only for 3D hulls, zero for 2D). */
+        # double total_volume_;
+        # /** \brief The dimensionality of the concave hull (2D or 3D). */
+        # int dimension_;
+        # /** \brief How close can a 2D plane's normal be to an axis to make projection problematic. */
+        # double projection_angle_thresh_;
+        # /** \brief Option flag string to be used calling qhull. */
+        # std::string qhull_flags;
+        # /* \brief x-axis - for checking valid projections. */
+        # const Eigen::Vector3f x_axis_;
+        # /* \brief y-axis - for checking valid projections. */
+        # const Eigen::Vector3f y_axis_;
+        # /* \brief z-axis - for checking valid projections. */
+        # const Eigen::Vector3f z_axis_;
+        # public:
+        # EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+###
+
+# ear_clipping.h
+# namespace pcl
+# /** \brief The ear clipping triangulation algorithm.
+#   * The code is inspired by Flavien Brebion implementation, which is
+#   * in n^3 and does not handle holes.
+#   * \author Nicolas Burrus
+#   * \ingroup surface
+# class PCL_EXPORTS EarClipping : public MeshProcessing
+#       public:
+#       using MeshProcessing::input_mesh_;
+#       using MeshProcessing::initCompute;
+#       /** \brief Empty constructor */
+#       EarClipping () : MeshProcessing (), points_ ()
+#       { 
+#       };
+# 
+#       protected:
+#       /** \brief a Pointer to the point cloud data. */
+#       pcl::PointCloud<pcl::PointXYZ>::Ptr points_;
+# 
+#       /** \brief This method should get called before starting the actual computation. */
+#       bool initCompute ();
+#       /** \brief The actual surface reconstruction method. 
+#         * \param[out] output the output polygonal mesh 
+#         */
+#       void performProcessing (pcl::PolygonMesh &output);
+# 
+#       /** \brief Triangulate one polygon. 
+#         * \param[in] vertices the set of vertices
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void triangulate (const Vertices& vertices, PolygonMesh& output);
+# 
+#       /** \brief Compute the signed area of a polygon. 
+#         * \param[in] vertices the vertices representing the polygon 
+#         */
+#       float area (const std::vector<uint32_t>& vertices);
+# 
+#       /** \brief Check if the triangle (u,v,w) is an ear. 
+#         * \param[in] u the first triangle vertex 
+#         * \param[in] v the second triangle vertex 
+#         * \param[in] w the third triangle vertex 
+#         * \param[in] vertices a set of input vertices
+#         */
+#       bool isEar (int u, int v, int w, const std::vector<uint32_t>& vertices);
+# 
+#       /** \brief Check if p is inside the triangle (u,v,w). 
+#         * \param[in] u the first triangle vertex 
+#         * \param[in] v the second triangle vertex 
+#         * \param[in] w the third triangle vertex 
+#         * \param[in] p the point to check
+#         */
+#       bool isInsideTriangle (const Eigen::Vector2f& u,
+#                         const Eigen::Vector2f& v,
+#                         const Eigen::Vector2f& w,
+#                         const Eigen::Vector2f& p);
+# 
+# 
+#       /** \brief Compute the cross product between 2D vectors.
+#        * \param[in] p1 the first 2D vector
+#        * \param[in] p2 the first 2D vector
+#        */
+#       float crossProduct (const Eigen::Vector2f& p1, const Eigen::Vector2f& p2) const
+###
+
+# factor.h(1.6.0)
+# pcl/surface/3rdparty/poisson4/factor.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# 
+#     double ArcTan2 (const double& y, const double& x);
+#     double Angle (const double in[2]);
+#     void Sqrt (const double in[2], double out[2]);
+#     void Add (const double in1[2], const double in2[2], double out[2]);
+#     void Subtract (const double in1[2], const double in2[2], double out[2]);
+#     void Multiply (const double in1[2], const double in2[2], double out[2]);
+#     void Divide (const double in1[2], const double in2[2], double out[2]);
+# 
+#     int Factor (double a1, double a0, double roots[1][2], const double& EPS);
+#     int Factor (double a2, double a1, double a0, double roots[2][2], const double& EPS);
+#     int Factor (double a3, double a2, double a1, double a0, double roots[3][2], const double& EPS);
+#     int Factor (double a4, double a3, double a2, double a1, double a0, double roots[4][2], const double& EPS);
+# 
+#     int Solve (const double* eqns, const double* values, double* solutions, const int& dim);
+###
+
+# function_data.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/function_data.h (1.7.2)
+# namespace pcl 
+# namespace poisson 
+# template<int Degree,class Real>
+# class FunctionData
+# cdef extern from "pcl/surface/function_data.h" namespace "pcl::poisson":
+#     cdef cppclass FunctionData:
+#         FunctionData()
+#         int useDotRatios;
+#         int normalize;
+#         public:
+#         const static int DOT_FLAG;
+#         const static int D_DOT_FLAG;
+#         const static int D2_DOT_FLAG;
+#         const static int VALUE_FLAG;
+#         const static int D_VALUE_FLAG;
+#         int depth, res, res2;
+#         Real *dotTable, *dDotTable, *d2DotTable;
+#         Real *valueTables, *dValueTables;
+#         PPolynomial<Degree> baseFunction;
+#         PPolynomial<Degree-1> dBaseFunction;
+#         PPolynomial<Degree+1>* baseFunctions;
+#         virtual void setDotTables (const int& flags);
+#         virtual void clearDotTables (const int& flags);
+#         virtual void setValueTables (const int& flags, const double& smooth = 0);
+#         virtual void setValueTables (const int& flags, const double& valueSmooth, const double& normalSmooth);
+#         virtual void clearValueTables (void);
+#         void set (const int& maxDepth, const PPolynomial<Degree>& F, const int& normalize, const int& useDotRatios = 1);
+#         Real dotProduct (const double& center1, const double& width1,
+#                          const double& center2, const double& width2) const;
+#         Real dDotProduct (const double& center1, const double& width1,
+#                           const double& center2, const double& width2) const;
+#         Real d2DotProduct (const double& center1, const double& width1,
+#                            const double& center2, const double& width2) const;
+#         static inline int SymmetricIndex (const int& i1, const int& i2);
+#         static inline int SymmetricIndex (const int& i1, const int& i2, int& index);
+###
+
+# geometry.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/geometry.h (1.7.2)
+# namespace pcl
+# namespace poisson 
+#   {
+#     template<class Real>
+#     Real Random (void);
+# 
+#     template<class Real>
+#     struct Point3D{Real coords[3];};
+# 
+#     template<class Real>
+#     Point3D<Real> RandomBallPoint (void);
+# 
+#     template<class Real>
+#     Point3D<Real> RandomSpherePoint (void);
+# 
+#     template<class Real>
+#     double Length (const Point3D<Real>& p);
+# 
+#     template<class Real>
+#     double SquareLength (const Point3D<Real>& p);
+# 
+#     template<class Real>
+#     double Distance (const Point3D<Real>& p1, const Point3D<Real>& p2);
+# 
+#     template<class Real>
+#     double SquareDistance (const Point3D<Real>& p1, const Point3D<Real>& p2);
+# 
+#     template <class Real>
+#     void CrossProduct (const Point3D<Real>& p1, const Point3D<Real>& p2, Point3D<Real>& p);
+# 
+#     class Edge
+#     {
+#       public:
+#         double p[2][2];
+#         double Length (void) const
+#         {
+#           double d[2];
+#           d[0]=p[0][0]-p[1][0];
+#           d[1]=p[0][1]-p[1][1];
+# 
+#           return sqrt (d[0]*d[0]+d[1]*d[1]);
+#         }
+#     };
+#     
+#     class Triangle
+#     {
+#       public:
+#         double p[3][3];
+#         
+#         double 
+#         Area (void) const
+#         {
+#           double v1[3], v2[3], v[3];
+#           for (int d=0;d<3;d++)
+#           {
+#             v1[d] = p[1][d]-p[0][d];
+#             v2[d] = p[2][d]-p[0][d];
+#           }
+#           v[0] =  v1[1]*v2[2]-v1[2]*v2[1];
+#           v[1] = -v1[0]*v2[2]+v1[2]*v2[0];
+#           v[2] =  v1[0]*v2[1]-v1[1]*v2[0];
+# 
+#           return (sqrt (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) / 2);
+#         }
+# 
+#         double 
+#         AspectRatio (void) const
+#         {
+#           double d=0;
+#           int i, j;
+#           for (i = 0; i < 3; i++)
+#           {
+#             for (i = 0; i < 3; i++)
+#               for (j = 0; j < 3; j++)
+#               {
+#                 d += (p[(i+1)%3][j]-p[i][j])* (p[(i+1)%3][j]-p[i][j]);
+#               }
+#           }
+#           return (Area () / d);
+#         }
+#     };
+# 
+#     class CoredPointIndex
+#     {
+#       public:
+#         int index;
+#         char inCore;
+# 
+#         int operator == (const CoredPointIndex& cpi) const {return (index==cpi.index) && (inCore==cpi.inCore);};
+#         int operator != (const CoredPointIndex& cpi) const {return (index!=cpi.index) || (inCore!=cpi.inCore);};
+#     };
+# 
+#     class EdgeIndex
+#     {
+#       public:
+#         int idx[2];
+#     };
+# 
+#     class CoredEdgeIndex
+#     {
+#       public:
+#         CoredPointIndex idx[2];
+#     };
+# 
+#     class TriangleIndex
+#     {
+#       public:
+#         int idx[3];
+#     };
+# 
+#     class TriangulationEdge
+#     {
+#       public:
+#         TriangulationEdge (void);
+#         int pIndex[2];
+#         int tIndex[2];
+#     };
+# 
+#     class TriangulationTriangle
+#     {
+#       public:
+#         TriangulationTriangle (void);
+#         int eIndex[3];
+#     };
+# 
+#     template<class Real>
+#     class Triangulation
+#     {
+#       public:
+#         Triangulation () : points (),  edges (),  triangles (),  edgeMap () {}
+# 
+#         std::vector<Point3D<Real> >        points;
+#         std::vector<TriangulationEdge>     edges;
+#         std::vector<TriangulationTriangle> triangles;
+# 
+#         int 
+#         factor (const int& tIndex, int& p1, int& p2, int& p3);
+#         
+#         double 
+#         area (void);
+# 
+#         double 
+#         area (const int& tIndex);
+# 
+#         double 
+#         area (const int& p1, const int& p2, const int& p3);
+# 
+#         int 
+#         flipMinimize (const int& eIndex);
+# 
+#         int 
+#         addTriangle (const int& p1, const int& p2, const int& p3);
+# 
+#       protected:
+#         hash_map<long long, int> edgeMap;
+#         static long long EdgeIndex (const int& p1, const int& p2);
+#         double area (const Triangle& t);
+#     };
+# 
+# 
+#     template<class Real> void 
+#     EdgeCollapse (const Real& edgeRatio,
+#                   std::vector<TriangleIndex>& triangles,
+#                   std::vector< Point3D<Real> >& positions,
+#                   std::vector<Point3D<Real> >* normals);
+#     
+#     template<class Real> void 
+#     TriangleCollapse (const Real& edgeRatio,
+#                       std::vector<TriangleIndex>& triangles,
+#                       std::vector<Point3D<Real> >& positions,
+#                       std::vector<Point3D<Real> >* normals);
+# 
+#     struct CoredVertexIndex
+#     {
+#       int idx;
+#       bool inCore;
+#     };
+# 
+#     class CoredMeshData
+#     {
+#       public:
+#         CoredMeshData () : inCorePoints () {}
+# 
+#         virtual ~CoredMeshData () {}
+# 
+#         std::vector<Point3D<float> > inCorePoints;
+#         
+#         virtual void 
+#         resetIterator () = 0;
+# 
+#         virtual int 
+#         addOutOfCorePoint (const Point3D<float>& p) = 0;
+# 
+#         virtual int 
+#         addPolygon (const std::vector< CoredVertexIndex >& vertices) = 0;
+# 
+#         virtual int 
+#         nextOutOfCorePoint (Point3D<float>& p) = 0;
+#         
+#         virtual int 
+#         nextPolygon (std::vector<CoredVertexIndex >& vertices) = 0;
+# 
+#         virtual int 
+#         outOfCorePointCount () = 0;
+#         
+#         virtual int 
+#         polygonCount () = 0;
+#     };
+# 
+#     class CoredVectorMeshData : public CoredMeshData
+#     {
+#       std::vector<Point3D<float> > oocPoints;
+#       std::vector< std::vector< int > > polygons;
+#       int polygonIndex;
+#       int oocPointIndex;
+# 
+#       public:
+#         CoredVectorMeshData ();
+#         
+#         virtual ~CoredVectorMeshData () {}
+# 
+#         void resetIterator (void);
+# 
+#         int addOutOfCorePoint (const Point3D<float>& p);
+#         int addPolygon (const std::vector< CoredVertexIndex >& vertices);
+# 
+#         int nextOutOfCorePoint (Point3D<float>& p);
+#         int nextPolygon (std::vector< CoredVertexIndex >& vertices);
+# 
+#         int outOfCorePointCount (void);
+#         int polygonCount (void);
+#     };
+# 
+#     class CoredFileMeshData : public CoredMeshData
+#     {
+#       FILE *oocPointFile ,  *polygonFile;
+#       int oocPoints ,  polygons;
+#       public:
+#         CoredFileMeshData ();
+#         virtual ~CoredFileMeshData ();
+# 
+#         void resetIterator (void);
+# 
+#         int addOutOfCorePoint (const Point3D<float>& p);
+#         int addPolygon (const std::vector< CoredVertexIndex >& vertices);
+# 
+#         int nextOutOfCorePoint (Point3D<float>& p);
+#         int nextPolygon (std::vector< CoredVertexIndex >& vertices);
+# 
+#         int outOfCorePointCount (void);
+#         int polygonCount (void);
+#     };
+#   }
+# 
+###
+
+# gp3.h
+# namespace pcl
+#   /** \brief Returns if a point X is visible from point R (or the origin)
+#     * when taking into account the segment between the points S1 and S2
+#     * \param X 2D coordinate of the point
+#     * \param S1 2D coordinate of the segment's first point
+#     * \param S2 2D coordinate of the segment's secont point
+#     * \param R 2D coorddinate of the reference point (defaults to 0,0)
+#     * \ingroup surface
+#     */
+#   inline bool 
+#   isVisible (const Eigen::Vector2f &X, const Eigen::Vector2f &S1, const Eigen::Vector2f &S2, 
+#              const Eigen::Vector2f &R = Eigen::Vector2f::Zero ())
+# 
+# /** \brief GreedyProjectionTriangulation is an implementation of a greedy triangulation algorithm for 3D points
+#   * based on local 2D projections. It assumes locally smooth surfaces and relatively smooth transitions between
+#   * areas with different point densities.
+#   * \author Zoltan Csaba Marton
+#   * \ingroup surface
+#   */
+# template <typename PointInT>
+# class GreedyProjectionTriangulation : public MeshConstruction<PointInT>
+cdef extern from "pcl/surface/gp3.h" namespace "pcl::poisson":
+    cdef cppclass GreedyProjectionTriangulation[In](MeshConstruction[In]):
+        GreedyProjectionTriangulation()
+#       public:
+#       using MeshConstruction<PointInT>::tree_;
+#       using MeshConstruction<PointInT>::input_;
+#       using MeshConstruction<PointInT>::indices_;
+#       typedef typename pcl::KdTree<PointInT> KdTree;
+#       typedef typename pcl::KdTree<PointInT>::Ptr KdTreePtr;
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       typedef typename PointCloudIn::Ptr PointCloudInPtr;
+#       typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+#       // FIXME this enum should have a type.  Not be anonymous. 
+#       // Otherplaces where consts are used probably should be fixed.
+#       enum 
+#       { 
+#         NONE = -1,    // not-defined
+#         FREE = 0,    
+#         FRINGE = 1,  
+#         BOUNDARY = 2,
+#         COMPLETED = 3
+#       };
+# 
+#       /** \brief Set the multiplier of the nearest neighbor distance to obtain the final search radius for each point
+#        *  (this will make the algorithm adapt to different point densities in the cloud).
+#        * \param[in] mu the multiplier
+#       inline void setMu (double mu)
+#       /** \brief Get the nearest neighbor distance multiplier. */
+#       inline double getMu ()
+#       /** \brief Set the maximum number of nearest neighbors to be searched for.
+#         * \param[in] nnn the maximum number of nearest neighbors
+#       inline void setMaximumNearestNeighbors (int nnn)
+#       /** \brief Get the maximum number of nearest neighbors to be searched for. */
+#       inline int getMaximumNearestNeighbors ()
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors used for triangulating.
+#         * \param[in] radius the sphere radius that is to contain all k-nearest neighbors
+#         * \note This distance limits the maximum edge length!
+#       inline void setSearchRadius (double radius)
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       inline double getSearchRadius ()
+#       /** \brief Set the minimum angle each triangle should have.
+#         * \param[in] minimum_angle the minimum angle each triangle should have
+#         * \note As this is a greedy approach, this will have to be violated from time to time
+#       inline void setMinimumAngle (double minimum_angle)
+#       /** \brief Get the parameter for distance based weighting of neighbors. */
+#       inline double getMinimumAngle ()
+#       /** \brief Set the maximum angle each triangle can have.
+#         * \param[in] maximum_angle the maximum angle each triangle can have
+#         * \note For best results, its value should be around 120 degrees
+#       inline void setMaximumAngle (double maximum_angle)
+#       /** \brief Get the parameter for distance based weighting of neighbors. */
+#       inline double getMaximumAngle ()
+#       /** \brief Don't consider points for triangulation if their normal deviates more than this value from the query point's normal.
+#         * \param[in] eps_angle maximum surface angle
+#         * \note As normal estimation methods usually give smooth transitions at sharp edges, this ensures correct triangulation
+#         *       by avoiding connecting points from one side to points from the other through forcing the use of the edge points.
+#       inline void setMaximumSurfaceAngle (double eps_angle)
+#       /** \brief Get the maximum surface angle. */
+#       inline double getMaximumSurfaceAngle ()
+#       /** \brief Set the flag if the input normals are oriented consistently.
+#         * \param[in] consistent set it to true if the normals are consistently oriented
+#       inline void setNormalConsistency (bool consistent)
+#       /** \brief Get the flag for consistently oriented normals. */
+#       inline bool getNormalConsistency ()
+#       /** \brief Set the flag to order the resulting triangle vertices consistently (positive direction around normal).
+#         * @note Assumes consistently oriented normals (towards the viewpoint) -- see setNormalConsistency ()
+#         * \param[in] consistent_ordering set it to true if triangle vertices should be ordered consistently
+#       inline void setConsistentVertexOrdering (bool consistent_ordering)
+#       /** \brief Get the flag signaling consistently ordered triangle vertices. */
+#       inline bool getConsistentVertexOrdering ()
+#       /** \brief Get the state of each point after reconstruction.
+#         * \note Options are defined as constants: FREE, FRINGE, COMPLETED, BOUNDARY and NONE
+#       inline std::vector<int> getPointStates ()
+#       /** \brief Get the ID of each point after reconstruction.
+#         * \note parts are numbered from 0, a -1 denotes unconnected points
+#       inline std::vector<int> getPartIDs ()
+#       /** \brief Get the sfn list. */
+#       inline std::vector<int> getSFN ()
+#       /** \brief Get the ffn list. */
+#       inline std::vector<int> getFFN ()
+#       protected:
+#       /** \brief The nearest neighbor distance multiplier to obtain the final search radius. */
+#       double mu_;
+#       /** \brief The nearest neighbors search radius for each point and the maximum edge length. */
+#       double search_radius_;
+#       /** \brief The maximum number of nearest neighbors accepted by searching. */
+#       int nnn_;
+#       /** \brief The preferred minimum angle for the triangles. */
+#       double minimum_angle_;
+#       /** \brief The maximum angle for the triangles. */
+#       double maximum_angle_;
+#       /** \brief Maximum surface angle. */
+#       double eps_angle_;
+#       /** \brief Set this to true if the normals of the input are consistently oriented. */
+#       bool consistent_;
+#       /** \brief Set this to true if the output triangle vertices should be consistently oriented. */
+#       bool consistent_ordering_;
+###
+
+# grid_projection.h
+# namespace pcl
+# {
+#   /** \brief The 12 edges of a cell. */
+#   const int I_SHIFT_EP[12][2] = {
+#     {0, 4}, {1, 5}, {2, 6}, {3, 7}, 
+#     {0, 1}, {1, 2}, {2, 3}, {3, 0},
+#     {4, 5}, {5, 6}, {6, 7}, {7, 4}
+#   };
+# 
+#   const int I_SHIFT_PT[4] = {
+#     0, 4, 5, 7
+#   };
+# 
+#   const int I_SHIFT_EDGE[3][2] = {
+#     {0,1}, {1,3}, {1,2}
+#   };
+# 
+# 
+#   /** \brief Grid projection surface reconstruction method.
+#     * \author Rosie Li
+#     *
+#     * \note If you use this code in any academic work, please cite:
+#     *   - Ruosi Li, Lu Liu, Ly Phan, Sasakthi Abeysinghe, Cindy Grimm, Tao Ju.
+#     *     Polygonizing extremal surfaces with manifold guarantees.
+#     *     In Proceedings of the 14th ACM Symposium on Solid and Physical Modeling, 2010.
+#      * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class GridProjection : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+#       /** \brief Data leaf. */
+#       struct Leaf
+#       {
+#         Leaf () : data_indices (), pt_on_surface (), vect_at_grid_pt () {}
+# 
+#         std::vector<int> data_indices;
+#         Eigen::Vector4f pt_on_surface; 
+#         Eigen::Vector3f vect_at_grid_pt;
+#       };
+# 
+#       typedef boost::unordered_map<int, Leaf, boost::hash<int>, std::equal_to<int>, Eigen::aligned_allocator<int> > HashMap;
+# 
+#       /** \brief Constructor. */ 
+#       GridProjection ();
+# 
+#       /** \brief Constructor. 
+#         * \param in_resolution set the resolution of the grid
+#         */ 
+#       GridProjection (double in_resolution);
+# 
+#       /** \brief Destructor. */
+#       ~GridProjection ();
+# 
+#       /** \brief Set the size of the grid cell
+#         * \param resolution  the size of the grid cell
+#         */
+#       inline void 
+#       setResolution (double resolution)
+#       {
+#         leaf_size_ = resolution;
+#       }
+# 
+#       inline double 
+#       getResolution () const
+#       {
+#         return (leaf_size_);
+#       }
+# 
+#       /** \brief When averaging the vectors, we find the union of all the input data 
+#         *  points within the padding area,and do a weighted average. Say if the padding
+#         *  size is 1, when we process cell (x,y,z), we will find union of input data points
+#         *  from (x-1) to (x+1), (y-1) to (y+1), (z-1) to (z+1)(in total, 27 cells). In this
+#         *  way, even the cells itself doesnt contain any data points, we will stil process it
+#         *  because there are data points in the padding area. This can help us fix holes which 
+#         *  is smaller than the padding size.
+#         * \param padding_size The num of padding cells we want to create 
+#         */
+#       inline void 
+#       setPaddingSize (int padding_size)
+#       {
+#         padding_size_ = padding_size;
+#       }
+#       inline int 
+#       getPaddingSize () const
+#       {
+#         return (padding_size_);
+#       }
+# 
+#       /** \brief Set this only when using the k nearest neighbors search 
+#         * instead of finding the point union
+#         * \param k The number of nearest neighbors we are looking for
+#         */
+#       inline void 
+#       setNearestNeighborNum (int k)
+#       {
+#         k_ = k;
+#       }
+#       inline int 
+#       getNearestNeighborNum () const
+#       {
+#         return (k_);
+#       }
+# 
+#       /** \brief Binary search is used in projection. given a point x, we find another point
+#         *  which is 3*cell_size_ far away from x. Then we do a binary search between these 
+#         *  two points to find where the projected point should be.
+#         */
+#       inline void 
+#       setMaxBinarySearchLevel (int max_binary_search_level)
+#       {
+#         max_binary_search_level_ = max_binary_search_level;
+#       }
+#       inline int 
+#       getMaxBinarySearchLevel () const
+#       {
+#         return (max_binary_search_level_);
+#       }
+# 
+#       ///////////////////////////////////////////////////////////
+#       inline const HashMap& 
+#       getCellHashMap () const
+#       {
+#         return (cell_hash_map_);
+#       }
+# 
+#       inline const std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> >& 
+#       getVectorAtDataPoint () const
+#       {
+#         return (vector_at_data_point_);
+#       }
+#       
+#       inline const std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> >& 
+#       getSurface () const
+#       {
+#         return (surface_);
+#       }
+# 
+#     protected:
+#       /** \brief Get the bounding box for the input data points, also calculating the
+#         * cell size, and the gaussian scale factor
+#         */
+#       void 
+#       getBoundingBox ();
+# 
+#       /** \brief The actual surface reconstruction method.
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       bool
+#       reconstructPolygons (std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Create the surface. 
+#         *
+#         * The 1st step is filling the padding, so that all the cells in the padding
+#         * area are in the hash map. The 2nd step is store the vector, and projected
+#         * point. The 3rd step is finding all the edges intersects the surface, and
+#         * creating surface.
+#         *
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void 
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Create the surface. 
+#         *
+#         * The 1st step is filling the padding, so that all the cells in the padding
+#         * area are in the hash map. The 2nd step is store the vector, and projected
+#         * point. The 3rd step is finding all the edges intersects the surface, and
+#         * creating surface.
+#         *
+#         * \param[out] points the resultant points lying on the surface
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       void 
+#       performReconstruction (pcl::PointCloud<PointNT> &points, 
+#                              std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief When the input data points don't fill into the 1*1*1 box, 
+#         * scale them so that they can be filled in the unit box. Otherwise, 
+#         * it will be some drawing problem when doing visulization
+#         * \param scale_factor scale all the input data point by scale_factor
+#         */
+#       void 
+#       scaleInputDataPoint (double scale_factor);
+# 
+#       /** \brief Get the 3d index (x,y,z) of the cell based on the location of
+#         * the cell
+#         * \param p the coordinate of the input point
+#         * \param index the output 3d index
+#         */
+#       inline void 
+#       getCellIndex (const Eigen::Vector4f &p, Eigen::Vector3i& index) const
+#       {
+#         for (int i = 0; i < 3; ++i)
+#           index[i] = static_cast<int> ((p[i] - min_p_(i)) / leaf_size_);
+#       }
+# 
+#       /** \brief Given the 3d index (x, y, z) of the cell, get the 
+#         * coordinates of the cell center
+#         * \param index the output 3d index
+#         * \param center the resultant cell center
+#         */
+#       inline void
+#       getCellCenterFromIndex (const Eigen::Vector3i &index, Eigen::Vector4f &center) const
+#       {
+#         for (int i = 0; i < 3; ++i)
+#           center[i] = 
+#             min_p_[i] + static_cast<float> (index[i]) * 
+#             static_cast<float> (leaf_size_) + 
+#             static_cast<float> (leaf_size_) / 2.0f;
+#       }
+# 
+#       /** \brief Given cell center, caluate the coordinates of the eight vertices of the cell
+#         * \param cell_center the coordinates of the cell center
+#         * \param pts the coordinates of the 8 vertices
+#         */
+#       void 
+#       getVertexFromCellCenter (const Eigen::Vector4f &cell_center, 
+#                                std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > &pts) const;
+# 
+#       /** \brief Given an index (x, y, z) in 3d, translate it into the index 
+#         * in 1d
+#         * \param index the index of the cell in (x,y,z) 3d format
+#         */
+#       inline int 
+#       getIndexIn1D (const Eigen::Vector3i &index) const
+#       {
+#         //assert(data_size_ > 0);
+#         return (index[0] * data_size_ * data_size_ + 
+#                 index[1] * data_size_ + index[2]);
+#       }
+# 
+#       /** \brief Given an index in 1d, translate it into the index (x, y, z) 
+#         * in 3d
+#         * \param index_1d the input 1d index
+#         * \param index_3d the output 3d index
+#         */
+#       inline void 
+#       getIndexIn3D (int index_1d, Eigen::Vector3i& index_3d) const
+#       {
+#         //assert(data_size_ > 0);
+#         index_3d[0] = index_1d / (data_size_ * data_size_);
+#         index_1d -= index_3d[0] * data_size_ * data_size_;
+#         index_3d[1] = index_1d / data_size_;
+#         index_1d -= index_3d[1] * data_size_;
+#         index_3d[2] = index_1d;
+#       }
+# 
+#       /** \brief For a given 3d index of a cell, test whether the cells within its
+#         * padding area exist in the hash table, if no, create an entry for that cell.
+#         * \param index the index of the cell in (x,y,z) format
+#         */
+#       void 
+#       fillPad (const Eigen::Vector3i &index);
+# 
+#       /** \brief Obtain the index of a cell and the pad size.
+#         * \param index the input index
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       void 
+#       getDataPtsUnion (const Eigen::Vector3i &index, std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Given the index of a cell, exam it's up, left, front edges, and add
+#         * the vectices to m_surface list.the up, left, front edges only share 4
+#         * points, we first get the vectors at these 4 points and exam whether those
+#         * three edges are intersected by the surface \param index the input index
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       void 
+#       createSurfaceForCell (const Eigen::Vector3i &index, std::vector <int> &pt_union_indices);
+# 
+# 
+#       /** \brief Given the coordinates of one point, project it onto the surface, 
+#         * return the projected point. Do a binary search between p and p+projection_distance 
+#         * to find the projected point
+#         * \param p the coordinates of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param projection the resultant point projected
+#         */
+#       void
+#       getProjection (const Eigen::Vector4f &p, std::vector<int> &pt_union_indices, Eigen::Vector4f &projection);
+# 
+#       /** \brief Given the coordinates of one point, project it onto the surface,
+#         * return the projected point. Find the plane which fits all the points in
+#         *  pt_union_indices, projected p to the plane to get the projected point.
+#         * \param p the coordinates of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param projection the resultant point projected
+#         */
+#       void 
+#       getProjectionWithPlaneFit (const Eigen::Vector4f &p, 
+#                                  std::vector<int> &pt_union_indices, 
+#                                  Eigen::Vector4f &projection);
+# 
+# 
+#       /** \brief Given the location of a point, get it's vector
+#         * \param p the coordinates of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param vo the resultant vector
+#         */
+#       void
+#       getVectorAtPoint (const Eigen::Vector4f &p, 
+#                         std::vector <int> &pt_union_indices, Eigen::Vector3f &vo);
+# 
+#       /** \brief Given the location of a point, get it's vector
+#         * \param p the coordinates of the input point
+#         * \param k_indices the k nearest neighbors of the query point
+#         * \param k_squared_distances the squared distances of the k nearest 
+#         * neighbors to the query point
+#         * \param vo the resultant vector
+#         */
+#       void
+#       getVectorAtPointKNN (const Eigen::Vector4f &p, 
+#                            std::vector<int> &k_indices, 
+#                            std::vector<float> &k_squared_distances,
+#                            Eigen::Vector3f &vo);
+# 
+#       /** \brief Get the magnitude of the vector by summing up the distance.
+#         * \param p the coordinate of the input point
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       double 
+#       getMagAtPoint (const Eigen::Vector4f &p, const std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Get the 1st derivative
+#         * \param p the coordinate of the input point
+#         * \param vec the vector at point p
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       double 
+#       getD1AtPoint (const Eigen::Vector4f &p, const Eigen::Vector3f &vec, 
+#                     const std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Get the 2nd derivative
+#         * \param p the coordinate of the input point
+#         * \param vec the vector at point p
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       double 
+#       getD2AtPoint (const Eigen::Vector4f &p, const Eigen::Vector3f &vec, 
+#                     const std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Test whether the edge is intersected by the surface by 
+#         * doing the dot product of the vector at two end points. Also test 
+#         * whether the edge is intersected by the maximum surface by examing 
+#         * the 2nd derivative of the intersection point 
+#         * \param end_pts the two points of the edge
+#         * \param vect_at_end_pts 
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         */
+#       bool 
+#       isIntersected (const std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > &end_pts, 
+#                      std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > &vect_at_end_pts, 
+#                      std::vector <int> &pt_union_indices);
+# 
+#       /** \brief Find point where the edge intersects the surface.
+#         * \param level binary search level
+#         * \param end_pts the two end points on the edge
+#         * \param vect_at_end_pts the vectors at the two end points
+#         * \param start_pt the starting point we use for binary search
+#         * \param pt_union_indices the union of input data points within the cell and padding cells
+#         * \param intersection the resultant intersection point
+#         */
+#       void
+#       findIntersection (int level, 
+#                         const std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > &end_pts, 
+#                         const std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > &vect_at_end_pts, 
+#                         const Eigen::Vector4f &start_pt, 
+#                         std::vector<int> &pt_union_indices,
+#                         Eigen::Vector4f &intersection);
+# 
+#       /** \brief Go through all the entries in the hash table and update the
+#        * cellData. 
+#        *
+#        * When creating the hash table, the pt_on_surface field store the center
+#        * point of the cell.After calling this function, the projection operator will
+#        * project the center point onto the surface, and the pt_on_surface field will
+#        * be updated using the projected point.Also the vect_at_grid_pt field will be
+#        * updated using the vector at the upper left front vertex of the cell.
+#        *
+#        * \param index_1d the index of the cell after flatting it's 3d index into a 1d array
+#        * \param index_3d the index of the cell in (x,y,z) 3d format
+#        * \param pt_union_indices the union of input data points within the cell and pads
+#        * \param cell_data information stored in the cell
+#        */
+#       void
+#       storeVectAndSurfacePoint (int index_1d, const Eigen::Vector3i &index_3d, 
+#                                 std::vector<int> &pt_union_indices, const Leaf &cell_data);
+# 
+#       /** \brief Go through all the entries in the hash table and update the cellData. 
+#         * When creating the hash table, the pt_on_surface field store the center point
+#         * of the cell.After calling this function, the projection operator will project the 
+#         * center point onto the surface, and the pt_on_surface field will be updated 
+#         * using the projected point.Also the vect_at_grid_pt field will be updated using 
+#         * the vector at the upper left front vertex of the cell. When projecting the point 
+#         * and calculating the vector, using K nearest neighbors instead of using the 
+#         * union of input data point within the cell and pads.
+#         *
+#         * \param index_1d the index of the cell after flatting it's 3d index into a 1d array
+#         * \param index_3d the index of the cell in (x,y,z) 3d format
+#         * \param cell_data information stored in the cell
+#         */
+#       void 
+#       storeVectAndSurfacePointKNN (int index_1d, const Eigen::Vector3i &index_3d, const Leaf &cell_data);
+# 
+#     private:
+#       /** \brief Map containing the set of leaves. */
+#       HashMap cell_hash_map_;
+# 
+#       /** \brief Min and max data points. */
+#       Eigen::Vector4f min_p_, max_p_;
+# 
+#       /** \brief The size of a leaf. */
+#       double leaf_size_;
+# 
+#       /** \brief Gaussian scale. */
+#       double gaussian_scale_;
+# 
+#       /** \brief Data size. */
+#       int data_size_;
+# 
+#       /** \brief Max binary search level. */
+#       int max_binary_search_level_;
+# 
+#       /** \brief Number of neighbors (k) to use. */
+#       int k_;
+# 
+#       /** \brief Padding size. */
+#       int padding_size_;
+# 
+#       /** \brief The point cloud input (XYZ+Normals). */
+#       PointCloudPtr data_;
+# 
+#       /** \brief Store the surface normal(vector) at the each input data point. */
+#       std::vector<Eigen::Vector3f, Eigen::aligned_allocator<Eigen::Vector3f> > vector_at_data_point_;
+#       
+#       /** \brief An array of points which lay on the output surface. */
+#       std::vector<Eigen::Vector4f, Eigen::aligned_allocator<Eigen::Vector4f> > surface_;
+# 
+#       /** \brief Bit map which tells if there is any input data point in the cell. */
+#       boost::dynamic_bitset<> occupied_cell_list_;
+# 
+#       /** \brief Class get name method. */
+#       std::string getClassName () const { return ("GridProjection"); }
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# hash.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/hash.h (1.7.2)
+###
+
+# marching_cubes.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2)
+# 
+# namespace pcl
+# {
+#   /*
+#    * Tables, and functions, derived from Paul Bourke's Marching Cubes implementation:
+#    * http://paulbourke.net/geometry/polygonise/
+#    * Cube vertex indices:
+#    *   y_dir 4 ________ 5
+#    *         /|       /|
+#    *       /  |     /  |
+#    *   7 /_______ /    |
+#    *    |     |  |6    |
+#    *    |    0|__|_____|1 x_dir
+#    *    |    /   |    /
+#    *    |  /     |  /
+#    z_dir|/_______|/
+#    *   3          2
+#    */
+#   const unsigned int edgeTable[256] = {
+#     0x0  , 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
+#     0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
+#     0x190, 0x99 , 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
+#     0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
+#     0x230, 0x339, 0x33 , 0x13a, 0x636, 0x73f, 0x435, 0x53c,
+#     0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
+#     0x3a0, 0x2a9, 0x1a3, 0xaa , 0x7a6, 0x6af, 0x5a5, 0x4ac,
+#     0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
+#     0x460, 0x569, 0x663, 0x76a, 0x66 , 0x16f, 0x265, 0x36c,
+#     0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
+#     0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff , 0x3f5, 0x2fc,
+#     0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
+#     0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55 , 0x15c,
+#     0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
+#     0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc ,
+#     0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
+#     0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
+#     0xcc , 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
+#     0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
+#     0x15c, 0x55 , 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
+#     0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
+#     0x2fc, 0x3f5, 0xff , 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
+#     0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
+#     0x36c, 0x265, 0x16f, 0x66 , 0x76a, 0x663, 0x569, 0x460,
+#     0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
+#     0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa , 0x1a3, 0x2a9, 0x3a0,
+#     0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
+#     0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33 , 0x339, 0x230,
+#     0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
+#     0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99 , 0x190,
+#     0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
+#     0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0
+#   };
+#   const int triTable[256][16] = {
+#     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+#     {8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1},
+#     {3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1},
+#     {4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+#     {4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1},
+#     {9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1},
+#     {10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
+#     {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
+#     {5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1},
+#     {8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1},
+#     {2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+#     {2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1},
+#     {11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1},
+#     {5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1},
+#     {11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1},
+#     {11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1},
+#     {2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1},
+#     {6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+#     {3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1},
+#     {6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1},
+#     {6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1},
+#     {8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1},
+#     {7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1},
+#     {3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1},
+#     {0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1},
+#     {9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1},
+#     {8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1},
+#     {5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1},
+#     {0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1},
+#     {6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1},
+#     {10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+#     {1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1},
+#     {0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1},
+#     {3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1},
+#     {6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1},
+#     {9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1},
+#     {8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1},
+#     {3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1},
+#     {10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1},
+#     {10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+#     {2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1},
+#     {7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1},
+#     {2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1},
+#     {1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1},
+#     {11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1},
+#     {8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1},
+#     {0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1},
+#     {7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1},
+#     {7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1},
+#     {10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1},
+#     {0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1},
+#     {7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1},
+#     {6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1},
+#     {4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1},
+#     {10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1},
+#     {8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1},
+#     {1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1},
+#     {10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1},
+#     {10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1},
+#     {9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1},
+#     {7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1},
+#     {3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1},
+#     {7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1},
+#     {3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1},
+#     {6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1},
+#     {9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1},
+#     {1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1},
+#     {4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1},
+#     {7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1},
+#     {6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1},
+#     {0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1},
+#     {6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1},
+#     {0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1},
+#     {11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1},
+#     {6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1},
+#     {5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1},
+#     {9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1},
+#     {1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1},
+#     {10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1},
+#     {0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1},
+#     {11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1},
+#     {9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1},
+#     {7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1},
+#     {2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1},
+#     {9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1},
+#     {9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1},
+#     {1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1},
+#     {0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1},
+#     {10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1},
+#     {2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1},
+#     {0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1},
+#     {0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1},
+#     {9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1},
+#     {5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1},
+#     {5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1},
+#     {8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1},
+#     {9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1},
+#     {1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1},
+#     {3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1},
+#     {4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1},
+#     {9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1},
+#     {11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1},
+#     {11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1},
+#     {2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1},
+#     {9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1},
+#     {3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1},
+#     {1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1},
+#     {4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1},
+#     {0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1},
+#     {9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1},
+#     {1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+#     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
+#   };
+# 
+# 
+#   /** \brief The marching cubes surface reconstruction algorithm. This is an abstract class that takes a grid and
+#     * extracts the isosurface as a mesh, based on the original marching cubes paper:
+#     *
+#     * Lorensen W.E., Cline H.E., "Marching cubes: A high resolution 3d surface construction algorithm",
+#     * SIGGRAPH '87
+#     *
+#     * \author Alexandru E. Ichim
+#     * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class MarchingCubes : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubes ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubes ();
+# 
+# 
+#       /** \brief Method that sets the iso level of the surface to be extracted.
+#         * \param[in] iso_level the iso level.
+#         */
+#       inline void
+#       setIsoLevel (float iso_level)
+#       { iso_level_ = iso_level; }
+# 
+#       /** \brief Method that returns the iso level of the surface to be extracted. */
+#       inline float
+#       getIsoLevel ()
+#       { return iso_level_; }
+# 
+#       /** \brief Method that sets the marching cubes grid resolution.
+#         * \param[in] res_x the resolution of the grid along the x-axis
+#         * \param[in] res_y the resolution of the grid along the y-axis
+#         * \param[in] res_z the resolution of the grid along the z-axis
+#         */
+#       inline void
+#       setGridResolution (int res_x, int res_y, int res_z)
+#       { res_x_ = res_x; res_y_ = res_y; res_z_ = res_z; }
+# 
+# 
+#       /** \brief Method to get the marching cubes grid resolution.
+#         * \param[in] res_x the resolution of the grid along the x-axis
+#         * \param[in] res_y the resolution of the grid along the y-axis
+#         * \param[in] res_z the resolution of the grid along the z-axis
+#         */
+#       inline void
+#       getGridResolution (int &res_x, int &res_y, int &res_z)
+#       { res_x = res_x_; res_y = res_y_; res_z = res_z_; }
+# 
+#       /** \brief Method that sets the parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits. Does not affect the resolution of the grid, it just
+#         * changes the voxel size accordingly.
+#         * \param[in] percentage the percentage of the bounding box that should be left empty between the bounding box and
+#         * the grid limits.
+#         */
+#       inline void
+#       setPercentageExtendGrid (float percentage)
+#       { percentage_extend_grid_ = percentage; }
+# 
+#       /** \brief Method that gets the parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits, as a percentage of the bounding box.
+#         */
+#       inline float
+#       getPercentageExtendGrid ()
+#       { return percentage_extend_grid_; }
+# 
+# protected:
+#       /** \brief The data structure storing the 3D grid */
+#       std::vector<float> grid_;
+# 
+#       /** \brief The grid resolution */
+#       int res_x_, res_y_, res_z_;
+# 
+#       /** \brief Parameter that defines how much free space should be left inside the grid between
+#         * the bounding box of the point cloud and the grid limits, as a percentage of the bounding box.*/
+#       float percentage_extend_grid_;
+# 
+#       /** \brief Min and max data points. */
+#       Eigen::Vector4f min_p_, max_p_;
+# 
+#       /** \brief The iso level to be extracted. */
+#       float iso_level_;
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       virtual void
+#       voxelizeData () = 0;
+# 
+#       /** \brief Interpolate along the voxel edge.
+#         * \param[in] p1 The first point on the edge
+#         * \param[in] p2 The second point on the edge
+#         * \param[in] val_p1 The scalar value at p1
+#         * \param[in] val_p2 The scalar value at p2
+#         * \param[out] output The interpolated point along the edge
+#         */
+#       void
+#       interpolateEdge (Eigen::Vector3f &p1, Eigen::Vector3f &p2, float val_p1, float val_p2, Eigen::Vector3f &output);
+# 
+# 
+#       /** \brief Calculate out the corresponding polygons in the leaf node
+#         * \param leaf_node the leaf node to be checked
+#         * \param index_3d the 3d index of the leaf node to be checked
+#         * \param cloud point cloud to store the vertices of the polygon
+#        */
+#       void
+#       createSurface (std::vector<float> &leaf_node,
+#                      Eigen::Vector3i &index_3d,
+#                      pcl::PointCloud<PointNT> &cloud);
+# 
+#       /** \brief Get the bounding box for the input data points. */
+#       void
+#       getBoundingBox ();
+# 
+# 
+#       /** \brief Method that returns the scalar value at the given grid position.
+#         * \param[in] pos The 3D position in the grid
+#         */
+#       float
+#       getGridValue (Eigen::Vector3i pos);
+# 
+#       /** \brief Method that returns the scalar values of the neighbors of a given 3D position in the grid.
+#         * \param[in] index3d the point in the grid
+#         * \param[out] leaf the set of values
+#         */
+#       void
+#       getNeighborList1D (std::vector<float> &leaf,
+#                          Eigen::Vector3i &index3d);
+# 
+#       /** \brief Class get name method. */
+#       std::string getClassName () const { return ("MarchingCubes"); }
+# 
+#       /** \brief Extract the surface.
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#        void
+#        performReconstruction (pcl::PolygonMesh &output);
+# 
+#        /** \brief Extract the surface.
+#          * \param[out] points the points of the extracted mesh
+#          * \param[out] polygons the connectivity between the point of the extracted mesh.
+#          */
+#        void
+#        performReconstruction (pcl::PointCloud<PointNT> &points,
+#                               std::vector<pcl::Vertices> &polygons);
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# marching_cubes_hoppe.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2) ?
+# namespace pcl
+# {
+#    /** \brief The marching cubes surface reconstruction algorithm, using a signed distance function based on the distance
+#      * from tangent planes, proposed by Hoppe et. al. in:
+#      * Hoppe H., DeRose T., Duchamp T., MC-Donald J., Stuetzle W., "Surface reconstruction from unorganized points",
+#      * SIGGRAPH '92
+#      * \author Alexandru E. Ichim
+#      * \ingroup surface
+#      */
+#   template <typename PointNT>
+#   class MarchingCubesHoppe : public MarchingCubes<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+#       using MarchingCubes<PointNT>::grid_;
+#       using MarchingCubes<PointNT>::res_x_;
+#       using MarchingCubes<PointNT>::res_y_;
+#       using MarchingCubes<PointNT>::res_z_;
+#       using MarchingCubes<PointNT>::min_p_;
+#       using MarchingCubes<PointNT>::max_p_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubesHoppe ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubesHoppe ();
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       void
+#       voxelizeData ();
+# 
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# marching_cubes_poisson.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2)
+# namespace pcl {
+#   namespace poisson {
+# 
+# 
+#     class Square
+#     {
+#     public:
+#       const static int CORNERS = 4, EDGES = 4, NEIGHBORS = 4;
+#       static int  CornerIndex (const int& x, const int& y);
+#       static void FactorCornerIndex (const int& idx, int& x, int& y);
+#       static int  EdgeIndex (const int& orientation, const int& i);
+#       static void FactorEdgeIndex (const int& idx, int& orientation, int& i);
+# 
+#       static int  ReflectCornerIndex (const int& idx, const int& edgeIndex);
+#       static int  ReflectEdgeIndex (const int& idx, const int& edgeIndex);
+# 
+#       static void EdgeCorners (const int& idx, int& c1, int &c2);
+#     };
+# 
+#     class Cube{
+#     public:
+#       const static int CORNERS = 8, EDGES = 12, NEIGHBORS = 6;
+# 
+#       static int CornerIndex (const int& x, const int& y, const int& z);
+#       static void FactorCornerIndex (const int& idx, int& x, int& y, int& z);
+#       static int EdgeIndex (const int& orientation, const int& i, const int& j);
+#       static void FactorEdgeIndex (const int& idx, int& orientation, int& i, int &j);
+#       static int FaceIndex (const int& dir, const int& offSet);
+#       static int FaceIndex (const int& x, const int& y, const int& z);
+#       static void FactorFaceIndex (const int& idx, int& x, int &y, int& z);
+#       static void FactorFaceIndex (const int& idx, int& dir, int& offSet);
+# 
+#       static int AntipodalCornerIndex (const int& idx);
+#       static int FaceReflectCornerIndex (const int& idx, const int& faceIndex);
+#       static int FaceReflectEdgeIndex (const int& idx, const int& faceIndex);
+#       static int FaceReflectFaceIndex (const int& idx, const int& faceIndex);
+#       static int EdgeReflectCornerIndex   (const int& idx, const int& edgeIndex);
+#       static int EdgeReflectEdgeIndex (const int& edgeIndex);
+# 
+#       static int FaceAdjacentToEdges (const int& eIndex1, const int& eIndex2);
+#       static void FacesAdjacentToEdge (const int& eIndex, int& f1Index, int& f2Index);
+# 
+#       static void EdgeCorners (const int& idx, int& c1, int &c2);
+#       static void FaceCorners (const int& idx, int& c1, int &c2, int& c3, int& c4);
+#     };
+# 
+#     class MarchingSquares
+#     {
+#       static double Interpolate (const double& v1, const double& v2);
+#       static void SetVertex (const int& e, const double values[Square::CORNERS], const double& iso);
+#     public:
+#       const static int MAX_EDGES = 2;
+#       static const int edgeMask[1<<Square::CORNERS];
+#       static const int edges[1<<Square::CORNERS][2*MAX_EDGES+1];
+#       static double vertexList[Square::EDGES][2];
+# 
+#       static int GetIndex (const double values[Square::CORNERS], const double& iso);
+#       static int IsAmbiguous (const double v[Square::CORNERS] ,const double& isoValue);
+#       static int AddEdges (const double v[Square::CORNERS], const double& isoValue, Edge* edges);
+#       static int AddEdgeIndices (const double v[Square::CORNERS], const double& isoValue, int* edges);
+#     };
+# 
+#     class MarchingCubes
+#     {
+#       static double Interpolate (const double& v1, const double& v2);
+#       static void SetVertex (const int& e, const double values[Cube::CORNERS], const double& iso);
+#       static int GetFaceIndex (const double values[Cube::CORNERS], const double& iso, const int& faceIndex);
+# 
+#       static float Interpolate (const float& v1, const float& v2);
+#       static void SetVertex (const int& e, const float values[Cube::CORNERS], const float& iso);
+#       static int GetFaceIndex (const float values[Cube::CORNERS], const float& iso, const int& faceIndex);
+# 
+#       static int GetFaceIndex (const int& mcIndex, const int& faceIndex);
+#     public:
+#       const static int MAX_TRIANGLES=5;
+#       static const int edgeMask[1<<Cube::CORNERS];
+#       static const int triangles[1<<Cube::CORNERS][3*MAX_TRIANGLES+1];
+#       static const int cornerMap[Cube::CORNERS];
+#       static double vertexList[Cube::EDGES][3];
+# 
+#       static int AddTriangleIndices (const int& mcIndex, int* triangles);
+# 
+#       static int GetIndex (const double values[Cube::CORNERS],const double& iso);
+#       static int IsAmbiguous (const double v[Cube::CORNERS],const double& isoValue,const int& faceIndex);
+#       static int HasRoots (const double v[Cube::CORNERS],const double& isoValue);
+#       static int HasRoots (const double v[Cube::CORNERS],const double& isoValue,const int& faceIndex);
+#       static int AddTriangles (const double v[Cube::CORNERS],const double& isoValue,Triangle* triangles);
+#       static int AddTriangleIndices (const double v[Cube::CORNERS],const double& isoValue,int* triangles);
+# 
+#       static int GetIndex (const float values[Cube::CORNERS], const float& iso);
+#       static int IsAmbiguous (const float v[Cube::CORNERS], const float& isoValue, const int& faceIndex);
+#       static int HasRoots (const float v[Cube::CORNERS], const float& isoValue);
+#       static int HasRoots (const float v[Cube::CORNERS], const float& isoValue, const int& faceIndex);
+#       static int AddTriangles (const float v[Cube::CORNERS], const float& isoValue, Triangle* triangles);
+#       static int AddTriangleIndices (const float v[Cube::CORNERS], const float& isoValue, int* triangles);
+# 
+#       static int IsAmbiguous (const int& mcIndex, const int& faceIndex);
+#       static int HasRoots (const int& mcIndex);
+#       static int HasFaceRoots (const int& mcIndex, const int& faceIndex);
+#       static int HasEdgeRoots (const int& mcIndex, const int& edgeIndex);
+#     };
+# 
+# 
+###
+
+# marching_cubes_rbf.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/marching_cubes_poisson.h (1.7.2) ?
+# namespace pcl
+# {
+#   /** \brief The marching cubes surface reconstruction algorithm, using a signed distance function based on radial
+#     * basis functions. Partially based on:
+#     * Carr J.C., Beatson R.K., Cherrie J.B., Mitchell T.J., Fright W.R., McCallum B.C. and Evans T.R.,
+#     * "Reconstruction and representation of 3D objects with radial basis functions"
+#     * SIGGRAPH '01
+#     *
+#     * \author Alexandru E. Ichim
+#     * \ingroup surface
+#     */
+#   template <typename PointNT>
+#   class MarchingCubesRBF : public MarchingCubes<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+#       using MarchingCubes<PointNT>::grid_;
+#       using MarchingCubes<PointNT>::res_x_;
+#       using MarchingCubes<PointNT>::res_y_;
+#       using MarchingCubes<PointNT>::res_z_;
+#       using MarchingCubes<PointNT>::min_p_;
+#       using MarchingCubes<PointNT>::max_p_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+# 
+#       /** \brief Constructor. */
+#       MarchingCubesRBF ();
+# 
+#       /** \brief Destructor. */
+#       ~MarchingCubesRBF ();
+# 
+#       /** \brief Convert the point cloud into voxel data. */
+#       void
+#       voxelizeData ();
+# 
+# 
+#       /** \brief Set the off-surface points displacement value.
+#         * \param[in] epsilon the value
+#         */
+#       inline void
+#       setOffSurfaceDisplacement (float epsilon)
+#       { off_surface_epsilon_ = epsilon; }
+# 
+#       /** \brief Get the off-surface points displacement value. */
+#       inline float
+#       getOffSurfaceDisplacement ()
+#       { return off_surface_epsilon_; }
+# 
+# 
+#     protected:
+#       /** \brief the Radial Basis Function kernel. */
+#       double
+#       kernel (Eigen::Vector3d c, Eigen::Vector3d x);
+# 
+#       /** \brief The off-surface displacement value. */
+#       float off_surface_epsilon_;
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# }
+###
+
+# mls.h
+cdef extern from "pcl/surface/mls.h" namespace "pcl":
+    cdef cppclass MovingLeastSquares[I,O]:
+        MovingLeastSquares()
+        void setInputCloud (shared_ptr[cpp.PointCloud[I]])
+        void setSearchRadius (double)
+        void setComputeNormals (bool compute_normals)
+        void setPolynomialOrder(bool)
+        void setPolynomialFit(int)
+        # void process(cpp.PointCloud[O] &) except +
+        void process(cpp.PointCloud[O] &) except +
+        
+        # KdTree
+        void setSearchMethod (const pclkdt.KdTreePtr_t &tree)
+        pclkdt.KdTreePtr_t getSearchMethod ()
+
+ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointXYZ] MovingLeastSquares_t
+ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointXYZI] MovingLeastSquares_PointXYZI_t
+ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointXYZRGB] MovingLeastSquares_PointXYZRGB_t
+ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointXYZRGBA] MovingLeastSquares_PointXYZRGBA_t
+# NG
+# ctypedef MovingLeastSquares[cpp.PointXYZ, cpp.PointNormal] MovingLeastSquares_t
+# ctypedef MovingLeastSquares[cpp.PointXYZI, cpp.PointNormal] MovingLeastSquares_PointXYZI_t
+# ctypedef MovingLeastSquares[cpp.PointXYZRGB, cpp.PointNormal] MovingLeastSquares_PointXYZRGB_t
+# ctypedef MovingLeastSquares[cpp.PointXYZRGBA, cpp.PointNormal] MovingLeastSquares_PointXYZRGBA_t
+
+
+# namespace pcl
+# {
+#   /** \brief MovingLeastSquares represent an implementation of the MLS (Moving Least Squares) algorithm 
+#     * for data smoothing and improved normal estimation. It also contains methods for upsampling the 
+#     * resulting cloud based on the parametric fit.
+#     * Reference paper: "Computing and Rendering Point Set Surfaces" by Marc Alexa, Johannes Behr, 
+#     * Daniel Cohen-Or, Shachar Fleishman, David Levin and Claudio T. Silva
+#     * www.sci.utah.edu/~shachar/Publications/crpss.pdf
+#     * \author Zoltan Csaba Marton, Radu B. Rusu, Alexandru E. Ichim, Suat Gedikli
+#     * \ingroup surface
+#     */
+#   template <typename PointInT, typename PointOutT>
+#   class MovingLeastSquares: public CloudSurfaceProcessing<PointInT, PointOutT>
+#   {
+#     public:
+#       using PCLBase<PointInT>::input_;
+#       using PCLBase<PointInT>::indices_;
+#       using PCLBase<PointInT>::fake_indices_;
+#       using PCLBase<PointInT>::initCompute;
+#       using PCLBase<PointInT>::deinitCompute;
+# 
+#       typedef typename pcl::search::Search<PointInT> KdTree;
+#       typedef typename pcl::search::Search<PointInT>::Ptr KdTreePtr;
+#       typedef pcl::PointCloud<pcl::Normal> NormalCloud;
+#       typedef pcl::PointCloud<pcl::Normal>::Ptr NormalCloudPtr;
+# 
+#       typedef pcl::PointCloud<PointOutT> PointCloudOut;
+#       typedef typename PointCloudOut::Ptr PointCloudOutPtr;
+#       typedef typename PointCloudOut::ConstPtr PointCloudOutConstPtr;
+# 
+#       typedef pcl::PointCloud<PointInT> PointCloudIn;
+#       typedef typename PointCloudIn::Ptr PointCloudInPtr;
+#       typedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+# 
+#       typedef boost::function<int (int, double, std::vector<int> &, std::vector<float> &)> SearchMethod;
+# 
+#       enum UpsamplingMethod { NONE, SAMPLE_LOCAL_PLANE, RANDOM_UNIFORM_DENSITY, VOXEL_GRID_DILATION };
+# 
+#       /** \brief Empty constructor. */
+#       MovingLeastSquares () : CloudSurfaceProcessing<PointInT, PointOutT> (),
+#                               normals_ (),
+#                               search_method_ (),
+#                               tree_ (),
+#                               order_ (2),
+#                               polynomial_fit_ (true),
+#                               search_radius_ (0.0),
+#                               sqr_gauss_param_ (0.0),
+#                               compute_normals_ (false),
+#                               upsample_method_ (NONE),
+#                               upsampling_radius_ (0.0),
+#                               upsampling_step_ (0.0),
+#                               rng_uniform_distribution_ (),
+#                               desired_num_points_in_radius_ (0),
+#                               mls_results_ (),
+#                               voxel_size_ (1.0),
+#                               dilation_iteration_num_ (0),
+#                               nr_coeff_ ()
+#                               {};
+# 
+# 
+#       /** \brief Set whether the algorithm should also store the normals computed
+#         * \note This is optional, but need a proper output cloud type
+#         */
+#       inline void
+#       setComputeNormals (bool compute_normals) { compute_normals_ = compute_normals; }
+# 
+#       /** \brief Provide a pointer to the search object.
+#         * \param[in] tree a pointer to the spatial search object.
+#         */
+#       inline void
+#       setSearchMethod (const KdTreePtr &tree)
+#       {
+#         tree_ = tree;
+#         // Declare the search locator definition
+#         int (KdTree::*radiusSearch)(int index, double radius, std::vector<int> &k_indices, std::vector<float> &k_sqr_distances, unsigned int max_nn) const = &KdTree::radiusSearch;
+#         search_method_ = boost::bind (radiusSearch, boost::ref (tree_), _1, _2, _3, _4, 0);
+#       }
+# 
+#       /** \brief Get a pointer to the search method used. */
+#       inline KdTreePtr 
+#       getSearchMethod () { return (tree_); }
+# 
+#       /** \brief Set the order of the polynomial to be fit.
+#         * \param[in] order the order of the polynomial
+#         */
+#       inline void 
+#       setPolynomialOrder (int order) { order_ = order; }
+# 
+#       /** \brief Get the order of the polynomial to be fit. */
+#       inline int 
+#       getPolynomialOrder () { return (order_); }
+# 
+#       /** \brief Sets whether the surface and normal are approximated using a polynomial, or only via tangent estimation.
+#         * \param[in] polynomial_fit set to true for polynomial fit
+#         */
+#       inline void 
+#       setPolynomialFit (bool polynomial_fit) { polynomial_fit_ = polynomial_fit; }
+# 
+#       /** \brief Get the polynomial_fit value (true if the surface and normal are approximated using a polynomial). */
+#       inline bool 
+#       getPolynomialFit () { return (polynomial_fit_); }
+# 
+#       /** \brief Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting.
+#         * \param[in] radius the sphere radius that is to contain all k-nearest neighbors
+#         * \note Calling this method resets the squared Gaussian parameter to radius * radius !
+#         */
+#       inline void 
+#       setSearchRadius (double radius) { search_radius_ = radius; sqr_gauss_param_ = search_radius_ * search_radius_; }
+# 
+#       /** \brief Get the sphere radius used for determining the k-nearest neighbors. */
+#       inline double 
+#       getSearchRadius () { return (search_radius_); }
+# 
+#       /** \brief Set the parameter used for distance based weighting of neighbors (the square of the search radius works
+#         * best in general).
+#         * \param[in] sqr_gauss_param the squared Gaussian parameter
+#         */
+#       inline void 
+#       setSqrGaussParam (double sqr_gauss_param) { sqr_gauss_param_ = sqr_gauss_param; }
+# 
+#       /** \brief Get the parameter for distance based weighting of neighbors. */
+#       inline double 
+#       getSqrGaussParam () const { return (sqr_gauss_param_); }
+# 
+#       /** \brief Set the upsampling method to be used
+#         * \note Options are: * NONE - no upsampling will be done, only the input points will be projected to their own
+#         *                             MLS surfaces
+#         *                    * SAMPLE_LOCAL_PLANE - the local plane of each input point will be sampled in a circular
+#         *                                           fashion using the \ref upsampling_radius_ and the \ref upsampling_step_
+#         *                                           parameters
+#         *                    * RANDOM_UNIFORM_DENSITY - the local plane of each input point will be sampled using an
+#         *                                               uniform random distribution such that the density of points is
+#         *                                               constant throughout the cloud - given by the \ref \ref desired_num_points_in_radius_
+#         *                                               parameter
+#         *                    * VOXEL_GRID_DILATION - the input cloud will be inserted into a voxel grid with voxels of
+#         *                                            size \ref voxel_size_; this voxel grid will be dilated \ref dilation_iteration_num_
+#         *                                            times and the resulting points will be projected to the MLS surface
+#         *                                            of the closest point in the input cloud; the result is a point cloud
+#         *                                            with filled holes and a constant point density
+#         */
+#       inline void
+#       setUpsamplingMethod (UpsamplingMethod method) { upsample_method_ = method; }
+# 
+# 
+#       /** \brief Set the radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         * \param[in] radius the radius of the circle
+#         */
+#       inline void
+#       setUpsamplingRadius (double radius) { upsampling_radius_ = radius; }
+# 
+#       /** \brief Get the radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       inline double
+#       getUpsamplingRadius () { return upsampling_radius_; }
+# 
+#       /** \brief Set the step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         * \param[in] step_size the step size
+#         */
+#       inline void
+#       setUpsamplingStepSize (double step_size) { upsampling_step_ = step_size; }
+# 
+# 
+#       /** \brief Get the step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       inline double
+#       getUpsamplingStepSize () { return upsampling_step_; }
+# 
+#       /** \brief Set the parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         * \param[in] desired_num_points_in_radius the desired number of points in the output cloud in a sphere of
+#         * radius \ref search_radius_ around each point
+#         */
+#       inline void
+#       setPointDensity (int desired_num_points_in_radius) { desired_num_points_in_radius_ = desired_num_points_in_radius; }
+# 
+# 
+#       /** \brief Get the parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       inline int
+#       getPointDensity () { return desired_num_points_in_radius_; }
+# 
+#       /** \brief Set the voxel size for the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         * \param[in] voxel_size the edge length of a cubic voxel in the voxel grid
+#         */
+#       inline void
+#       setDilationVoxelSize (float voxel_size) { voxel_size_ = voxel_size; }
+# 
+# 
+#       /** \brief Get the voxel size for the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         */
+#       inline float
+#       getDilationVoxelSize () { return voxel_size_; }
+# 
+#       /** \brief Set the number of dilation steps of the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         * \param[in] iterations the number of dilation iterations
+#         */
+#       inline void
+#       setDilationIterations (int iterations) { dilation_iteration_num_ = iterations; }
+# 
+#       /** \brief Get the number of dilation steps of the voxel grid
+#         * \note Used only in the VOXEL_GRID_DILATION upsampling method
+#         */
+#       inline int
+#       getDilationIterations () { return dilation_iteration_num_; }
+# 
+#       /** \brief Base method for surface reconstruction for all points given in <setInputCloud (), setIndices ()>
+#         * \param[out] output the resultant reconstructed surface model
+#         */
+#       void 
+#       process (PointCloudOut &output);
+# 
+#     protected:
+#       /** \brief The point cloud that will hold the estimated normals, if set. */
+#       NormalCloudPtr normals_;
+# 
+#       /** \brief The search method template for indices. */
+#       SearchMethod search_method_;
+# 
+#       /** \brief A pointer to the spatial search object. */
+#       KdTreePtr tree_;
+# 
+#       /** \brief The order of the polynomial to be fit. */
+#       int order_;
+# 
+#       /** True if the surface and normal be approximated using a polynomial, false if tangent estimation is sufficient. */
+#       bool polynomial_fit_;
+# 
+#       /** \brief The nearest neighbors search radius for each point. */
+#       double search_radius_;
+# 
+#       /** \brief Parameter for distance based weighting of neighbors (search_radius_ * search_radius_ works fine) */
+#       double sqr_gauss_param_;
+# 
+#       /** \brief Parameter that specifies whether the normals should be computed for the input cloud or not */
+#       bool compute_normals_;
+# 
+#       /** \brief Parameter that specifies the upsampling method to be used */
+#       UpsamplingMethod upsample_method_;
+# 
+#       /** \brief Radius of the circle in the local point plane that will be sampled
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       double upsampling_radius_;
+# 
+#       /** \brief Step size for the local plane sampling
+#         * \note Used only in the case of SAMPLE_LOCAL_PLANE upsampling
+#         */
+#       double upsampling_step_;
+# 
+#       /** \brief Random number generator using an uniform distribution of floats
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       boost::variate_generator<boost::mt19937, boost::uniform_real<float> > *rng_uniform_distribution_;
+# 
+#       /** \brief Parameter that specifies the desired number of points within the search radius
+#         * \note Used only in the case of RANDOM_UNIFORM_DENSITY upsampling
+#         */
+#       int desired_num_points_in_radius_;
+# 
+#       
+#       /** \brief Data structure used to store the results of the MLS fitting
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       struct MLSResult
+#       {
+#         MLSResult () : plane_normal (), u (), v (), c_vec (), num_neighbors (), curvature (), valid (false) {}
+# 
+#         MLSResult (Eigen::Vector3d &a_plane_normal,
+#                    Eigen::Vector3d &a_u,
+#                    Eigen::Vector3d &a_v,
+#                    Eigen::VectorXd a_c_vec,
+#                    int a_num_neighbors,
+#                    float &a_curvature);
+# 
+#         Eigen::Vector3d plane_normal, u, v;
+#         Eigen::VectorXd c_vec;
+#         int num_neighbors;
+#         float curvature;
+#         bool valid;
+#       };
+# 
+#       /** \brief Stores the MLS result for each point in the input cloud
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       std::vector<MLSResult> mls_results_;
+# 
+#       
+#       /** \brief A minimalistic implementation of a voxel grid, necessary for the point cloud upsampling
+#         * \note Used only in the case of VOXEL_GRID_DILATION upsampling
+#         */
+#       class MLSVoxelGrid
+#       {
+#         public:
+#           struct Leaf { Leaf () : valid (true) {} bool valid; };
+# 
+#           MLSVoxelGrid (PointCloudInConstPtr& cloud,
+#                         IndicesPtr &indices,
+#                         float voxel_size);
+# 
+#           void
+#           dilate ();
+# 
+#           inline void
+#           getIndexIn1D (const Eigen::Vector3i &index, uint64_t &index_1d) const
+#           {
+#             index_1d = index[0] * data_size_ * data_size_ +
+#                        index[1] * data_size_ + index[2];
+#           }
+# 
+#           inline void
+#           getIndexIn3D (uint64_t index_1d, Eigen::Vector3i& index_3d) const
+#           {
+#             index_3d[0] = static_cast<Eigen::Vector3i::Scalar> (index_1d / (data_size_ * data_size_));
+#             index_1d -= index_3d[0] * data_size_ * data_size_;
+#             index_3d[1] = static_cast<Eigen::Vector3i::Scalar> (index_1d / data_size_);
+#             index_1d -= index_3d[1] * data_size_;
+#             index_3d[2] = static_cast<Eigen::Vector3i::Scalar> (index_1d);
+#           }
+# 
+#           inline void
+#           getCellIndex (const Eigen::Vector3f &p, Eigen::Vector3i& index) const
+#           {
+#             for (int i = 0; i < 3; ++i)
+#               index[i] = static_cast<Eigen::Vector3i::Scalar> ((p[i] - bounding_min_(i)) / voxel_size_);
+#           }
+# 
+#           inline void
+#           getPosition (const uint64_t &index_1d, Eigen::Vector3f &point) const
+#           {
+#             Eigen::Vector3i index_3d;
+#             getIndexIn3D (index_1d, index_3d);
+#             for (int i = 0; i < 3; ++i)
+#               point[i] = static_cast<Eigen::Vector3f::Scalar> (index_3d[i]) * voxel_size_ + bounding_min_[i];
+#           }
+# 
+#           typedef std::map<uint64_t, Leaf> HashMap;
+#           HashMap voxel_grid_;
+#           Eigen::Vector4f bounding_min_, bounding_max_;
+#           uint64_t data_size_;
+#           float voxel_size_;
+#       };
+# 
+# 
+#       /** \brief Voxel size for the VOXEL_GRID_DILATION upsampling method */
+#       float voxel_size_;
+# 
+#       /** \brief Number of dilation steps for the VOXEL_GRID_DILATION upsampling method */
+#       int dilation_iteration_num_; 
+# 
+#       /** \brief Number of coefficients, to be computed from the requested order.*/
+#       int nr_coeff_;
+# 
+#       /** \brief Search for the closest nearest neighbors of a given point using a radius search
+#         * \param[in] index the index of the query point
+#         * \param[out] indices the resultant vector of indices representing the k-nearest neighbors
+#         * \param[out] sqr_distances the resultant squared distances from the query point to the k-nearest neighbors
+#         */
+#       inline int
+#       searchForNeighbors (int index, std::vector<int> &indices, std::vector<float> &sqr_distances)
+#       {
+#         return (search_method_ (index, search_radius_, indices, sqr_distances));
+#       }
+# 
+#       /** \brief Smooth a given point and its neighborghood using Moving Least Squares.
+#         * \param[in] index the inex of the query point in the \ref input cloud
+#         * \param[in] input the input point cloud that \ref nn_indices refer to
+#         * \param[in] nn_indices the set of nearest neighbors indices for \ref pt
+#         * \param[in] nn_sqr_dists the set of nearest neighbors squared distances for \ref pt
+#         * \param[out] projected_points the set of points projected points around the query point
+#         * (in the case of upsampling method NONE, only the query point projected to its own fitted surface will be returned,
+#         * in the case of the other upsampling methods, multiple points will be returned)
+#         * \param[out] projected_points_normals the normals corresponding to the projected points
+#         */
+#       void
+#       computeMLSPointNormal (int index,
+#                              const PointCloudIn &input,
+#                              const std::vector<int> &nn_indices,
+#                              std::vector<float> &nn_sqr_dists,
+#                              PointCloudOut &projected_points,
+#                              NormalCloud &projected_points_normals);
+# 
+#       /** \brief Fits a point (sample point) given in the local plane coordinates of an input point (query point) to
+#         * the MLS surface of the input point
+#         * \param[in] u_disp the u coordinate of the sample point in the local plane of the query point
+#         * \param[in] v_disp the v coordinate of the sample point in the local plane of the query point
+#         * \param[in] u the axis corresponding to the u-coordinates of the local plane of the query point
+#         * \param[in] v the axis corresponding to the v-coordinates of the local plane of the query point
+#         * \param[in] plane_normal the normal to the local plane of the query point
+#         * \param[in] curvature the curvature of the surface at the query point
+#         * \param[in] query_point the absolute 3D position of the query point
+#         * \param[in] c_vec the coefficients of the polynomial fit on the MLS surface of the query point
+#         * \param[in] num_neighbors the number of neighbors of the query point in the input cloud
+#         * \param[out] result_point the absolute 3D position of the resulting projected point
+#         * \param[out] result_normal the normal of the resulting projected point
+#         */
+#       void
+#       projectPointToMLSSurface (float &u_disp, float &v_disp,
+#                                 Eigen::Vector3d &u, Eigen::Vector3d &v,
+#                                 Eigen::Vector3d &plane_normal,
+#                                 float &curvature,
+#                                 Eigen::Vector3f &query_point,
+#                                 Eigen::VectorXd &c_vec,
+#                                 int num_neighbors,
+#                                 PointOutT &result_point,
+#                                 pcl::Normal &result_normal);
+#     public:
+#         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+###
+
+# mls_omp.h
+# namespace pcl
+# {
+#   /** \brief MovingLeastSquaresOMP represent an OpenMP implementation of the MLS (Moving Least Squares) algorithm for 
+#     * data smoothing and improved normal estimation.
+#     * \author Radu B. Rusu
+#     * \ingroup surface
+#     */
+#   template <typename PointInT, typename PointOutT>
+#   class MovingLeastSquaresOMP : public MovingLeastSquares<PointInT, PointOutT>
+#   {
+#     using MovingLeastSquares<PointInT, PointOutT>::input_;
+#     using MovingLeastSquares<PointInT, PointOutT>::indices_;
+#     using MovingLeastSquares<PointInT, PointOutT>::fake_indices_;
+#     using MovingLeastSquares<PointInT, PointOutT>::initCompute;
+#     using MovingLeastSquares<PointInT, PointOutT>::deinitCompute;
+#     using MovingLeastSquares<PointInT, PointOutT>::nr_coeff_;
+#     using MovingLeastSquares<PointInT, PointOutT>::order_;
+#     using MovingLeastSquares<PointInT, PointOutT>::normals_;
+#     using MovingLeastSquares<PointInT, PointOutT>::upsample_method_;
+#     using MovingLeastSquares<PointInT, PointOutT>::voxel_size_;
+#     using MovingLeastSquares<PointInT, PointOutT>::dilation_iteration_num_;
+#     using MovingLeastSquares<PointInT, PointOutT>::tree_;
+#     using MovingLeastSquares<PointInT, PointOutT>::mls_results_;
+#     using MovingLeastSquares<PointInT, PointOutT>::search_radius_;
+#     using MovingLeastSquares<PointInT, PointOutT>::compute_normals_;
+#     using MovingLeastSquares<PointInT, PointOutT>::searchForNeighbors;
+#       
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::PointCloudIn PointCloudIn;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::PointCloudOut PointCloudOut;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::NormalCloud NormalCloud;
+#     typedef typename MovingLeastSquares<PointInT, PointOutT>::MLSVoxelGrid MLSVoxelGrid;
+# 
+#     public:
+#       /** \brief Empty constructor. */
+#       MovingLeastSquaresOMP () : threads_ (1)
+#       {};
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       MovingLeastSquaresOMP (unsigned int nr_threads) : threads_ (0)
+#       {
+#         setNumberOfThreads (nr_threads);
+#       }
+# 
+#       /** \brief Initialize the scheduler and set the number of threads to use.
+#         * \param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+#         */
+#       inline void 
+#       setNumberOfThreads (unsigned int nr_threads)
+#       { 
+#         if (nr_threads == 0)
+#           nr_threads = 1;
+#         threads_ = nr_threads; 
+#       }
+# 
+###
+
+# multi_grid_octree_data.h
+# pcl/surface/3rdparty/poisson4/multi_grid_octree_data.h (1.7.2)
+# namespace pcl 
+# {
+#   namespace poisson 
+#   {
+#     typedef float Real;
+#     typedef float FunctionDataReal;
+#     typedef OctNode<class TreeNodeData,Real> TreeOctNode;
+# 
+#     class RootInfo
+#     {
+#       public:
+#         const TreeOctNode* node;
+#         int edgeIndex;
+#         long long key;
+#     };
+# 
+#     class VertexData
+#     {
+#       public:
+#         static long long 
+#         EdgeIndex (const TreeOctNode* node, const int& eIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         EdgeIndex (const TreeOctNode* node, const int& eIndex, const int& maxDepth);
+# 
+#         static long long 
+#         FaceIndex (const TreeOctNode* node, const int& fIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         FaceIndex (const TreeOctNode* node, const int& fIndex, const int& maxDepth);
+# 
+#         static long long 
+#         CornerIndex (const int& depth, const int offSet[DIMENSION] ,const int& cIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CornerIndex (const TreeOctNode* node, const int& cIndex, const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CornerIndex (const TreeOctNode* node, const int& cIndex, const int& maxDepth);
+# 
+#         static long long 
+#         CenterIndex (const int& depth, const int offSet[DIMENSION], const int& maxDepth, int index[DIMENSION]);
+# 
+#         static long long 
+#         CenterIndex (const TreeOctNode* node, const int& maxDepth, int index[DIMENSION]);
+#         
+#         static long long 
+#         CenterIndex (const TreeOctNode* node, const int& maxDepth);
+#     };
+# 
+#     class SortedTreeNodes
+#     {
+#       public:
+#         TreeOctNode** treeNodes;
+#         int *nodeCount;
+#         int maxDepth;
+#         SortedTreeNodes ();
+#         ~SortedTreeNodes ();
+#         void 
+#         set (TreeOctNode& root,const int& setIndex);
+#     };
+# 
+#     class TreeNodeData
+#     {
+#       public:
+#         static int UseIndex;
+#         union
+#         {
+#           int mcIndex;
+#           struct
+#           {
+#             int nodeIndex;
+#             Real centerWeightContribution;
+#           };
+#         };
+#         Real value;
+# 
+#         TreeNodeData (void);
+#         ~TreeNodeData (void);
+#     };
+# 
+#     template<int Degree>
+#     class Octree
+#     {
+#       TreeOctNode::NeighborKey neighborKey;
+#       TreeOctNode::NeighborKey2 neighborKey2;
+# 
+#       Real radius;
+#       int width;
+# 
+#       void 
+#       setNodeIndices (TreeOctNode& tree,int& idx);
+#       
+#       Real 
+#       GetDotProduct (const int index[DIMENSION]) const;
+# 
+#       Real 
+#       GetLaplacian (const int index[DIMENSION]) const;
+# 
+#       Real 
+#       GetDivergence (const int index[DIMENSION], const Point3D<Real>& normal) const;
+# 
+#       class DivergenceFunction
+#       {
+#         public:
+#           Point3D<Real> normal;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+# 
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class LaplacianProjectionFunction
+#       {
+#         public:
+#           double value;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+# 
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class LaplacianMatrixFunction
+#       {
+#         public:
+#           int x2,y2,z2,d2;
+#           Octree<Degree>* ot;
+#           int index[DIMENSION],scratch[DIMENSION];
+#           int elementCount,offset;
+#           MatrixEntry<float>* rowElements;
+# 
+#           int 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class RestrictedLaplacianMatrixFunction
+#       {
+#         public:
+#           int depth,offset[3];
+#           Octree<Degree>* ot;
+#           Real radius;
+#           int index[DIMENSION], scratch[DIMENSION];
+#           int elementCount;
+#           MatrixEntry<float>* rowElements;
+# 
+#           int 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       ///////////////////////////
+#       // Evaluation Functions  //
+#       ///////////////////////////
+#       class PointIndexValueFunction
+#       {
+#         public:
+#           int res2;
+#           FunctionDataReal* valueTables;
+#           int index[DIMENSION];
+#           Real value;
+# 
+#           void 
+#           Function (const TreeOctNode* node);
+#       };
+# 
+#       class PointIndexValueAndNormalFunction
+#       {
+#         public:
+#           int res2;
+#           FunctionDataReal* valueTables;
+#           FunctionDataReal* dValueTables;
+#           Real value;
+#           Point3D<Real> normal;
+#           int index[DIMENSION];
+# 
+#           void 
+#           Function (const TreeOctNode* node);
+#       };
+# 
+#       class AdjacencyCountFunction
+#       {
+#         public:
+#           int adjacencyCount;
+# 
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class AdjacencySetFunction
+#       {
+#         public:
+#           int *adjacencies,adjacencyCount;
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class RefineFunction
+#       {
+#         public:
+#           int depth;
+#           void 
+#           Function (TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       class FaceEdgesFunction 
+#       {
+#         public:
+#           int fIndex,maxDepth;
+#           std::vector<std::pair<long long,long long> >* edges;
+#           hash_map<long long, std::pair<RootInfo,int> >* vertexCount;
+# 
+#           void 
+#           Function (const TreeOctNode* node1, const TreeOctNode* node2);
+#       };
+# 
+#       int 
+#       SolveFixedDepthMatrix (const int& depth, const SortedTreeNodes& sNodes);
+#       
+#       int 
+#       SolveFixedDepthMatrix (const int& depth, const int& startingDepth, const SortedTreeNodes& sNodes);
+# 
+#       int 
+#       GetFixedDepthLaplacian (SparseSymmetricMatrix<float>& matrix, const int& depth, const SortedTreeNodes& sNodes);
+# 
+#       int 
+#       GetRestrictedFixedDepthLaplacian (SparseSymmetricMatrix<float>& matrix,
+#                                         const int& depth,
+#                                         const int* entries,
+#                                         const int& entryCount,
+#                                         const TreeOctNode* rNode,
+#                                         const Real& radius,
+#                                         const SortedTreeNodes& sNodes);
+# 
+#       void 
+#       SetIsoSurfaceCorners (const Real& isoValue, const int& subdivisionDepth, const int& fullDepthIso);
+# 
+#       static int 
+#       IsBoundaryFace (const TreeOctNode* node, const int& faceIndex, const int& subdivideDepth);
+#       
+#       static int 
+#       IsBoundaryEdge (const TreeOctNode* node, const int& edgeIndex, const int& subdivideDepth);
+#       
+#       static int 
+#       IsBoundaryEdge (const TreeOctNode* node, const int& dir, const int& x, const int& y, const int& subidivideDepth);
+#       
+#       void 
+#       PreValidate (const Real& isoValue, const int& maxDepth, const int& subdivideDepth);
+#       
+#       void 
+#       PreValidate (TreeOctNode* node, const Real& isoValue, const int& maxDepth, const int& subdivideDepth);
+#       
+#       void 
+#       Validate (TreeOctNode* node,
+#                 const Real& isoValue,
+#                 const int& maxDepth,
+#                 const int& fullDepthIso,
+#                 const int& subdivideDepth);
+# 
+#       void 
+#       Validate (TreeOctNode* node, const Real& isoValue, const int& maxDepth, const int& fullDepthIso);
+# 
+#       void 
+#       Subdivide (TreeOctNode* node, const Real& isoValue, const int& maxDepth);
+# 
+#       int 
+#       SetBoundaryMCRootPositions (const int& sDepth,const Real& isoValue,
+#                                   hash_map<long long,int>& boundaryRoots,
+#                                   hash_map<long long,
+#                                   std::pair<Real,Point3D<Real> > >& boundaryNormalHash,
+#                                   CoredMeshData* mesh,
+#                                   const int& nonLinearFit);
+# 
+#       int 
+#       SetMCRootPositions (TreeOctNode* node,
+#                           const int& sDepth,
+#                           const Real& isoValue,
+#                           hash_map<long long, int>& boundaryRoots,
+#                           hash_map<long long, int>* interiorRoots,
+#                           hash_map<long long, std::pair<Real,Point3D<Real> > >& boundaryNormalHash,
+#                           hash_map<long long, std::pair<Real,Point3D<Real> > >* interiorNormalHash,
+#                           std::vector<Point3D<float> >* interiorPositions,
+#                           CoredMeshData* mesh,
+#                           const int& nonLinearFit);
+# 
+#       int 
+#       GetMCIsoTriangles (TreeOctNode* node,
+#                          CoredMeshData* mesh,
+#                          hash_map<long long,int>& boundaryRoots,
+#                          hash_map<long long,int>* interiorRoots,
+#                          std::vector<Point3D<float> >* interiorPositions,
+#                          const int& offSet,
+#                          const int& sDepth, 
+#                          bool addBarycenter, 
+#                          bool polygonMesh);
+# 
+#       static int 
+#       AddTriangles (CoredMeshData* mesh,
+#                     std::vector<CoredPointIndex> edges[3],
+#                     std::vector<Point3D<float> >* interiorPositions, 
+#                     const int& offSet);
+#       
+#       static int 
+#       AddTriangles (CoredMeshData* mesh, 
+#                     std::vector<CoredPointIndex>& edges, std::vector<Point3D<float> >* interiorPositions, 
+#                     const int& offSet, 
+#                     bool addBarycenter, 
+#                     bool polygonMesh);
+# 
+#       void 
+#       GetMCIsoEdges (TreeOctNode* node,
+#                      hash_map<long long,int>& boundaryRoots,
+#                      hash_map<long long,int>* interiorRoots,
+#                      const int& sDepth,
+#                      std::vector<std::pair<long long,long long> >& edges);
+# 
+#       static int 
+#       GetEdgeLoops (std::vector<std::pair<long long,long long> >& edges,
+#                     std::vector<std::vector<std::pair<long long,long long> > >& loops);
+# 
+#       static int 
+#       InteriorFaceRootCount (const TreeOctNode* node,const int &faceIndex,const int& maxDepth);
+# 
+#       static int 
+#       EdgeRootCount (const TreeOctNode* node,const int& edgeIndex,const int& maxDepth);
+# 
+#       int 
+#       GetRoot (const RootInfo& ri,
+#                const Real& isoValue,
+#                const int& maxDepth,Point3D<Real> & position,
+#                hash_map<long long,std::pair<Real,Point3D<Real> > >& normalHash,
+#                Point3D<Real>* normal,
+#                const int& nonLinearFit);
+# 
+#       int 
+#       GetRoot (const RootInfo& ri,
+#                const Real& isoValue,
+#                Point3D<Real> & position,
+#                hash_map<long long,
+#                std::pair<Real,Point3D<Real> > >& normalHash,
+#                const int& nonLinearFit);
+# 
+#       static int 
+#       GetRootIndex (const TreeOctNode* node,const int& edgeIndex,const int& maxDepth,RootInfo& ri);
+# 
+#       static int 
+#       GetRootIndex (const TreeOctNode* node, 
+#                     const int& edgeIndex,
+#                     const int& maxDepth,
+#                     const int& sDepth,
+#                     RootInfo& ri);
+#       
+#       static int 
+#       GetRootIndex (const long long& key,
+#                     hash_map<long long,int>& boundaryRoots,
+#                     hash_map<long long,int>* interiorRoots,
+#                     CoredPointIndex& index);
+#       
+#       static int 
+#       GetRootPair (const RootInfo& root,const int& maxDepth,RootInfo& pair);
+# 
+#       int 
+#       NonLinearUpdateWeightContribution (TreeOctNode* node,
+#                                          const Point3D<Real>& position,
+#                                          const Real& weight = Real(1.0));
+# 
+#       Real 
+#       NonLinearGetSampleWeight (TreeOctNode* node,
+#                                 const Point3D<Real>& position);
+#       
+#       void 
+#       NonLinearGetSampleDepthAndWeight (TreeOctNode* node,
+#                                         const Point3D<Real>& position,
+#                                         const Real& samplesPerNode,
+#                                         Real& depth,
+#                                         Real& weight);
+# 
+#       int 
+#       NonLinearSplatOrientedPoint (TreeOctNode* node,
+#                                    const Point3D<Real>& point,
+#                                    const Point3D<Real>& normal);
+#       
+#       void 
+#       NonLinearSplatOrientedPoint (const Point3D<Real>& point,
+#                                    const Point3D<Real>& normal,
+#                                    const int& kernelDepth,
+#                                    const Real& samplesPerNode,
+#                                    const int& minDepth,
+#                                    const int& maxDepth);
+# 
+#       int 
+#       HasNormals (TreeOctNode* node,const Real& epsilon);
+# 
+#       Real 
+#       getCenterValue (const TreeOctNode* node);
+# 
+#       Real 
+#       getCornerValue (const TreeOctNode* node,const int& corner);
+# 
+#       void 
+#       getCornerValueAndNormal (const TreeOctNode* node,const int& corner,Real& value,Point3D<Real>& normal);
+# 
+#       public:
+#         static double maxMemoryUsage;
+#         static double 
+#         MemoryUsage ();
+# 
+#         std::vector<Point3D<Real> >* normals;
+#         Real postNormalSmooth;
+#         TreeOctNode tree;
+#         FunctionData<Degree,FunctionDataReal> fData;
+#         Octree ();
+# 
+#         void 
+#         setFunctionData (const PPolynomial<Degree>& ReconstructionFunction,
+#                          const int& maxDepth,
+#                          const int& normalize,
+#                          const Real& normalSmooth = -1);
+#         
+#         void 
+#         finalize1 (const int& refineNeighbors=-1);
+#         
+#         void 
+#         finalize2 (const int& refineNeighbors=-1);
+# 
+#         //int setTree(char* fileName,const int& maxDepth,const int& binary,const int& kernelDepth,const Real& samplesPerNode,
+#         //    const Real& scaleFactor,Point3D<Real>& center,Real& scale,const int& resetSampleDepths,const int& useConfidence);
+# 
+#         template<typename PointNT> int
+#         setTree (boost::shared_ptr<const pcl::PointCloud<PointNT> > input_,
+#                  const int& maxDepth,
+#                  const int& kernelDepth,
+#                  const Real& samplesPerNode,
+#                  const Real& scaleFactor,
+#                  Point3D<Real>& center,
+#                  Real& scale,
+#                  const int& resetSamples,
+#                  const int& useConfidence);
+# 
+# 
+#         void 
+#         SetLaplacianWeights (void);
+#         
+#         void 
+#         ClipTree (void);
+# 
+#         int 
+#         LaplacianMatrixIteration (const int& subdivideDepth);
+# 
+#         Real 
+#         GetIsoValue (void);
+#         
+#         void 
+#         GetMCIsoTriangles (const Real& isoValue,
+#                            CoredMeshData* mesh,
+#                            const int& fullDepthIso = 0,
+#                            const int& nonLinearFit = 1, 
+#                            bool addBarycenter = false, 
+#                            bool polygonMesh = false);
+#         
+#         void 
+#         GetMCIsoTriangles (const Real& isoValue,
+#                            const int& subdivideDepth,
+#                            CoredMeshData* mesh,
+#                            const int& fullDepthIso = 0,
+#                            const int& nonLinearFit = 1, 
+#                            bool addBarycenter = false, 
+#                            bool polygonMesh = false );
+#     };
+#   }
+# }
+# 
+###
+
+# octree_poisson.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/octree_poisson.h (1.7.2)
+# namespace pcl 
+# {
+#   namespace poisson 
+#   {
+# 
+#     template<class NodeData,class Real=float>
+#     class OctNode
+#     {
+#       private:
+#         static int UseAlloc;
+# 
+#         class AdjacencyCountFunction
+#         {
+#           public:
+#             int count;
+#             void Function(const OctNode<NodeData,Real>* node1,const OctNode<NodeData,Real>* node2);
+#         };
+# 
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeFaces (OctNode* node,
+#                                  NodeAdjacencyFunction* F,
+#                                  const int& cIndex1, const int& cIndex2, const int& cIndex3, const int& cIndex4);
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeEdges (OctNode* node,
+#                                  NodeAdjacencyFunction* F,
+#                                  const int& cIndex1, const int& cIndex2);
+#         template<class NodeAdjacencyFunction>
+#         void __processNodeNodes (OctNode* node, NodeAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                 OctNode* node1, const int& radius1,
+#                                                 OctNode* node2, const int& radius2,
+#                                                 const int& cWidth2,
+#                                                 NodeAdjacencyFunction* F);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void __ProcessTerminatingNodeAdjacentNodes(const int& dx, const int& dy, const int& dz,
+#                                                           OctNode* node1, const int& radius1,
+#                                                           OctNode* node2, const int& radius2,
+#                                                           const int& cWidth2,
+#                                                           TerminatingNodeAdjacencyFunction* F);
+#         template<class PointAdjacencyFunction>
+#         static void __ProcessPointAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                  OctNode* node2, const int& radius2,
+#                                                  const int& cWidth2,
+#                                                  PointAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessFixedDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                           OctNode* node1, const int& radius1,
+#                                                           OctNode* node2, const int& radius2,
+#                                                           const int& cWidth2,
+#                                                           const int& depth,
+#                                                           NodeAdjacencyFunction* F);
+#         template<class NodeAdjacencyFunction>
+#         static void __ProcessMaxDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                         OctNode* node1, const int& radius1,
+#                                                         OctNode* node2, const int& radius2,
+#                                                         const int& cWidth2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F);
+# 
+#         // This is made private because the division by two has been pulled out.
+#         static inline int Overlap (const int& c1, const int& c2, const int& c3, const int& dWidth);
+#         inline static int ChildOverlap (const int& dx, const int& dy, const int& dz, const int& d, const int& cRadius2);
+# 
+#         const OctNode* __faceNeighbor (const int& dir, const int& off) const;
+#         const OctNode* __edgeNeighbor (const int& o, const int i[2], const int idx[2]) const;
+#         OctNode* __faceNeighbor (const int& dir, const int& off, const int& forceChildren);
+#         OctNode* __edgeNeighbor (const int& o, const int i[2], const int idx[2], const int& forceChildren);
+#       public:
+#         static const int DepthShift,OffsetShift,OffsetShift1,OffsetShift2,OffsetShift3;
+#         static const int DepthMask,OffsetMask;
+# 
+#         static Allocator<OctNode> AllocatorOctNode;
+#         static int UseAllocator (void);
+#         static void SetAllocator (int blockSize);
+# 
+#         OctNode* parent;
+#         OctNode* children;
+#         short d,off[3];
+#         NodeData nodeData;
+# 
+# 
+#         OctNode (void);
+#         ~OctNode (void);
+#         int initChildren (void);
+# 
+#         void depthAndOffset (int& depth, int offset[3]) const;
+#         int depth (void) const;
+#         static inline void DepthAndOffset (const long long& index, int& depth, int offset[3]);
+#         static inline void CenterAndWidth (const long long& index, Point3D<Real>& center, Real& width);
+#         static inline int Depth (const long long& index);
+#         static inline void Index (const int& depth, const int offset[3], short& d, short off[3]);
+#         void centerAndWidth (Point3D<Real>& center, Real& width) const;
+# 
+#         int leaves (void) const;
+#         int maxDepthLeaves (const int& maxDepth) const;
+#         int nodes (void) const;
+#         int maxDepth (void) const;
+# 
+#         const OctNode* root (void) const;
+# 
+#         const OctNode* nextLeaf (const OctNode* currentLeaf = NULL) const;
+#         OctNode* nextLeaf (OctNode* currentLeaf = NULL);
+#         const OctNode* nextNode (const OctNode* currentNode = NULL) const;
+#         OctNode* nextNode (OctNode* currentNode = NULL);
+#         const OctNode* nextBranch (const OctNode* current) const;
+#         OctNode* nextBranch (OctNode* current);
+# 
+#         void setFullDepth (const int& maxDepth);
+# 
+#         void printLeaves (void) const;
+#         void printRange (void) const;
+# 
+#         template<class NodeAdjacencyFunction>
+#         void processNodeFaces (OctNode* node,NodeAdjacencyFunction* F, const int& fIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeEdges (OctNode* node, NodeAdjacencyFunction* F, const int& eIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeCorners (OctNode* node, NodeAdjacencyFunction* F, const int& cIndex, const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         void processNodeNodes (OctNode* node, NodeAdjacencyFunction* F, const int& processCurrent=1);
+# 
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessNodeAdjacentNodes (const int& maxDepth,
+#                                               OctNode* node1, const int& width1,
+#                                               OctNode* node2, const int& width2,
+#                                               NodeAdjacencyFunction* F,
+#                                               const int& processCurrent=1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                               OctNode* node1, const int& radius1,
+#                                               OctNode* node2, const int& radius2,
+#                                               const int& width2,
+#                                               NodeAdjacencyFunction* F,
+#                                               const int& processCurrent = 1);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void ProcessTerminatingNodeAdjacentNodes (const int& maxDepth,
+#                                                          OctNode* node1, const int& width1,
+#                                                          OctNode* node2, const int& width2,
+#                                                          TerminatingNodeAdjacencyFunction* F,
+#                                                          const int& processCurrent = 1);
+#         template<class TerminatingNodeAdjacencyFunction>
+#         static void ProcessTerminatingNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                          OctNode* node1, const int& radius1,
+#                                                          OctNode* node2, const int& radius2,
+#                                                          const int& width2,
+#                                                          TerminatingNodeAdjacencyFunction* F,
+#                                                          const int& processCurrent = 1);
+#         template<class PointAdjacencyFunction>
+#         static void ProcessPointAdjacentNodes (const int& maxDepth,
+#                                                const int center1[3],
+#                                                OctNode* node2, const int& width2,
+#                                                PointAdjacencyFunction* F,
+#                                                const int& processCurrent = 1);
+#         template<class PointAdjacencyFunction>
+#         static void ProcessPointAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                OctNode* node2, const int& radius2, const int& width2,
+#                                                PointAdjacencyFunction* F,
+#                                                const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessFixedDepthNodeAdjacentNodes (const int& maxDepth,
+#                                                         OctNode* node1, const int& width1,
+#                                                         OctNode* node2, const int& width2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F,
+#                                                         const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessFixedDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                         OctNode* node1, const int& radius1,
+#                                                         OctNode* node2, const int& radius2,
+#                                                         const int& width2,
+#                                                         const int& depth,
+#                                                         NodeAdjacencyFunction* F,
+#                                                         const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessMaxDepthNodeAdjacentNodes (const int& maxDepth,
+#                                                       OctNode* node1, const int& width1,
+#                                                       OctNode* node2, const int& width2,
+#                                                       const int& depth,
+#                                                       NodeAdjacencyFunction* F,
+#                                                       const int& processCurrent = 1);
+#         template<class NodeAdjacencyFunction>
+#         static void ProcessMaxDepthNodeAdjacentNodes (const int& dx, const int& dy, const int& dz,
+#                                                       OctNode* node1, const int& radius1,
+#                                                       OctNode* node2, const int& radius2,
+#                                                       const int& width2,
+#                                                       const int& depth,
+#                                                       NodeAdjacencyFunction* F,
+#                                                       const int& processCurrent = 1);
+# 
+#         static int CornerIndex (const Point3D<Real>& center, const Point3D<Real> &p);
+# 
+#         OctNode* faceNeighbor (const int& faceIndex, const int& forceChildren = 0);
+#         const OctNode* faceNeighbor (const int& faceIndex) const;
+#         OctNode* edgeNeighbor (const int& edgeIndex, const int& forceChildren = 0);
+#         const OctNode* edgeNeighbor (const int& edgeIndex) const;
+#         OctNode* cornerNeighbor (const int& cornerIndex, const int& forceChildren = 0);
+#         const OctNode* cornerNeighbor (const int& cornerIndex) const;
+# 
+#         OctNode* getNearestLeaf (const Point3D<Real>& p);
+#         const OctNode* getNearestLeaf (const Point3D<Real>& p) const;
+# 
+#         static int CommonEdge (const OctNode* node1, const int& eIndex1,
+#                                const OctNode* node2, const int& eIndex2);
+#         static int CompareForwardDepths (const void* v1, const void* v2);
+#         static int CompareForwardPointerDepths (const void* v1, const void* v2);
+#         static int CompareBackwardDepths (const void* v1, const void* v2);
+#         static int CompareBackwardPointerDepths (const void* v1, const void* v2);
+# 
+# 
+#         template<class NodeData2>
+#         OctNode& operator = (const OctNode<NodeData2, Real>& node);
+# 
+#         static inline int Overlap2 (const int &depth1,
+#                                     const int offSet1[DIMENSION],
+#                                     const Real& multiplier1,
+#                                     const int &depth2,
+#                                     const int offSet2[DIMENSION],
+#                                     const Real& multiplier2);
+# 
+# 
+#         int write (const char* fileName) const;
+#         int write (FILE* fp) const;
+#         int read (const char* fileName);
+#         int read (FILE* fp);
+# 
+#         class Neighbors{
+#         public:
+#           OctNode* neighbors[3][3][3];
+#           Neighbors (void);
+#           void clear (void);
+#         };
+#         class NeighborKey{
+#         public:
+#           Neighbors* neighbors;
+# 
+#           NeighborKey (void);
+#           ~NeighborKey (void);
+# 
+#           void set (const int& depth);
+#           Neighbors& setNeighbors (OctNode* node);
+#           Neighbors& getNeighbors (OctNode* node);
+#         };
+#         class Neighbors2{
+#         public:
+#           const OctNode* neighbors[3][3][3];
+#           Neighbors2 (void);
+#           void clear (void);
+#         };
+#         class NeighborKey2{
+#         public:
+#           Neighbors2* neighbors;
+# 
+#           NeighborKey2 (void);
+#           ~NeighborKey2 (void);
+# 
+#           void set (const int& depth);
+#           Neighbors2& getNeighbors (const OctNode* node);
+#         };
+# 
+#         void centerIndex (const int& maxDepth, int index[DIMENSION]) const;
+#         int width (const int& maxDepth) const;
+#     };
+# 
+#   }
+# }
+###
+
+# organized_fast_mesh.h
+# namespace pcl
+# {
+# 
+#   /** \brief Simple triangulation/surface reconstruction for organized point
+#     * clouds. Neighboring points (pixels in image space) are connected to
+#     * construct a triangular mesh.
+#     *
+#     * \author Dirk Holz, Radu B. Rusu
+#     * \ingroup surface
+#     */
+#   template <typename PointInT>
+#   class OrganizedFastMesh : public MeshConstruction<PointInT>
+#   {
+#     public:
+#       using MeshConstruction<PointInT>::input_;
+#       using MeshConstruction<PointInT>::check_tree_;
+# 
+#       typedef typename pcl::PointCloud<PointInT>::Ptr PointCloudPtr;
+# 
+#       typedef std::vector<pcl::Vertices> Polygons;
+# 
+#       enum TriangulationType
+#       {
+#         TRIANGLE_RIGHT_CUT,     // _always_ "cuts" a quad from top left to bottom right
+#         TRIANGLE_LEFT_CUT,      // _always_ "cuts" a quad from top right to bottom left
+#         TRIANGLE_ADAPTIVE_CUT,  // "cuts" where possible and prefers larger differences in 'z' direction
+#         QUAD_MESH               // create a simple quad mesh
+#       };
+# 
+#       /** \brief Constructor. Triangulation type defaults to \a QUAD_MESH. */
+#       OrganizedFastMesh ()
+#       : max_edge_length_squared_ (0.025f)
+#       , triangle_pixel_size_ (1)
+#       , triangulation_type_ (QUAD_MESH)
+#       , store_shadowed_faces_ (false)
+#       , cos_angle_tolerance_ (fabsf (cosf (pcl::deg2rad (12.5f))))
+#       {
+#         check_tree_ = false;
+#       };
+# 
+#       /** \brief Destructor. */
+#       ~OrganizedFastMesh () {};
+# 
+#       /** \brief Set a maximum edge length. TODO: Implement!
+#         * \param[in] max_edge_length the maximum edge length
+#         */
+#       inline void
+#       setMaxEdgeLength (float max_edge_length)
+#       {
+#         max_edge_length_squared_ = max_edge_length * max_edge_length;
+#       };
+# 
+#       /** \brief Set the edge length (in pixels) used for constructing the fixed mesh.
+#         * \param[in] triangle_size edge length in pixels
+#         * (Default: 1 = neighboring pixels are connected)
+#         */
+#       inline void
+#       setTrianglePixelSize (int triangle_size)
+#       {
+#         triangle_pixel_size_ = std::max (1, (triangle_size - 1));
+#       }
+# 
+#       /** \brief Set the triangulation type (see \a TriangulationType)
+#         * \param[in] type quad mesh, triangle mesh with fixed left, right cut,
+#         * or adaptive cut (splits a quad wrt. the depth (z) of the points)
+#         */
+#       inline void
+#       setTriangulationType (TriangulationType type)
+#       {
+#         triangulation_type_ = type;
+#       }
+# 
+#       /** \brief Store shadowed faces or not.
+#         * \param[in] enable set to true to store shadowed faces
+#         */
+#       inline void
+#       storeShadowedFaces (bool enable)
+#       {
+#         store_shadowed_faces_ = enable;
+#       }
+# 
+#     protected:
+#       /** \brief max (squared) length of edge */
+#       float max_edge_length_squared_;
+# 
+#       /** \brief size of triangle endges (in pixels) */
+#       int triangle_pixel_size_;
+# 
+#       /** \brief Type of meshin scheme (quads vs. triangles, left cut vs. right cut ... */
+#       TriangulationType triangulation_type_;
+# 
+#       /** \brief Whether or not shadowed faces are stored, e.g., for exploration */
+#       bool store_shadowed_faces_;
+# 
+#       float cos_angle_tolerance_;
+# 
+#       /** \brief Perform the actual polygonal reconstruction.
+#         * \param[out] polygons the resultant polygons
+#         */
+#       void
+#       reconstructPolygons (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create the surface.
+#         * \param[out] polygons the resultant polygons, as a set of vertices. The Vertices structure contains an array of point indices.
+#         */
+#       virtual void
+#       performReconstruction (std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Create the surface.
+#         *
+#         * Simply uses image indices to create an initial polygonal mesh for organized point clouds.
+#         * \a indices_ are ignored!
+#         *
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Add a new triangle to the current polygon mesh
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] idx the index in the set of polygon vertices (assumes \a idx is valid in \a polygons)
+#         * \param[out] polygons the polygon mesh to be updated
+#         */
+#       inline void
+#       addTriangle (int a, int b, int c, int idx, std::vector<pcl::Vertices>& polygons)
+#       {
+#         assert (idx < static_cast<int> (polygons.size ()));
+#         polygons[idx].vertices.resize (3);
+#         polygons[idx].vertices[0] = a;
+#         polygons[idx].vertices[1] = b;
+#         polygons[idx].vertices[2] = c;
+#       }
+# 
+#       /** \brief Add a new quad to the current polygon mesh
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         * \param[in] idx the index in the set of polygon vertices (assumes \a idx is valid in \a polygons)
+#         * \param[out] polygons the polygon mesh to be updated
+#         */
+#       inline void
+#       addQuad (int a, int b, int c, int d, int idx, std::vector<pcl::Vertices>& polygons)
+#       {
+#         assert (idx < static_cast<int> (polygons.size ()));
+#         polygons[idx].vertices.resize (4);
+#         polygons[idx].vertices[0] = a;
+#         polygons[idx].vertices[1] = b;
+#         polygons[idx].vertices[2] = c;
+#         polygons[idx].vertices[3] = d;
+#       }
+# 
+#       /** \brief Set (all) coordinates of a particular point to the specified value
+#         * \param[in] point_index index of point
+#         * \param[out] mesh to modify
+#         * \param[in] value value to use when re-setting
+#         * \param[in] field_x_idx the X coordinate of the point
+#         * \param[in] field_y_idx the Y coordinate of the point
+#         * \param[in] field_z_idx the Z coordinate of the point
+#         */
+#       inline void
+#       resetPointData (const int &point_index, pcl::PolygonMesh &mesh, const float &value = 0.0f,
+#                       int field_x_idx = 0, int field_y_idx = 1, int field_z_idx = 2)
+#       {
+#         float new_value = value;
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_x_idx].offset], &new_value, sizeof (float));
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_y_idx].offset], &new_value, sizeof (float));
+#         memcpy (&mesh.cloud.data[point_index * mesh.cloud.point_step + mesh.cloud.fields[field_z_idx].offset], &new_value, sizeof (float));
+#       }
+# 
+#       /** \brief Check if a point is shadowed by another point
+#         * \param[in] point_a the first point
+#         * \param[in] point_b the second point
+#         */
+#       inline bool
+#       isShadowed (const PointInT& point_a, const PointInT& point_b)
+#       {
+#         Eigen::Vector3f viewpoint = Eigen::Vector3f::Zero (); // TODO: allow for passing viewpoint information
+#         Eigen::Vector3f dir_a = viewpoint - point_a.getVector3fMap ();
+#         Eigen::Vector3f dir_b = point_b.getVector3fMap () - point_a.getVector3fMap ();
+#         float distance_to_points = dir_a.norm ();
+#         float distance_between_points = dir_b.norm ();
+#         float cos_angle = dir_a.dot (dir_b) / (distance_to_points*distance_between_points);
+#         if (cos_angle != cos_angle)
+#           cos_angle = 1.0f;
+#         return (fabs (cos_angle) >= cos_angle_tolerance_);
+#         // TODO: check for both: angle almost 0/180 _and_ distance between points larger than noise level
+#       }
+# 
+#       /** \brief Check if a triangle is valid.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         */
+#       inline bool
+#       isValidTriangle (const int& a, const int& b, const int& c)
+#       {
+#         if (!pcl::isFinite (input_->points[a])) return (false);
+#         if (!pcl::isFinite (input_->points[b])) return (false);
+#         if (!pcl::isFinite (input_->points[c])) return (false);
+#         return (true);
+#       }
+# 
+#       /** \brief Check if a triangle is shadowed.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         */
+#       inline bool
+#       isShadowedTriangle (const int& a, const int& b, const int& c)
+#       {
+#         if (isShadowed (input_->points[a], input_->points[b])) return (true);
+#         if (isShadowed (input_->points[b], input_->points[c])) return (true);
+#         if (isShadowed (input_->points[c], input_->points[a])) return (true);
+#         return (false);
+#       }
+# 
+#       /** \brief Check if a quad is valid.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         */
+#       inline bool
+#       isValidQuad (const int& a, const int& b, const int& c, const int& d)
+#       {
+#         if (!pcl::isFinite (input_->points[a])) return (false);
+#         if (!pcl::isFinite (input_->points[b])) return (false);
+#         if (!pcl::isFinite (input_->points[c])) return (false);
+#         if (!pcl::isFinite (input_->points[d])) return (false);
+#         return (true);
+#       }
+# 
+#       /** \brief Check if a triangle is shadowed.
+#         * \param[in] a index of the first vertex
+#         * \param[in] b index of the second vertex
+#         * \param[in] c index of the third vertex
+#         * \param[in] d index of the fourth vertex
+#         */
+#       inline bool
+#       isShadowedQuad (const int& a, const int& b, const int& c, const int& d)
+#       {
+#         if (isShadowed (input_->points[a], input_->points[b])) return (true);
+#         if (isShadowed (input_->points[b], input_->points[c])) return (true);
+#         if (isShadowed (input_->points[c], input_->points[d])) return (true);
+#         if (isShadowed (input_->points[d], input_->points[a])) return (true);
+#         return (false);
+#       }
+# 
+#       /** \brief Create a quad mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeQuadMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create a right cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeRightCutMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create a left cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeLeftCutMesh (std::vector<pcl::Vertices>& polygons);
+# 
+#       /** \brief Create an adaptive cut mesh.
+#         * \param[out] polygons the resultant mesh
+#         */
+#       void
+#       makeAdaptiveCutMesh (std::vector<pcl::Vertices>& polygons);
+#   };
+# 
+###
+
+# poisson.h
+# namespace pcl
+# {
+#   /** \brief The Poisson surface reconstruction algorithm.
+#     * \note Code adapted from Misha Kazhdan: http://www.cs.jhu.edu/~misha/Code/PoissonRecon/
+#     * \note Based on the paper:
+#     *       * Michael Kazhdan, Matthew Bolitho, Hugues Hoppe, "Poisson surface reconstruction",
+#     *         SGP '06 Proceedings of the fourth Eurographics symposium on Geometry processing
+#     * \author Alexandru-Eugen Ichim
+#     * \ingroup surface
+#     */
+#   template<typename PointNT>
+#   class Poisson : public SurfaceReconstruction<PointNT>
+#   {
+#     public:
+#       using SurfaceReconstruction<PointNT>::input_;
+#       using SurfaceReconstruction<PointNT>::tree_;
+# 
+#       typedef typename pcl::PointCloud<PointNT>::Ptr PointCloudPtr;
+# 
+#       typedef typename pcl::KdTree<PointNT> KdTree;
+#       typedef typename pcl::KdTree<PointNT>::Ptr KdTreePtr;
+# 
+#       /** \brief Constructor that sets all the parameters to working default values. */
+#       Poisson ();
+# 
+#       /** \brief Destructor. */
+#       ~Poisson ();
+# 
+#       /** \brief Create the surface.
+#         * \param[out] output the resultant polygonal mesh
+#         */
+#       void
+#       performReconstruction (pcl::PolygonMesh &output);
+# 
+#       /** \brief Create the surface.
+#         * \param[out] points the vertex positions of the resulting mesh
+#         * \param[out] polygons the connectivity of the resulting mesh
+#         */
+#       void
+#       performReconstruction (pcl::PointCloud<PointNT> &points,
+#                              std::vector<pcl::Vertices> &polygons);
+# 
+#       /** \brief Set the confidence flag
+#         * \note Enabling this flag tells the reconstructor to use the size of the normals as confidence information.
+#         * When the flag is not enabled, all normals are normalized to have unit-length prior to reconstruction.
+#         * \param[in] confidence the given flag
+#         */
+#       inline void
+#       setConfidence (bool confidence) { confidence_ = confidence; }
+# 
+#       /** \brief Get the confidence flag */
+#       inline bool
+#       getConfidence () { return confidence_; }
+# 
+#       /** \brief Set the manifold flag.
+#         * \note Enabling this flag tells the reconstructor to add the polygon barycenter when triangulating polygons
+#         * with more than three vertices.
+#         * \param[in] manifold the given flag
+#         */
+#       inline void
+#       setManifold (bool manifold) { manifold_ = manifold; }
+# 
+#       /** \brief Get the manifold flag */
+#       inline bool
+#       getManifold () { return manifold_; }
+# 
+#       /** \brief Enabling this flag tells the reconstructor to output a polygon mesh (rather than triangulating the
+#         * results of Marching Cubes).
+#         * \param[in] output_polygons the given flag
+#         */
+#       inline void
+#       setOutputPolygons (bool output_polygons) { output_polygons_ = output_polygons; }
+# 
+#       /** \brief Get whether the algorithm outputs a polygon mesh or a triangle mesh */
+#       inline bool
+#       getOutputPolygons () { return output_polygons_; }
+# 
+# 
+#       /** \brief Set the maximum depth of the tree that will be used for surface reconstruction.
+#         * \note Running at depth d corresponds to solving on a voxel grid whose resolution is no larger than
+#         * 2^d x 2^d x 2^d. Note that since the reconstructor adapts the octree to the sampling density, the specified
+#         * reconstruction depth is only an upper bound.
+#         * \param[in] depth the depth parameter
+#         */
+#       inline void
+#       setDepth (int depth) { depth_ = depth; }
+# 
+#       /** \brief Get the depth parameter */
+#       inline int
+#       getDepth () { return depth_; }
+# 
+#       /** \brief Set the the depth at which a block Gauss-Seidel solver is used to solve the Laplacian equation
+#         * \note Using this parameter helps reduce the memory overhead at the cost of a small increase in
+#         * reconstruction time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide
+#         * depth of 7 or 8 can greatly reduce the memory usage.)
+#         * \param[in] solver_divide the given parameter value
+#         */
+#       inline void
+#       setSolverDivide (int solver_divide) { solver_divide_ = solver_divide; }
+# 
+#       /** \brief Get the the depth at which a block Gauss-Seidel solver is used to solve the Laplacian equation */
+#       inline int
+#       getSolverDivide () { return solver_divide_; }
+# 
+#       /** \brief Set the depth at which a block iso-surface extractor should be used to extract the iso-surface
+#         * \note Using this parameter helps reduce the memory overhead at the cost of a small increase in extraction
+#         * time. (In practice, we have found that for reconstructions of depth 9 or higher a subdivide depth of 7 or 8
+#         * can greatly reduce the memory usage.)
+#         * \param[in] iso_divide the given parameter value
+#         */
+#       inline void
+#       setIsoDivide (int iso_divide) { iso_divide_ = iso_divide; }
+# 
+#       /** \brief Get the depth at which a block iso-surface extractor should be used to extract the iso-surface */
+#       inline int
+#       getIsoDivide () { return iso_divide_; }
+# 
+#       /** \brief Set the minimum number of sample points that should fall within an octree node as the octree
+#         * construction is adapted to sampling density
+#         * \note For noise-free samples, small values in the range [1.0 - 5.0] can be used. For more noisy samples,
+#         * larger values in the range [15.0 - 20.0] may be needed to provide a smoother, noise-reduced, reconstruction.
+#         * \param[in] samples_per_node the given parameter value
+#         */
+#       inline void
+#       setSamplesPerNode (float samples_per_node) { samples_per_node_ = samples_per_node; }
+# 
+#       /** \brief Get the minimum number of sample points that should fall within an octree node as the octree
+#         * construction is adapted to sampling density
+#         */
+#       inline float
+#       getSamplesPerNode () { return samples_per_node_; }
+# 
+#       /** \brief Set the ratio between the diameter of the cube used for reconstruction and the diameter of the
+#         * samples' bounding cube.
+#         * \param[in] scale the given parameter value
+#         */
+#       inline void
+#       setScale (float scale) { scale_ = scale; }
+# 
+#       /** Get the ratio between the diameter of the cube used for reconstruction and the diameter of the
+#         * samples' bounding cube.
+#         */
+#       inline float
+#       getScale () { return scale_; }
+# 
+#       /** \brief Set the degree parameter
+#         * \param[in] degree the given degree
+#         */
+#       inline void
+#       setDegree (int degree) { degree_ = degree; }
+# 
+#       /** \brief Get the degree parameter */
+#       inline int
+#       getDegree () { return degree_; }
+# 
+# 
+#     protected:
+#       /** \brief The point cloud input (XYZ+Normals). */
+#       PointCloudPtr data_;
+# 
+#       /** \brief Class get name method. */
+#       std::string
+#       getClassName () const { return ("Poisson"); }
+# 
+#     private:
+#       bool no_reset_samples_;
+#       bool no_clip_tree_;
+#       bool confidence_;
+#       bool manifold_;
+#       bool output_polygons_;
+# 
+#       int depth_;
+#       int solver_divide_;
+#       int iso_divide_;
+#       int refine_;
+#       int kernel_depth_;
+#       int degree_;
+# 
+#       float samples_per_node_;
+#       float scale_;
+# 
+#       template<int Degree> void
+#       execute (poisson::CoredMeshData &mesh,
+#                poisson::Point3D<float> &translate,
+#                float &scale);
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+###
+
+# polynomial.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/polynomial.h (1.7.2)
+# namespace pcl
+# namespace poisson
+# template<int Degree>
+# class Polynomial
+#       public:
+#       double coefficients[Degree+1];
+# 
+#       Polynomial(void);
+#       template<int Degree2>
+#       Polynomial(const Polynomial<Degree2>& P);
+#       double operator() (const double& t) const;
+#       double integral (const double& tMin,const double& tMax) const;
+# 
+#       int operator == (const Polynomial& p) const;
+#       int operator != (const Polynomial& p) const;
+#       int isZero(void) const;
+#       void setZero(void);
+# 
+#       template<int Degree2>
+#       Polynomial& operator  = (const Polynomial<Degree2> &p);
+#       Polynomial& operator += (const Polynomial& p);
+#       Polynomial& operator -= (const Polynomial& p);
+#       Polynomial  operator -  (void) const;
+#       Polynomial  operator +  (const Polynomial& p) const;
+#       Polynomial  operator -  (const Polynomial& p) const;
+#       template<int Degree2>
+#       Polynomial<Degree+Degree2>  operator *  (const Polynomial<Degree2>& p) const;
+# 
+#       Polynomial& operator += (const double& s);
+#       Polynomial& operator -= (const double& s);
+#       Polynomial& operator *= (const double& s);
+#       Polynomial& operator /= (const double& s);
+#       Polynomial  operator +  (const double& s) const;
+#       Polynomial  operator -  (const double& s) const;
+#       Polynomial  operator *  (const double& s) const;
+#       Polynomial  operator /  (const double& s) const;
+# 
+#       Polynomial scale (const double& s) const;
+#       Polynomial shift (const double& t) const;
+# 
+#       Polynomial<Degree-1> derivative (void) const;
+#       Polynomial<Degree+1> integral (void) const;
+# 
+#       void printnl (void) const;
+# 
+#       Polynomial& addScaled (const Polynomial& p, const double& scale);
+# 
+#       static void Negate (const Polynomial& in, Polynomial& out);
+#       static void Subtract (const Polynomial& p1, const Polynomial& p2, Polynomial& q);
+#       static void Scale (const Polynomial& p, const double& w, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const double& w1, const Polynomial& p2, const double& w2, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const Polynomial& p2, const double& w2, Polynomial& q);
+#       static void AddScaled (const Polynomial& p1, const double& w1, const Polynomial& p2, Polynomial& q);
+# 
+#       void getSolutions (const double& c, std::vector<double>& roots, const double& EPS) const;
+#     };
+#   }
+# }
+###
+
+# ppolynomial.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/ppolynomial.h (1.7.2)
+# namespace pcl
+# {
+#   namespace poisson
+#   {
+#     template <int Degree> 
+#     class StartingPolynomial
+#     {
+#       public:
+#         Polynomial<Degree> p;
+#         double start;
+# 
+#         StartingPolynomial () : p (), start () {}
+# 
+#         template <int Degree2> StartingPolynomial<Degree+Degree2> operator* (const StartingPolynomial<Degree2>&p) const;
+#         StartingPolynomial scale (const double&s) const;
+#         StartingPolynomial shift (const double&t) const;
+#         int operator < (const StartingPolynomial &sp) const;
+#         static int Compare (const void *v1,const void *v2);
+#     };
+# 
+#     template <int Degree> 
+#     class PPolynomial
+#     {
+#       public:
+#         size_t polyCount;
+#         StartingPolynomial<Degree>*polys;
+# 
+#         PPolynomial (void);
+#         PPolynomial (const PPolynomial<Degree>&p);
+#         ~PPolynomial (void);
+# 
+#         PPolynomial& operator = (const PPolynomial&p);
+# 
+#         int size (void) const;
+# 
+#         void set (const size_t&size);
+#         // Note: this method will sort the elements in sps
+#         void set (StartingPolynomial<Degree>*sps,const int&count);
+#         void reset (const size_t&newSize);
+# 
+# 
+#         double operator() (const double &t) const;
+#         double integral (const double &tMin,const double &tMax) const;
+#         double Integral (void) const;
+# 
+#         template <int Degree2> PPolynomial<Degree>& operator = (const PPolynomial<Degree2>&p);
+# 
+#         PPolynomial operator + (const PPolynomial&p) const;
+#         PPolynomial operator - (const PPolynomial &p) const;
+# 
+#         template <int Degree2> PPolynomial<Degree+Degree2> operator * (const Polynomial<Degree2> &p) const;
+# 
+#         template <int Degree2> PPolynomial<Degree+Degree2> operator* (const PPolynomial<Degree2>&p) const;
+# 
+# 
+#         PPolynomial& operator += (const double&s);
+#         PPolynomial& operator -= (const double&s);
+#         PPolynomial& operator *= (const double&s);
+#         PPolynomial& operator /= (const double&s);
+#         PPolynomial operator +  (const double&s) const;
+#         PPolynomial operator -  (const double&s) const;
+#         PPolynomial operator*  (const double&s) const;
+#         PPolynomial operator /  (const double &s) const;
+# 
+#         PPolynomial& addScaled (const PPolynomial &poly,const double &scale);
+# 
+#         PPolynomial scale (const double &s) const;
+#         PPolynomial shift (const double &t) const;
+# 
+#         PPolynomial<Degree-1> derivative (void) const;
+#         PPolynomial<Degree+1> integral (void) const;
+# 
+#         void getSolutions (const double &c,
+#                            std::vector<double> &roots,
+#                            const double &EPS,
+#                            const double &min =- DBL_MAX,
+#                            const double &max=DBL_MAX) const;
+# 
+#         void printnl (void) const;
+# 
+#         PPolynomial<Degree+1> MovingAverage (const double &radius);
+# 
+#         static PPolynomial ConstantFunction (const double &width=0.5);
+#         static PPolynomial GaussianApproximation (const double &width=0.5);
+#         void write (FILE *fp,
+#                     const int &samples,
+#                     const double &min,
+#                     const double &max) const;
+#     };
+# 
+# 
+#   }
+# }
+###
+
+# qhull.h
+# 
+# #if defined __GNUC__
+# #  pragma GCC system_header 
+# #endif
+# 
+# extern "C"
+# {
+# #ifdef HAVE_QHULL_2011
+# #  include "libqhull/libqhull.h"
+# #  include "libqhull/mem.h"
+# #  include "libqhull/qset.h"
+# #  include "libqhull/geom.h"
+# #  include "libqhull/merge.h"
+# #  include "libqhull/poly.h"
+# #  include "libqhull/io.h"
+# #  include "libqhull/stat.h"
+# #else
+# #  include "qhull/qhull.h"
+# #  include "qhull/mem.h"
+# #  include "qhull/qset.h"
+# #  include "qhull/geom.h"
+# #  include "qhull/merge.h"
+# #  include "qhull/poly.h"
+# #  include "qhull/io.h"
+# #  include "qhull/stat.h"
+# #endif
+# }
+# 
+###
+
+# simplification_remove_unused_vertices.h
+# namespace pcl
+# {
+#   namespace surface
+#   {
+#     class PCL_EXPORTS SimplificationRemoveUnusedVertices
+#     {
+#       public:
+#         /** \brief Constructor. */
+#         SimplificationRemoveUnusedVertices () {};
+#         /** \brief Destructor. */
+#         ~SimplificationRemoveUnusedVertices () {};
+# 
+#         /** \brief Simply a polygonal mesh.
+#           * \param[in] input the input mesh
+#           * \param[out] output the output mesh
+#           */
+#         inline void
+#         simplify (const pcl::PolygonMesh& input, pcl::PolygonMesh& output)
+#         {
+#           std::vector<int> indices;
+#           simplify (input, output, indices);
+#         }
+# 
+#         /** \brief Perform simplification (remove unused vertices).
+#           * \param[in] input the input mesh
+#           * \param[out] output the output mesh
+#           * \param[out] indices the resultant vector of indices
+#           */
+#         void
+#         simplify (const pcl::PolygonMesh& input, pcl::PolygonMesh& output, std::vector<int>& indices);
+# 
+#     };
+#   }
+###
+
+# sparse_matrix.h
+# pcl/surface/3rdparty/poisson4/sparse_matrix.h (1.7.2)
+# 
+# namespace pcl 
+# namespace poisson 
+# template <class T>
+# struct MatrixEntry
+#     {
+#       MatrixEntry () : N (-1), Value (0) {}
+#       MatrixEntry (int i) : N (i), Value (0) {}
+#       int N;
+#       T Value;
+#     };
+# 
+#     template <class T,int Dim>
+#     struct NMatrixEntry
+#     {
+#       NMatrixEntry () : N (-1), Value () { memset (Value, 0, sizeof (T) * Dim); }
+#       NMatrixEntry (int i) : N (i), Value () { memset (Value, 0, sizeof (T) * Dim); }
+#       int N;
+#       T Value[Dim];
+#     };
+# 
+#     template<class T> class SparseMatrix
+#     {
+#       private:
+#         static int UseAlloc;
+#       public:
+#         static Allocator<MatrixEntry<T> > AllocatorMatrixEntry;
+#         static int UseAllocator (void);
+#         static void SetAllocator (const int& blockSize);
+# 
+#         int rows;
+#         int* rowSizes;
+#         MatrixEntry<T>** m_ppElements;
+# 
+#         SparseMatrix ();
+#         SparseMatrix (int rows);
+#         void Resize (int rows);
+#         void SetRowSize (int row , int count);
+#         int Entries (void);
+# 
+#         SparseMatrix (const SparseMatrix& M);
+#         virtual ~SparseMatrix ();
+# 
+#         void SetZero ();
+#         void SetIdentity ();
+# 
+#         SparseMatrix<T>& operator = (const SparseMatrix<T>& M);
+# 
+#         SparseMatrix<T> operator * (const T& V) const;
+#         SparseMatrix<T>& operator *= (const T& V);
+# 
+# 
+#         SparseMatrix<T> operator * (const SparseMatrix<T>& M) const;
+#         SparseMatrix<T> Multiply (const SparseMatrix<T>& M) const;
+#         SparseMatrix<T> MultiplyTranspose (const SparseMatrix<T>& Mt) const;
+# 
+#         template<class T2>
+#         Vector<T2> operator * (const Vector<T2>& V) const;
+#         template<class T2>
+#         Vector<T2> Multiply (const Vector<T2>& V) const;
+#         template<class T2>
+#         void Multiply (const Vector<T2>& In, Vector<T2>& Out) const;
+# 
+# 
+#         SparseMatrix<T> Transpose() const;
+# 
+#         static int Solve (const SparseMatrix<T>& M,
+#                           const Vector<T>& b,
+#                           const int& iters,
+#                           Vector<T>& solution,
+#                           const T eps = 1e-8);
+# 
+#         template<class T2>
+#         static int SolveSymmetric (const SparseMatrix<T>& M,
+#                                    const Vector<T2>& b,
+#                                    const int& iters,
+#                                    Vector<T2>& solution,
+#                                    const T2 eps = 1e-8,
+#                                    const int& reset=1);
+# 
+#     };
+# 
+#     template<class T,int Dim> class SparseNMatrix
+#     {
+#       private:
+#         static int UseAlloc;
+#       public:
+#         static Allocator<NMatrixEntry<T,Dim> > AllocatorNMatrixEntry;
+#         static int UseAllocator (void);
+#         static void SetAllocator (const int& blockSize);
+# 
+#         int rows;
+#         int* rowSizes;
+#         NMatrixEntry<T,Dim>** m_ppElements;
+# 
+#         SparseNMatrix ();
+#         SparseNMatrix (int rows);
+#         void Resize (int rows);
+#         void SetRowSize (int row, int count);
+#         int Entries ();
+# 
+#         SparseNMatrix (const SparseNMatrix& M);
+#         ~SparseNMatrix ();
+# 
+#         SparseNMatrix& operator = (const SparseNMatrix& M);
+# 
+#         SparseNMatrix  operator *  (const T& V) const;
+#         SparseNMatrix& operator *= (const T& V);
+# 
+#         template<class T2>
+#         NVector<T2,Dim> operator * (const Vector<T2>& V) const;
+#         template<class T2>
+#         Vector<T2> operator * (const NVector<T2,Dim>& V) const;
+#     };
+# 
+#     template <class T>
+#     class SparseSymmetricMatrix : public SparseMatrix<T>
+#     {
+#       public:
+#         virtual ~SparseSymmetricMatrix () {}
+# 
+#         template<class T2>
+#         Vector<T2> operator * (const Vector<T2>& V) const;
+# 
+#         template<class T2>
+#         Vector<T2> Multiply (const Vector<T2>& V ) const;
+# 
+#         template<class T2> void 
+#         Multiply (const Vector<T2>& In, Vector<T2>& Out ) const;
+# 
+#         template<class T2> static int 
+#         Solve (const SparseSymmetricMatrix<T>& M,
+#                const Vector<T2>& b,
+#                const int& iters,
+#                Vector<T2>& solution,
+#                const T2 eps = 1e-8,
+#                const int& reset=1);
+# 
+#         template<class T2> static int 
+#         Solve (const SparseSymmetricMatrix<T>& M,
+#                const Vector<T>& diagonal,
+#                const Vector<T2>& b,
+#                const int& iters,
+#                Vector<T2>& solution,
+#                const T2 eps = 1e-8,
+#                const int& reset=1);
+#     };
+#   }
+# 
+###
+
+# surfel_smoothing.h
+# namespace pcl
+# {
+#   template <typename PointT, typename PointNT>
+#   class SurfelSmoothing : public PCLBase<PointT>
+#   {
+#     using PCLBase<PointT>::input_;
+#     using PCLBase<PointT>::initCompute;
+# 
+#     public:
+#       typedef pcl::PointCloud<PointT> PointCloudIn;
+#       typedef typename pcl::PointCloud<PointT>::Ptr PointCloudInPtr;
+#       typedef pcl::PointCloud<PointNT> NormalCloud;
+#       typedef typename pcl::PointCloud<PointNT>::Ptr NormalCloudPtr;
+#       typedef pcl::search::Search<PointT> CloudKdTree;
+#       typedef typename pcl::search::Search<PointT>::Ptr CloudKdTreePtr;
+# 
+#       SurfelSmoothing (float a_scale = 0.01)
+#         : PCLBase<PointT> ()
+#         , scale_ (a_scale)
+#         , scale_squared_ (a_scale * a_scale)
+#         , normals_ ()
+#         , interm_cloud_ ()
+#         , interm_normals_ ()
+#         , tree_ ()
+#       {
+#       }
+# 
+#       void
+#       setInputNormals (NormalCloudPtr &a_normals) { normals_ = a_normals; };
+# 
+#       void
+#       setSearchMethod (const CloudKdTreePtr &a_tree) { tree_ = a_tree; };
+# 
+#       bool
+#       initCompute ();
+# 
+#       float
+#       smoothCloudIteration (PointCloudInPtr &output_positions,
+#                             NormalCloudPtr &output_normals);
+# 
+#       void
+#       computeSmoothedCloud (PointCloudInPtr &output_positions,
+#                             NormalCloudPtr &output_normals);
+# 
+# 
+#       void
+#       smoothPoint (size_t &point_index,
+#                    PointT &output_point,
+#                    PointNT &output_normal);
+# 
+#       void
+#       extractSalientFeaturesBetweenScales (PointCloudInPtr &cloud2,
+#                                            NormalCloudPtr &cloud2_normals,
+#                                            boost::shared_ptr<std::vector<int> > &output_features);
+# 
+#     private:
+#       float scale_, scale_squared_;
+#       NormalCloudPtr normals_;
+# 
+#       PointCloudInPtr interm_cloud_;
+#       NormalCloudPtr interm_normals_;
+# 
+#       CloudKdTreePtr tree_;
+# 
+#   };
+###
+
+# texture_mapping.h
+# namespace pcl
+# {
+#   namespace texture_mapping
+#   {
+#         
+#     /** \brief Structure to store camera pose and focal length. */
+#     struct Camera
+#     {
+#       Camera () : pose (), focal_length (), height (), width (), texture_file () {}
+#       Eigen::Affine3f pose;
+#       double focal_length;
+#       double height;
+#       double width;
+#       std::string texture_file;
+# 
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#     };
+# 
+#     /** \brief Structure that links a uv coordinate to its 3D point and face.
+#       */
+#     struct UvIndex
+#     {
+#       UvIndex () : idx_cloud (), idx_face () {}
+#       int idx_cloud; // Index of the PointXYZ in the camera's cloud
+#       int idx_face; // Face corresponding to that projection
+#     };
+#     
+#     typedef std::vector<Camera, Eigen::aligned_allocator<Camera> > CameraVector;
+#     
+#   }
+#   
+#   /** \brief The texture mapping algorithm
+#     * \author Khai Tran, Raphael Favier
+#     * \ingroup surface
+#     */
+#   template<typename PointInT>
+#   class TextureMapping
+#   {
+#     public:
+#      
+#       typedef boost::shared_ptr< PointInT > Ptr;
+#       typedef boost::shared_ptr< const PointInT > ConstPtr;
+# 
+#       typedef pcl::PointCloud<PointInT> PointCloud;
+#       typedef typename PointCloud::Ptr PointCloudPtr;
+#       typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+# 
+#       typedef pcl::octree::OctreePointCloudSearch<PointInT> Octree;
+#       typedef typename Octree::Ptr OctreePtr;
+#       typedef typename Octree::ConstPtr OctreeConstPtr;
+#       
+#       typedef pcl::texture_mapping::Camera Camera;
+#       typedef pcl::texture_mapping::UvIndex UvIndex;
+# 
+#       /** \brief Constructor. */
+#       TextureMapping () :
+#         f_ (), vector_field_ (), tex_files_ (), tex_material_ ()
+#       {
+#       }
+# 
+#       /** \brief Destructor. */
+#       ~TextureMapping ()
+#       {
+#       }
+# 
+#       /** \brief Set mesh scale control
+#         * \param[in] f
+#         */
+#       inline void
+#       setF (float f)
+#       {
+#         f_ = f;
+#       }
+# 
+#       /** \brief Set vector field
+#         * \param[in] x data point x
+#         * \param[in] y data point y
+#         * \param[in] z data point z
+#         */
+#       inline void
+#       setVectorField (float x, float y, float z)
+#       {
+#         vector_field_ = Eigen::Vector3f (x, y, z);
+#         // normalize vector field
+#         vector_field_ = vector_field_ / std::sqrt (vector_field_.dot (vector_field_));
+#       }
+# 
+#       /** \brief Set texture files
+#         * \param[in] tex_files list of texture files
+#         */
+#       inline void
+#       setTextureFiles (std::vector<std::string> tex_files)
+#       {
+#         tex_files_ = tex_files;
+#       }
+# 
+#       /** \brief Set texture materials
+#         * \param[in] tex_material texture material
+#         */
+#       inline void
+#       setTextureMaterials (TexMaterial tex_material)
+#       {
+#         tex_material_ = tex_material;
+#       }
+# 
+#       /** \brief Map texture to a mesh synthesis algorithm
+#         * \param[in] tex_mesh texture mesh
+#         */
+#       void
+#       mapTexture2Mesh (pcl::TextureMesh &tex_mesh);
+# 
+#       /** \brief map texture to a mesh UV mapping
+#         * \param[in] tex_mesh texture mesh
+#         */
+#       void
+#       mapTexture2MeshUV (pcl::TextureMesh &tex_mesh);
+# 
+#       /** \brief map textures aquired from a set of cameras onto a mesh.
+#         * \details With UV mapping, the mesh must be divided into NbCamera + 1 sub-meshes.
+#         * Each sub-mesh corresponding to the faces visible by one camera. The last submesh containing all non-visible faces
+#         * \param[in] tex_mesh texture mesh
+#         * \param[in] cams cameras used for UV mapping
+#         */
+#       void
+#       mapMultipleTexturesToMeshUV (pcl::TextureMesh &tex_mesh, 
+#                                    pcl::texture_mapping::CameraVector &cams);
+# 
+#       /** \brief computes UV coordinates of point, observed by one particular camera
+#         * \param[in] pt XYZ point to project on camera plane
+#         * \param[in] cam the camera used for projection
+#         * \param[out] UV_coordinates the resulting uv coordinates. Set to (-1.0,-1.0) if the point is not visible by the camera
+#         * \returns false if the point is not visible by the camera
+#         */
+#       inline bool
+#       getPointUVCoordinates (const pcl::PointXYZ &pt, const Camera &cam, Eigen::Vector2f &UV_coordinates)
+#       {
+#         // if the point is in front of the camera
+#         if (pt.z > 0)
+#         {
+#           // compute image center and dimension
+#           double sizeX = cam.width;
+#           double sizeY = cam.height;
+#           double cx = (sizeX) / 2.0;
+#           double cy = (sizeY) / 2.0;
+# 
+#           double focal_x = cam.focal_length;
+#           double focal_y = cam.focal_length;
+# 
+#           // project point on image frame
+#           UV_coordinates[0] = static_cast<float> ((focal_x * (pt.x / pt.z) + cx) / sizeX); //horizontal
+#           UV_coordinates[1] = 1.0f - static_cast<float> (((focal_y * (pt.y / pt.z) + cy) / sizeY)); //vertical
+# 
+#           // point is visible!
+#           if (UV_coordinates[0] >= 0.0 && UV_coordinates[0] <= 1.0 && UV_coordinates[1] >= 0.0 && UV_coordinates[1]
+#                                                                                                                  <= 1.0)
+#             return (true);
+#         }
+# 
+#         // point is NOT visible by the camera
+#         UV_coordinates[0] = -1.0;
+#         UV_coordinates[1] = -1.0;
+#         return (false);
+#       }
+# 
+#       /** \brief Check if a point is occluded using raycasting on octree.
+#         * \param[in] pt XYZ from which the ray will start (toward the camera)
+#         * \param[in] octree the octree used for raycasting. It must be initialized with a cloud transformed into the camera's frame
+#         * \returns true if the point is occluded.
+#         */
+#       inline bool
+#       isPointOccluded (const pcl::PointXYZ &pt, const OctreePtr octree);
+# 
+#       /** \brief Remove occluded points from a point cloud
+#         * \param[in] input_cloud the cloud on which to perform occlusion detection
+#         * \param[out] filtered_cloud resulting cloud, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         * \param[out] visible_indices will contain indices of visible points
+#         * \param[out] occluded_indices will contain indices of occluded points
+#         */
+#       void
+#       removeOccludedPoints (const PointCloudPtr &input_cloud,
+#                             PointCloudPtr &filtered_cloud, const double octree_voxel_size,
+#                             std::vector<int> &visible_indices, std::vector<int> &occluded_indices);
+# 
+#       /** \brief Remove occluded points from a textureMesh
+#         * \param[in] tex_mesh input mesh, on witch to perform occlusion detection
+#         * \param[out] cleaned_mesh resulting mesh, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         */
+#       void
+#       removeOccludedPoints (const pcl::TextureMesh &tex_mesh, pcl::TextureMesh &cleaned_mesh, const double octree_voxel_size);
+# 
+# 
+#       /** \brief Remove occluded points from a textureMesh
+#         * \param[in] tex_mesh input mesh, on witch to perform occlusion detection
+#         * \param[out] filtered_cloud resulting cloud, containing only visible points
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         */
+#       void
+#       removeOccludedPoints (const pcl::TextureMesh &tex_mesh, PointCloudPtr &filtered_cloud, const double octree_voxel_size);
+# 
+# 
+#       /** \brief Segment faces by camera visibility. Point-based segmentation.
+#         * \details With N camera, faces will be arranged into N+1 groups: 1 for each camera, plus 1 for faces not visible from any camera.
+#         * \param[in] tex_mesh input mesh that needs sorting. Must contain only 1 sub-mesh.
+#         * \param[in] sorted_mesh resulting mesh, will contain nbCamera + 1 sub-mesh.
+#         * \param[in] cameras vector containing the cameras used for texture mapping.
+#         * \param[in] octree_voxel_size octree resolution (in meters)
+#         * \param[out] visible_pts cloud containing only visible points
+#         */
+#       int
+#       sortFacesByCamera (pcl::TextureMesh &tex_mesh, 
+#                          pcl::TextureMesh &sorted_mesh, 
+#                          const pcl::texture_mapping::CameraVector &cameras,
+#                          const double octree_voxel_size, PointCloud &visible_pts);
+# 
+#       /** \brief Colors a point cloud, depending on its occlusions.
+#         * \details If showNbOcclusions is set to True, each point is colored depending on the number of points occluding it.
+#         * Else, each point is given a different a 0 value is not occluded, 1 if occluded.
+#         * By default, the number of occlusions is bounded to 4.
+#         * \param[in] input_cloud input cloud on which occlusions will be computed.
+#         * \param[out] colored_cloud resulting colored cloud showing the number of occlusions per point.
+#         * \param[in] octree_voxel_size octree resolution (in meters).
+#         * \param[in] show_nb_occlusions If false, color information will only represent.
+#         * \param[in] max_occlusions Limit the number of occlusions per point.
+#         */
+#       void
+#       showOcclusions (const PointCloudPtr &input_cloud, 
+#                       pcl::PointCloud<pcl::PointXYZI>::Ptr &colored_cloud,
+#                       const double octree_voxel_size, 
+#                       const bool show_nb_occlusions = true,
+#                       const int max_occlusions = 4);
+# 
+#       /** \brief Colors the point cloud of a Mesh, depending on its occlusions.
+#         * \details If showNbOcclusions is set to True, each point is colored depending on the number of points occluding it.
+#         * Else, each point is given a different a 0 value is not occluded, 1 if occluded.
+#         * By default, the number of occlusions is bounded to 4.
+#         * \param[in] tex_mesh input mesh on which occlusions will be computed.
+#         * \param[out] colored_cloud resulting colored cloud showing the number of occlusions per point.
+#         * \param[in] octree_voxel_size octree resolution (in meters).
+#         * \param[in] show_nb_occlusions If false, color information will only represent.
+#         * \param[in] max_occlusions Limit the number of occlusions per point.
+#         */
+#       void
+#       showOcclusions (pcl::TextureMesh &tex_mesh, 
+#                       pcl::PointCloud<pcl::PointXYZI>::Ptr &colored_cloud,
+#                       double octree_voxel_size, 
+#                       bool show_nb_occlusions = true, 
+#                       int max_occlusions = 4);
+# 
+#       /** \brief Segment and texture faces by camera visibility. Face-based segmentation.
+#         * \details With N camera, faces will be arranged into N+1 groups: 1 for each camera, plus 1 for faces not visible from any camera.
+#         * The mesh will also contain uv coordinates for each face
+#         * \param[in/out] tex_mesh input mesh that needs sorting. Should contain only 1 sub-mesh.
+#         * \param[in] cameras vector containing the cameras used for texture mapping.
+#         */
+#       void 
+#       textureMeshwithMultipleCameras (pcl::TextureMesh &mesh, 
+#                                       const pcl::texture_mapping::CameraVector &cameras);
+# 
+#     protected:
+#       /** \brief mesh scale control. */
+#       float f_;
+# 
+#       /** \brief vector field */
+#       Eigen::Vector3f vector_field_;
+# 
+#       /** \brief list of texture files */
+#       std::vector<std::string> tex_files_;
+# 
+#       /** \brief list of texture materials */
+#       TexMaterial tex_material_;
+# 
+#       /** \brief Map texture to a face
+#         * \param[in] p1 the first point
+#         * \param[in] p2 the second point
+#         * \param[in] p3 the third point
+#         */
+#       std::vector<Eigen::Vector2f>
+#       mapTexture2Face (const Eigen::Vector3f &p1, const Eigen::Vector3f &p2, const Eigen::Vector3f &p3);
+# 
+#       /** \brief Returns the circumcenter of a triangle and the circle's radius.
+#         * \details see http://en.wikipedia.org/wiki/Circumcenter for formulas.
+#         * \param[in] p1 first point of the triangle.
+#         * \param[in] p2 second point of the triangle.
+#         * \param[in] p3 third point of the triangle.
+#         * \param[out] circumcenter resulting circumcenter
+#         * \param[out] radius the radius of the circumscribed circle.
+#         */
+#       inline void
+#       getTriangleCircumcenterAndSize (const pcl::PointXY &p1, const pcl::PointXY &p2, const pcl::PointXY &p3, pcl::PointXY &circomcenter, double &radius);
+# 
+#       /** \brief computes UV coordinates of point, observed by one particular camera
+#         * \param[in] pt XYZ point to project on camera plane
+#         * \param[in] cam the camera used for projection
+#         * \param[out] UV_coordinates the resulting UV coordinates. Set to (-1.0,-1.0) if the point is not visible by the camera
+#         * \returns false if the point is not visible by the camera
+#         */
+#       inline bool
+#       getPointUVCoordinates (const pcl::PointXYZ &pt, const Camera &cam, pcl::PointXY &UV_coordinates);
+# 
+#       /** \brief Returns true if all the vertices of one face are projected on the camera's image plane.
+#         * \param[in] camera camera on which to project the face.
+#         * \param[in] p1 first point of the face.
+#         * \param[in] p2 second point of the face.
+#         * \param[in] p3 third point of the face.
+#         * \param[out] proj1 UV coordinates corresponding to p1.
+#         * \param[out] proj2 UV coordinates corresponding to p2.
+#         * \param[out] proj3 UV coordinates corresponding to p3.
+#         */
+#       inline bool
+#       isFaceProjected (const Camera &camera, 
+#                        const pcl::PointXYZ &p1, const pcl::PointXYZ &p2, const pcl::PointXYZ &p3, 
+#                        pcl::PointXY &proj1, pcl::PointXY &proj2, pcl::PointXY &proj3);
+# 
+#       /** \brief Returns True if a point lays within a triangle
+#         * \details see http://www.blackpawn.com/texts/pointinpoly/default.html
+#         * \param[in] p1 first point of the triangle.
+#         * \param[in] p2 second point of the triangle.
+#         * \param[in] p3 third point of the triangle.
+#         * \param[in] pt the querry point.
+#         */
+#       inline bool
+#       checkPointInsideTriangle (const pcl::PointXY &p1, const pcl::PointXY &p2, const pcl::PointXY &p3, const pcl::PointXY &pt);
+# 
+#       /** \brief Class get name method. */
+#       std::string
+#       getClassName () const
+#       {
+#         return ("TextureMapping");
+#       }
+# 
+#     public:
+#       EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+#   };
+# 
+###
+
+# vector.h (1.6.0)
+# pcl/surface/3rdparty/poisson4/vector.h (1.7.2)
+# namespace pcl {
+# namespace poisson {
+# 
+#     template<class T>
+#     class Vector
+#     {
+#     public:
+#       Vector ();
+#       Vector (const Vector<T>& V);
+#       Vector (size_t N);
+#       Vector (size_t N, T* pV);
+#       ~Vector();
+# 
+#       const T& operator () (size_t i) const;
+#       T& operator () (size_t i);
+#       const T& operator [] (size_t i) const;
+#       T& operator [] (size_t i);
+# 
+#       void SetZero();
+# 
+#       size_t Dimensions() const;
+#       void Resize( size_t N );
+# 
+#       Vector operator * (const T& A) const;
+#       Vector operator / (const T& A) const;
+#       Vector operator - (const Vector& V) const;
+#       Vector operator + (const Vector& V) const;
+# 
+#       Vector& operator *= (const T& A);
+#       Vector& operator /= (const T& A);
+#       Vector& operator += (const Vector& V);
+#       Vector& operator -= (const Vector& V);
+# 
+#       Vector& AddScaled (const Vector& V,const T& scale);
+#       Vector& SubtractScaled (const Vector& V,const T& scale);
+#       static void Add (const Vector& V1,const T& scale1,const Vector& V2,const T& scale2,Vector& Out);
+#       static void Add (const Vector& V1,const T& scale1,const Vector& V2,Vector& Out);
+# 
+#       Vector operator - () const;
+# 
+#       Vector& operator = (const Vector& V);
+# 
+#       T Dot (const Vector& V) const;
+# 
+#       T Length() const;
+# 
+#       T Norm (size_t Ln) const;
+#       void Normalize();
+# 
+#       T* m_pV;
+#     protected:
+#       size_t m_N;
+# 
+#     };
+# 
+#     template<class T,int Dim>
+#     class NVector
+#     {
+#     public:
+#       NVector ();
+#       NVector (const NVector& V);
+#       NVector (size_t N);
+#       NVector (size_t N, T* pV);
+#       ~NVector ();
+# 
+#       const T* operator () (size_t i) const;
+#       T* operator () (size_t i);
+#       const T* operator [] (size_t i) const;
+#       T* operator [] (size_t i);
+# 
+#       void SetZero();
+# 
+#       size_t Dimensions() const;
+#       void Resize( size_t N );
+# 
+#       NVector operator * (const T& A) const;
+#       NVector operator / (const T& A) const;
+#       NVector operator - (const NVector& V) const;
+#       NVector operator + (const NVector& V) const;
+# 
+#       NVector& operator *= (const T& A);
+#       NVector& operator /= (const T& A);
+#       NVector& operator += (const NVector& V);
+#       NVector& operator -= (const NVector& V);
+# 
+#       NVector& AddScaled (const NVector& V,const T& scale);
+#       NVector& SubtractScaled (const NVector& V,const T& scale);
+#       static void Add (const NVector& V1,const T& scale1,const NVector& V2,const T& scale2,NVector& Out);
+#       static void Add (const NVector& V1,const T& scale1,const NVector& V2, NVector& Out);
+# 
+#       NVector operator - () const;
+# 
+#       NVector& operator = (const NVector& V);
+# 
+#       T Dot (const NVector& V) const;
+# 
+#       T Length () const;
+# 
+#       T Norm (size_t Ln) const;
+#       void Normalize ();
+# 
+#       T* m_pV;
+#     protected:
+#       size_t m_N;
+# 
+#     };
+# 
+#   }
+# }
+###
+
+# vtk.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_smoothing.h (1.7.2)
+# #include <vtkPolyData.h>
+# #include <vtkSmartPointer.h>
+###
+
+# pcl\surface\vtk_smoothing\vtk_mesh_quadric_decimation.h (1.7.2)
+
+# vtk_mesh_smoothing_laplacian.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_smoothing_laplacian.h (1.7.2)
+# namespace pcl
+# {
+#   /** \brief PCL mesh smoothing based on the vtkSmoothPolyDataFilter algorithm from the VTK library.
+#     * Please check out the original documentation for more details on the inner workings of the algorithm
+#     * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#     * data structure to the vtkPolyData data structure and back.
+#     */
+#   class PCL_EXPORTS MeshSmoothingLaplacianVTK : public MeshProcessing
+#   {
+#     public:
+#       /** \brief Empty constructor that sets the values of the algorithm parameters to the VTK defaults */
+#       MeshSmoothingLaplacianVTK ()
+#         : MeshProcessing ()
+#         , vtk_polygons_ ()
+#         , num_iter_ (20)
+#         , convergence_ (0.0f)
+#         , relaxation_factor_ (0.01f)
+#         , feature_edge_smoothing_ (false)
+#         , feature_angle_ (45.f)
+#         , edge_angle_ (15.f)
+#         , boundary_smoothing_ (true)
+#       {};
+# 
+#       /** \brief Set the number of iterations for the smoothing filter.
+#         * \param[in] num_iter the number of iterations
+#         */
+#       inline void
+#       setNumIter (int num_iter)
+#       {
+#         num_iter_ = num_iter;
+#       };
+# 
+#       /** \brief Get the number of iterations. */
+#       inline int
+#       getNumIter ()
+#       {
+#         return num_iter_;
+#       };
+# 
+#       /** \brief Specify a convergence criterion for the iteration process. Smaller numbers result in more smoothing iterations.
+#        * \param[in] convergence convergence criterion for the Laplacian smoothing
+#        */
+#       inline void
+#       setConvergence (float convergence)
+#       {
+#         convergence_ = convergence;
+#       };
+# 
+#       /** \brief Get the convergence criterion. */
+#       inline float
+#       getConvergence ()
+#       {
+#         return convergence_;
+#       };
+# 
+#       /** \brief Specify the relaxation factor for Laplacian smoothing. As in all iterative methods,
+#        * the stability of the process is sensitive to this parameter.
+#        * In general, small relaxation factors and large numbers of iterations are more stable than larger relaxation
+#        * factors and smaller numbers of iterations.
+#        * \param[in] relaxation_factor the relaxation factor of the Laplacian smoothing algorithm
+#        */
+#       inline void
+#       setRelaxationFactor (float relaxation_factor)
+#       {
+#         relaxation_factor_ = relaxation_factor;
+#       };
+# 
+#       /** \brief Get the relaxation factor of the Laplacian smoothing */
+#       inline float
+#       getRelaxationFactor ()
+#       {
+#         return relaxation_factor_;
+#       };
+# 
+#       /** \brief Turn on/off smoothing along sharp interior edges.
+#        * \param[in] status decision whether to enable/disable smoothing along sharp interior edges
+#        */
+#       inline void
+#       setFeatureEdgeSmoothing (bool feature_edge_smoothing)
+#       {
+#         feature_edge_smoothing_ = feature_edge_smoothing;
+#       };
+# 
+#       /** \brief Get the status of the feature edge smoothing */
+#       inline bool
+#       getFeatureEdgeSmoothing ()
+#       {
+#         return feature_edge_smoothing_;
+#       };
+# 
+#       /** \brief Specify the feature angle for sharp edge identification.
+#        * \param[in] feature_angle the angle threshold for considering an edge to be sharp
+#        */
+#       inline void
+#       setFeatureAngle (float feature_angle)
+#       {
+#         feature_angle_ = feature_angle;
+#       };
+# 
+#       /** \brief Get the angle threshold for considering an edge to be sharp */
+#       inline float
+#       getFeatureAngle ()
+#       {
+#         return feature_angle_;
+#       };
+# 
+#       /** \brief Specify the edge angle to control smoothing along edges (either interior or boundary).
+#        * \param[in] edge_angle the angle to control smoothing along edges
+#        */
+#       inline void
+#       setEdgeAngle (float edge_angle)
+#       {
+#         edge_angle_ = edge_angle;
+#       };
+# 
+#       /** \brief Get the edge angle to control smoothing along edges */
+#       inline float
+#       getEdgeAngle ()
+#       {
+#         return edge_angle_;
+#       };
+# 
+#       /** \brief Turn on/off the smoothing of vertices on the boundary of the mesh.
+#        * \param[in] boundary_smoothing decision whether boundary smoothing is on or off
+#        */
+#       inline void
+#       setBoundarySmoothing (bool boundary_smoothing)
+#       {
+#         boundary_smoothing_ = boundary_smoothing;
+#       };
+# 
+#       /** \brief Get the status of the boundary smoothing */
+#       inline bool
+#       getBoundarySmoothing ()
+#       {
+#         return boundary_smoothing_;
+#       }
+# 
+#     protected:
+#       void
+#       performProcessing (pcl::PolygonMesh &output);
+# 
+#     private:
+#       vtkSmartPointer<vtkPolyData> vtk_polygons_;
+# 
+#       /// Parameters
+#       int num_iter_;
+#       float convergence_;
+#       float relaxation_factor_;
+#       bool feature_edge_smoothing_;
+#       float feature_angle_;
+#       float edge_angle_;
+#       bool boundary_smoothing_;
+#   };
+###
+
+# vtk_mesh_smoothing_windowed_sinc.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_smoothing_windowed_sinc.h (1.7.2)
+# namespace pcl
+# /** \brief PCL mesh smoothing based on the vtkWindowedSincPolyDataFilter algorithm from the VTK library.
+#   * Please check out the original documentation for more details on the inner workings of the algorithm
+#   * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#   * data structure to the vtkPolyData data structure and back.
+#   */
+# class PCL_EXPORTS MeshSmoothingWindowedSincVTK : public MeshProcessing
+#       public:
+#       /** \brief Empty constructor that sets the values of the algorithm parameters to the VTK defaults */
+#       MeshSmoothingWindowedSincVTK ()
+#         : MeshProcessing (),
+#           num_iter_ (20),
+#           pass_band_ (0.1f),
+#           feature_edge_smoothing_ (false),
+#           feature_angle_ (45.f),
+#           edge_angle_ (15.f),
+#           boundary_smoothing_ (true),
+#           normalize_coordinates_ (false)
+#       {};
+# 
+#       /** \brief Set the number of iterations for the smoothing filter.
+#         * \param[in] num_iter the number of iterations
+#       inline void setNumIter (int num_iter)
+#       /** \brief Get the number of iterations. */
+#       inline int getNumIter ()
+#       /** \brief Set the pass band value for windowed sinc filtering.
+#         * \param[in] pass_band value for the pass band.
+#       inline void setPassBand (float pass_band)
+#       /** \brief Get the pass band value. */
+#       inline float getPassBand ()
+#       /** \brief Turn on/off coordinate normalization. The positions can be translated and scaled such that they fit
+#        * within a [-1, 1] prior to the smoothing computation. The default is off. The numerical stability of the
+#        * solution can be improved by turning normalization on. If normalization is on, the coordinates will be rescaled
+#        * to the original coordinate system after smoothing has completed.
+#        * \param[in] normalize_coordinates decision whether to normalize coordinates or not
+#       inline void setNormalizeCoordinates (bool normalize_coordinates)
+#       /** \brief Get whether the coordinate normalization is active or not */
+#       inline bool getNormalizeCoordinates ()
+#       /** \brief Turn on/off smoothing along sharp interior edges.
+#        * \param[in] status decision whether to enable/disable smoothing along sharp interior edges
+#       inline void setFeatureEdgeSmoothing (bool feature_edge_smoothing)
+#       /** \brief Get the status of the feature edge smoothing */
+#       inline bool getFeatureEdgeSmoothing ()
+#       /** \brief Specify the feature angle for sharp edge identification.
+#        * \param[in] feature_angle the angle threshold for considering an edge to be sharp
+#       inline void setFeatureAngle (float feature_angle)
+#       /** \brief Get the angle threshold for considering an edge to be sharp */
+#       inline float getFeatureAngle ()
+#       /** \brief Specify the edge angle to control smoothing along edges (either interior or boundary).
+#        * \param[in] edge_angle the angle to control smoothing along edges
+#       inline void setEdgeAngle (float edge_angle)
+#       /** \brief Get the edge angle to control smoothing along edges */
+#       inline float getEdgeAngle ()
+#       /** \brief Turn on/off the smoothing of vertices on the boundary of the mesh.
+#        * \param[in] boundary_smoothing decision whether boundary smoothing is on or off
+#       inline void setBoundarySmoothing (bool boundary_smoothing)
+#       /** \brief Get the status of the boundary smoothing */
+#       inline bool getBoundarySmoothing ()
+#       protected:
+#       void performProcessing (pcl::PolygonMesh &output);
+###
+
+# vtk_mesh_subdivision.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_mesh_subdivision.h (1.7.2)
+# namespace pcl
+# /** \brief PCL mesh smoothing based on the vtkLinearSubdivisionFilter, vtkLoopSubdivisionFilter, vtkButterflySubdivisionFilter
+#   * depending on the selected MeshSubdivisionVTKFilterType algorithm from the VTK library.
+#   * Please check out the original documentation for more details on the inner workings of the algorithm
+#   * Warning: This wrapper does two fairly computationally expensive conversions from the PCL PolygonMesh
+#   * data structure to the vtkPolyData data structure and back.
+#   */
+# class PCL_EXPORTS MeshSubdivisionVTK : public MeshProcessing
+#       public:
+#       /** \brief Empty constructor */
+#       MeshSubdivisionVTK ();
+#       enum MeshSubdivisionVTKFilterType
+#       { LINEAR, LOOP, BUTTERFLY };
+#       /** \brief Set the mesh subdivision filter type
+#         * \param[in] type the filter type
+#       inline void setFilterType (MeshSubdivisionVTKFilterType type)
+#       /** \brief Get the mesh subdivision filter type */
+#       inline MeshSubdivisionVTKFilterType getFilterType ()
+#       protected:
+#       void performProcessing (pcl::PolygonMesh &output);
+###
+
+# vtk_utils.h (1.6.0)
+# pcl\surface\vtk_smoothing\vtk_utils.h (1.7.2)
+# namespace pcl
+# class PCL_EXPORTS VTKUtils
+#       public:
+#       /** \brief Convert a PCL PolygonMesh to a VTK vtkPolyData.
+#         * \param[in] triangles PolygonMesh to be converted to vtkPolyData, stored in the object.
+#         */
+#       static int
+#       convertToVTK (const pcl::PolygonMesh &triangles, vtkSmartPointer<vtkPolyData> &triangles_out_vtk);
+#       /** \brief Convert the vtkPolyData object back to PolygonMesh.
+#         * \param[out] triangles the PolygonMesh to store the vtkPolyData in.
+#         */
+#       static void
+#       convertToPCL (vtkSmartPointer<vtkPolyData> &vtk_polygons, pcl::PolygonMesh &triangles);
+#       /** \brief Convert vtkPolyData object to a PCL PolygonMesh
+#         * \param[in] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#         * \param[out] mesh PCL Polygon Mesh to fill
+#         * \return Number of points in the point cloud of mesh.
+#         */
+#       static int
+#       vtk2mesh (const vtkSmartPointer<vtkPolyData>& poly_data, pcl::PolygonMesh& mesh);
+#       /** \brief Convert a PCL PolygonMesh to a vtkPolyData object
+#         * \param[in] mesh Reference to PCL Polygon Mesh
+#         * \param[out] poly_data Pointer (vtkSmartPointer) to a vtkPolyData object
+#         * \return Number of points in the point cloud of mesh.
+#         */
+#       static int
+#       mesh2vtk (const pcl::PolygonMesh& mesh, vtkSmartPointer<vtkPolyData> &poly_data);
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
diff --git a/pcl/pcl_tracking_172.pxd b/pcl/pcl_tracking_172.pxd
new file mode 100644
index 0000000..8e67e19
--- /dev/null
+++ b/pcl/pcl_tracking_172.pxd
@@ -0,0 +1,687 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# class Tracker: public PCLBase<PointInT>
+cdef extern from "pcl/tracking/tracker.h" namespace "pcl::tracking":
+    cdef cppclass Tracker[T](cpp.PCLBase[T]):
+        Tracker ()
+        # using PCLBase<PointInT>::deinitCompute;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::input_;
+        # ctypedef PCLBase<PointInT> BaseClass;
+        # ctypedef boost::shared_ptr< Tracker<PointInT, StateT> > Ptr;
+        # ctypedef boost::shared_ptr< const Tracker<PointInT, StateT> > ConstPtr;
+        # ctypedef boost::shared_ptr<pcl::search::Search<PointInT> > SearchPtr;
+        # ctypedef boost::shared_ptr<const pcl::search::Search<PointInT> > SearchConstPtr;
+        # ctypedef pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef pcl::PointCloud<StateT> PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # public:
+        # brief Base method for tracking for all points given in 
+        # <setInputCloud (), setIndices ()> using the indices in setIndices () 
+        cdef void compute ()
+        # protected:
+        # brief The tracker name. 
+        # std::string tracker_name_;
+        # brief A pointer to the spatial search object. 
+        # SearchPtr search_;
+        # brief Get a string representation of the name of this class.
+        # cdef inline const std::string& getClassName ()
+        # brief This method should get called before starting the actual computation.
+        # cdef bool initCompute ();
+        # brief Provide a pointer to a dataset to add additional information
+        # to estimate the features for every point in the input dataset.  This
+        # is optional, if this is not set, it will only use the data in the
+        # input cloud to estimate the features.  This is useful when you only
+        # need to compute the features for a downsampled cloud.  
+        # \param cloud a pointer to a PointCloud message
+        # cdef void setSearchMethod (const SearchPtr &)
+        # brief Get a pointer to the point cloud dataset.
+        # inline SearchPtr getSearchMethod ()
+        # brief Get an instance of the result of tracking.
+        # virtual StateT getResult () const = 0;
+###
+
+cdef extern from "pcl/tracking/coherence.h" namespace "pcl::tracking":
+    cdef cppclass PointCoherence[T]:
+        PointCoherence ()
+        # public:
+        # ctypedef boost::shared_ptr< PointCoherence<PointInT> > Ptr;
+        # ctypedef boost::shared_ptr< const PointCoherence<PointInT> > ConstPtr;
+        # public:
+        # cdef double compute (PointInT &source, PointInT &target);
+        # protected:
+        # std::string coherence_name_;
+        # cdef double computeCoherence (PointInT &source, PointInT &target) = 0;
+        # cdef const std::string& getClassName () const { return (coherence_name_);
+
+###
+
+cdef extern from "pcl/tracking/coherence.h" namespace "pcl::tracking":
+    cdef cppclass PointCloudCoherence[T]:
+        PointCloudCoherence ()
+        # public:
+        # ctypedef boost::shared_ptr< PointCloudCoherence<PointInT> > Ptr;
+        # ctypedef boost::shared_ptr< const PointCloudCoherence<PointInT> > ConstPtr;
+        # ctypedef pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename PointCoherence<PointInT>::Ptr PointCoherencePtr;
+        cdef void compute (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_i);
+        # cdef vector[PointCoherencePtr] getPointCoherences ()
+        cdef void setPointCoherences (std::vector<PointCoherencePtr> coherences)
+        cdef bool initCompute ()
+        cdef void addPointCoherence (PointCoherencePtr coherence)
+        cdef void setTargetCloud (const PointCloudInConstPtr &cloud)
+        # protected:
+        # cdef void computeCoherence (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_j) = 0;
+        # cdef double calcPointCoherence (PointInT &source, PointInT &target);
+        # cdef const std::string& getClassName () const { return (coherence_name_); }
+        # std::string coherence_name_;
+        # PointCloudInConstPtr target_input_;
+        # std::vector<PointCoherencePtr> point_coherences_;
+###
+
+# class NearestPairPointCloudCoherence: public PointCloudCoherence<PointInT>
+cdef extern from "pcl/tracking/nearest_pair_point_cloud_coherence.h" namespace "pcl::tracking":
+    cdef cppclass NearestPairPointCloudCoherence[T](PointCoherence[T]):
+        NearestPairPointCloudCoherence ()
+        # public:
+        # using PointCloudCoherence<PointInT>::getClassName;
+        # using PointCloudCoherence<PointInT>::coherence_name_;
+        # using PointCloudCoherence<PointInT>::target_input_;
+        # ctypedef typename PointCloudCoherence<PointInT>::PointCoherencePtr PointCoherencePtr;
+        # ctypedef typename PointCloudCoherence<PointInT>::PointCloudInConstPtr PointCloudInConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> BaseClass;
+        # ctypedef boost::shared_ptr<NearestPairPointCloudCoherence<PointInT> > Ptr;
+        # ctypedef boost::shared_ptr<const NearestPairPointCloudCoherence<PointInT> > ConstPtr;
+        # ctypedef boost::shared_ptr<pcl::search::Search<PointInT> > SearchPtr;
+        # ctypedef boost::shared_ptr<const pcl::search::Search<PointInT> > SearchConstPtr;
+        # brief Provide a pointer to a dataset to add additional information
+        # to estimate the features for every point in the input dataset.  This
+        # is optional, if this is not set, it will only use the data in the
+        # input cloud to estimate the features.  This is useful when you only
+        # need to compute the features for a downsampled cloud. 
+        # param cloud a pointer to a PointCloud message
+        cdef void setSearchMethod (const SearchPtr &search)
+        # brief Get a pointer to the point cloud dataset.
+        # cdef SearchPtr getSearchMethod ()
+        # brief add a PointCoherence to the PointCloudCoherence.
+        # param coherence a pointer to PointCoherence.
+        cdef void setTargetCloud (const PointCloudInConstPtr &cloud)
+        # brief set maximum distance to be taken into account.
+        # param maximum distance.
+        cdef void setMaximumDistance (double )
+        # protected:
+        # using PointCloudCoherence<PointInT>::point_coherences_;
+        # brief This method should get called before starting the actual computation.
+        # virtual bool initCompute ();
+        # brief A flag which is true if target_input_ is updated
+        # bool new_target_;
+        # brief A pointer to the spatial search object.
+        # SearchPtr search_;
+        # brief max of distance for points to be taken into account
+        # double maximum_distance_;
+        # brief compute the nearest pairs and compute coherence using point_coherences_ 
+        # cdef void computeCoherence (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_j);
+
+###
+
+# class ParticleFilterTracker: public Tracker<PointInT, StateT>
+cdef extern from "pcl/tracking/particle_filter.h" namespace "pcl::tracking":
+    cdef cppclass ParticleFilterTracker[T, S](Tracker[T]):
+        ParticleFilterTracker ()
+        # protected:
+        # using Tracker<PointInT, StateT>::deinitCompute;
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::indices_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # brief set the number of iteration.
+        # param iteration_num the number of iteration.
+        cdef void setIterationNum (int )
+        # brief get the number of iteration.
+        cdef int getIterationNum ()
+        # brief set the number of the particles.
+        # param particle_num the number of the particles.
+        cdef void setParticleNum (const int )
+        # brief get the number of the particles.
+        cdef int getParticleNum ()
+        # brief set a pointer to a reference dataset to be tracked.
+        # param cloud a pointer to a PointCloud message
+        cdef void setReferenceCloud (const PointCloudInConstPtr &ref)
+        # brief get a pointer to a reference dataset to be tracked.
+        cdef PointCloudInConstPtr const getReferenceCloud ()
+        # brief set the PointCloudCoherence as likelihood.
+        # param coherence a pointer to PointCloudCoherence.
+        cdef void setCloudCoherence (const CloudCoherencePtr &coherence)
+        # brief get the PointCloudCoherence to compute likelihood.
+        cdef CloudCoherencePtr getCloudCoherence ()
+        # brief set the covariance of step noise.
+        # param step_noise_covariance the diagonal elements of covariance matrix of step noise.
+        cdef void setStepNoiseCovariance (const std::vector<double> &step_noise_covariance)
+        # brief set the covariance of the initial noise.
+        # it will be used when initializing the particles.
+        # param initial_noise_covariance the diagonal elements of covariance matrix of initial noise.
+        cdef void setInitialNoiseCovariance (const std::vector<double> &initial_noise_covariance)
+        # brief set the mean of the initial noise.
+        # it will be used when initializing the particles.
+        # param initial_noise_mean the mean values of initial noise.
+        cdef void setInitialNoiseMean (const std::vector<double> &initial_noise_mean)
+        # brief set the threshold to re-initialize the particles.
+        # param resample_likelihood_thr threshold to re-initialize.
+        cdef void setResampleLikelihoodThr (const double resample_likelihood_thr)
+        # brief set the threshold of angle to be considered occlusion (default: pi/2).
+        # ParticleFilterTracker does not take the occluded points into account according to the angle
+        # between the normal and the position. 
+        # param occlusion_angle_thr threshold of angle to be considered occlusion.
+        cdef void setOcclusionAngleThe (const double occlusion_angle_thr)
+        # brief set the minimum number of indices (default: 1).
+        # ParticleFilterTracker does not take into account the hypothesis
+        # whose the number of points is smaller than the minimum indices.
+        # param min_indices the minimum number of indices.
+        cdef void setMinIndices (const int min_indices)
+        # brief set the transformation from the world coordinates to the frame of the particles.
+        # param trans Affine transformation from the worldcoordinates to the frame of the particles.
+        cdef void setTrans (const Eigen::Affine3f &trans)
+        # brief get the transformation from the world coordinates to the frame of the particles.
+        cdef Eigen::Affine3f getTrans () const { return trans_; }
+        # brief Get an instance of the result of tracking.
+        # cdef StateT getResult () const { return representative_state_; }
+        # brief convert a state to affine transformation from the world coordinates frame.
+        # param particle an instance of StateT.
+        cdef Eigen::Affine3f toEigenMatrix (const StateT& particle)
+        # brief get a pointer to a pointcloud of the particles.
+        cdef PointCloudStatePtr getParticles ()
+        # brief normalize the weight of a particle using
+        # exp(1- alpha ( w - w_{min}) / (w_max - w_min)).
+        # this method is described in [P.Azad et. al, ICRA11].
+        # param w the weight to be normalized
+        # param w_min the minimum weight of the particles
+        # param w_max the maximum weight of the particles
+        cdef double normalizeParticleWeight (double , double , double )
+        # brief set the value of alpha.
+        # param alpha the value of alpha
+        cdef void setAlpha (double)
+        # brief get the value of alpha.
+        cdef double getAlpha ()
+        # brief set the value of use_normal_.
+        # param use_normal the value of use_normal_.
+        cdef void setUseNormal (bool)
+        # brief get the value of use_normal_.
+        cdef bool getUseNormal ()
+        # brief set the value of use_change_detector_.
+        # param use_normal the value of use_change_detector_.
+        cdef void setUseChangeDetector (bool )
+        # brief get the value of use_change_detector_.
+        cdef bool getUseChangeDetector ()
+        # brief set the motion ratio
+        # param motion_ratio the ratio of hypothesis to use motion model.
+        cdef void setMotionRatio (double )
+        # brief get the motion ratio
+        cdef double getMotionRatio ()
+        # brief set the number of interval frames to run change detection.
+        # param change_detector_interval the number of interval frames.
+        cdef void setIntervalOfChangeDetection (unsigned int )
+        # brief get the number of interval frames to run change detection.
+        cdef unsigned int getIntervalOfChangeDetection ()
+        # brief set the minimum amount of points required within leaf node to become serialized in change detection
+        # param change_detector_filter the minimum amount of points required within leaf node
+        cdef void setMinPointsOfChangeDetection (unsigned int change_detector_filter)
+        # brief set the resolution of change detection.
+        # param resolution resolution of change detection octree
+        cdef void setResolutionOfChangeDetection (double )
+        # brief get the resolution of change detection.
+        cdef double getResolutionOfChangeDetection ()
+        # brief get the minimum amount of points required within leaf node to become serialized in change detection
+        cdef unsigned int getMinPointsOfChangeDetection ()
+        # brief get the adjustment ratio.
+        cdef double getFitRatio()
+        # brief reset the particles to restart tracking
+        cdef void resetTracking ()
+        ###
+        # protected:
+        # brief compute the parameters for the bounding box of 
+        # hypothesis pointclouds.
+        # param x_min the minimum value of x axis.
+        # param x_max the maximum value of x axis.
+        # param y_min the minimum value of y axis.
+        # param y_max the maximum value of y axis.
+        # param z_min the minimum value of z axis.
+        # param z_max the maximum value of z axis.
+        cdef void calcBoundingBox (double &x_min, double &x_max,
+                              double &y_min, double &y_max,
+                              double &z_min, double &z_max);
+        # brief crop the pointcloud by the bounding box calculated
+        #  from hypothesis and the reference pointcloud.
+        # param cloud a pointer to pointcloud to be cropped.
+        # param output a pointer to be assigned the cropped pointcloud.
+        cdef void cropInputPointCloud (const PointCloudInConstPtr &cloud, PointCloudIn &output);
+
+        # brief compute a reference pointcloud transformed to the pose that
+        # hypothesis represents.
+        # param hypothesis a particle which represents a hypothesis.
+        # param indices the indices which should be taken into account.
+        # param cloud the resultant point cloud model dataset which
+        #             is transformed to hypothesis.
+        cdef void computeTransformedPointCloud (const StateT& hypothesis,
+                                           std::vector<int>& indices,
+                                           PointCloudIn &cloud);
+        # brief compute a reference pointcloud transformed to the pose that
+        # hypothesis represents and calculate indices taking occlusion into \
+        #  account.
+        # param hypothesis a particle which represents a hypothesis.
+        # param indices the indices which should be taken into account.
+        # param cloud the resultant point cloud model dataset which
+        #           is transformed to hypothesis.
+        cdef void computeTransformedPointCloudWithNormal (const StateT& hypothesis,
+                                           std::vector<int>& indices,
+                                           PointCloudIn &cloud);
+        # brief compute a reference pointcloud transformed to the pose that
+        # hypothesis represents and calculate indices without taking
+        # occlusion into account.
+        # param hypothesis a particle which represents a hypothesis.
+        # param cloud the resultant point cloud model dataset which
+        #         is transformed to hypothesis.
+        cdef void computeTransformedPointCloudWithoutNormal (const StateT& hypothesis, PointCloudIn &cloud);
+        # brief This method should get called before starting the actual computation.
+        cdef bool initCompute ()
+        # brief weighting phase of particle filter method.
+        # calculate the likelihood of all of the particles and set the weights.
+        cdef void weight ()
+        # brief resampling phase of particle filter method.
+        # sampling the particles according to the weights calculated in weight method.
+        # in particular, "sample with replacement" is archieved by walker's alias method.
+        cdef void resample ()
+        # brief calculate the weighted mean of the particles and set it as the result
+        cdef void update ()
+        # brief normalize the weights of all the particels.
+        cdef void normalizeWeight ()
+        # brief initialize the particles. initial_noise_covariance_ and initial_noise_mean_ are
+        # used for gausiaan sampling.
+        cdef void initParticles (bool reset)
+        # brief track the pointcloud using particle filter method.
+        cdef void computeTracking ()
+        # brief implementation of "sample with replacement" using Walker's alias method.
+        # about Walker's alias method, you can check the paper below:
+        # param a an alias table, which generated by genAliasTable.
+        # param q a table of weight, which generated by genAliasTable.
+        cdef int sampleWithReplacement (const std::vector<int>& a, const std::vector<double>& q)
+        # brief generate the tables for walker's alias method
+        cdef void genAliasTable (std::vector<int> &a, std::vector<double> &q, const PointCloudStateConstPtr &particles)
+        # brief resampling the particle with replacement
+        cdef void resampleWithReplacement ()
+        # brief resampling the particle in deterministic way
+        cdef void resampleDeterministic ()
+        # brief run change detection and return true if there is a change.
+        # param input a pointer to the input pointcloud.
+        cdef bool testChangeDetection (const PointCloudInConstPtr &input)
+        # the number of iteration of particlefilter.
+        # int iteration_num_;
+        # brief the number of the particles.
+        int particle_num_;
+        # brief the minimum number of points which the hypothesis should have.
+        int min_indices_;
+        # brief adjustment of the particle filter.
+        double fit_ratio_;
+        # brief a pointer to reference point cloud.
+        PointCloudInConstPtr ref_;
+        # brief a pointer to the particles
+        PointCloudStatePtr particles_;
+        # brief a pointer to PointCloudCoherence.
+        CloudCoherencePtr coherence_;
+        # brief the diagonal elements of covariance matrix of the step noise. the covariance matrix is used
+        #    at every resample method.
+        std::vector<double> step_noise_covariance_;
+        # brief the diagonal elements of covariance matrix of the initial noise. the covariance matrix is used
+        # when initialize the particles.
+        std::vector<double> initial_noise_covariance_;
+        # brief the mean values of initial noise.
+        std::vector<double> initial_noise_mean_;
+        # brief the threshold for the particles to be re-initialized
+        double resample_likelihood_thr_;
+        # brief the threshold for the points to be considered as occluded
+        double occlusion_angle_thr_;
+        # brief the weight to be used in normalization
+        #         of the weights of the particles 
+        double alpha_;
+        # brief the result of tracking.
+        StateT representative_state_;
+        # brief an affine transformation from the world coordinates frame to the origin of the particles
+        Eigen::Affine3f trans_;
+        # brief a flag to use normal or not. defaults to false
+        bool use_normal_;
+        # brief difference between the result in t and t-1
+        StateT motion_;
+        # brief ratio of hypothesis to use motion model
+        double motion_ratio_;
+        # brief pass through filter to crop the pointclouds within the hypothesis bounding box
+        pcl::PassThrough<PointInT> pass_x_;
+        # brief pass through filter to crop the pointclouds within the hypothesis bounding box
+        pcl::PassThrough<PointInT> pass_y_;
+        # brief pass through filter to crop the pointclouds within the hypothesis bounding box
+        pcl::PassThrough<PointInT> pass_z_;
+        # brief a list of the pointers to pointclouds
+        std::vector<PointCloudInPtr> transed_reference_vector_;
+        # brief change detector used as a trigger to track
+        boost::shared_ptr<pcl::octree::OctreePointCloudChangeDetector<PointInT> > change_detector_;
+        # brief a flag to be true when change of pointclouds is detected
+        bool changed_;
+        # brief a counter to skip change detection
+        unsigned int change_counter_;
+        # brief minimum points in a leaf when calling change detector. defaults to 10
+        unsigned int change_detector_filter_;
+        # brief the number of interval frame to run change detection. defaults to 10.
+        unsigned int change_detector_interval_;
+        # brief resolution of change detector. defaults to 0.01.
+        double change_detector_resolution_;
+        # brief the flag which will be true if using change detection
+        bool use_change_detector_;
+###
+
+### Inheritance ###
+
+# class ApproxNearestPairPointCloudCoherence: public NearestPairPointCloudCoherence<PointInT>
+cdef extern from "pcl/tracking/approx_nearest_pair_point_cloud_coherence.h" namespace "pcl::tracking":
+    cdef cppclass ApproxNearestPairPointCloudCoherence[T](NearestPairPointCloudCoherence[T]):
+        ApproxNearestPairPointCloudCoherence ()
+        # public:
+        # ctypedef typename NearestPairPointCloudCoherence<PointInT>::PointCoherencePtr PointCoherencePtr;
+        # ctypedef typename NearestPairPointCloudCoherence<PointInT>::PointCloudInConstPtr PointCloudInConstPtr;
+        # using NearestPairPointCloudCoherence<PointInT>::maximum_distance_;
+        # using NearestPairPointCloudCoherence<PointInT>::target_input_;
+        # using NearestPairPointCloudCoherence<PointInT>::point_coherences_;
+        # using NearestPairPointCloudCoherence<PointInT>::coherence_name_;
+        # using NearestPairPointCloudCoherence<PointInT>::new_target_;
+        # using NearestPairPointCloudCoherence<PointInT>::getClassName;
+
+        # protected:
+        # cdef bool initCompute ();
+        # cdef void computeCoherence (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_j);
+        # typename boost::shared_ptr<pcl::search::Octree<PointInT> > search_;
+
+###
+
+# class DistanceCoherence: public PointCoherence<PointInT>
+cdef extern from "pcl/tracking/distance_coherence.h" namespace "pcl::tracking":
+    cdef cppclass DistanceCoherence[T](PointCoherence[T]):
+        DistanceCoherence ()
+        cdef void setWeight (double)
+        cdef double getWeight ()
+        # protected:
+        # cdef double computeCoherence (PointInT &source, PointInT &target);
+        # double weight_;
+###
+
+cdef extern from "pcl/tracking/hsv_color_coherence.h" namespace "pcl::tracking":
+    cdef cppclass HSVColorCoherence[T]:
+        HSVColorCoherence ()
+        cdef void setWeight (double)
+        cdef double getWeight ()
+        # public:
+        cdef void setWeight (double )
+        cdef double getWeight ()
+        cdef void setHWeight (double )
+        cdef double getHWeight ()
+        cdef void setSWeight (double )
+        cdef double getSWeight ()
+        cdef void setVWeight (double )
+        cdef double getVWeight ()
+        # protected:
+        # cdef double computeCoherence (PointInT &source, PointInT &target);
+        # double weight_;
+        # double h_weight_;
+        # double s_weight_;
+        # double v_weight_;
+
+###
+
+# class KLDAdaptiveParticleFilterTracker: public ParticleFilterTracker<PointInT, StateT>
+cdef extern from "pcl/tracking/kld_adaptive_particle_filter.h" namespace "pcl::tracking":
+    cdef cppclass KLDAdaptiveParticleFilterTracker[T, S](ParticleFilterTracker[T, S]):
+        KLDAdaptiveParticleFilterTracker ()
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # using ParticleFilterTracker<PointInT, StateT>::transed_reference_vector_;
+        # using ParticleFilterTracker<PointInT, StateT>::coherence_;
+        # using ParticleFilterTracker<PointInT, StateT>::initParticles;
+        # using ParticleFilterTracker<PointInT, StateT>::weight;
+        # using ParticleFilterTracker<PointInT, StateT>::update;
+        # using ParticleFilterTracker<PointInT, StateT>::iteration_num_;
+        # using ParticleFilterTracker<PointInT, StateT>::particle_num_;
+        # using ParticleFilterTracker<PointInT, StateT>::particles_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_normal_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_resolution_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::motion_;
+        # using ParticleFilterTracker<PointInT, StateT>::motion_ratio_;
+        # using ParticleFilterTracker<PointInT, StateT>::step_noise_covariance_;
+        # using ParticleFilterTracker<PointInT, StateT>::representative_state_;
+        # using ParticleFilterTracker<PointInT, StateT>::sampleWithReplacement;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # cdef void setBinSize (const StateT& bin_size) { bin_size_ = bin_size; }
+        # cdef StateT getBinSize () const { return (bin_size_); }
+        # cdef void setMaximumParticleNum (unsigned int nr) { maximum_particle_number_ = nr; }
+        # cdef unsigned int getMaximumParticleNum () const { return (maximum_particle_number_); }
+        # cdef void setEpsilon (double eps) { epsilon_ = eps; }
+        # cdef double getEpsilon () const { return (epsilon_); }
+        #cdef void setDelta (double delta) { delta_ = delta; }
+        # brief get delta to be used in chi-squared distribution.
+        cdef double getDelta () const { return (delta_); }
+        # protected:
+        # brief return true if the two bins are equal.
+        # param a index of the bin
+        # param b index of the bin
+        # cdef bool equalBin (std::vector<int> a, std::vector<int> b)
+        # brief return upper quantile of standard normal distribution.
+        # param[in] u ratio of quantile.
+        # double normalQuantile (double u)
+        # brief calculate K-L boundary. K-L boundary follows 1/2e*chi(k-1, 1-d)^2.
+        # param[in] k the number of bins and the first parameter of chi distribution.
+        # cdef double calcKLBound (int k)
+        # brief insert a bin into the set of the bins. if that bin is already registered,
+        #   return false. if not, return true.
+        # param bin a bin to be inserted.
+        # param B a set of the bins
+        # cdef bool insertIntoBins (std::vector<int> bin, std::vector<std::vector<int> > &B);
+        # brief This method should get called before starting the actual computation.
+        # cdef bool initCompute ();
+        # brief resampling phase of particle filter method.
+        #  sampling the particles according to the weights calculated in weight method.
+        #  in particular, "sample with replacement" is archieved by walker's alias method.
+        # cdef void resample ();
+        # brief the maximum number of the particles.
+        # unsigned int maximum_particle_number_;
+        # brief error between K-L distance and MLE
+        # double epsilon_;
+        # brief probability of distance between K-L distance and MLE is less than epsilon_
+        # double delta_;
+        # brief the size of a bin.
+        # StateT bin_size_;
+###
+
+# class KLDAdaptiveParticleFilterOMPTracker: public KLDAdaptiveParticleFilterTracker<PointInT, StateT>
+cdef extern from "pcl/tracking/kld_adaptive_particle_filter_omp.h" namespace "pcl::tracking":
+    cdef cppclass KLDAdaptiveParticleFilterOMPTracker[T, S](KLDAdaptiveParticleFilterTracker[T, S]):
+        KLDAdaptiveParticleFilterOMPTracker ()
+        KLDAdaptiveParticleFilterOMPTracker (unsigned int )
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::indices_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::particles_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_detector_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_counter_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_detector_interval_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::use_change_detector_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::pass_x_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::pass_y_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::pass_z_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::alpha_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::changed_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::coherence_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::use_normal_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::particle_num_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_detector_filter_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::transed_reference_vector_;
+        # //using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::calcLikelihood;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::normalizeWeight;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::normalizeParticleWeight;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::calcBoundingBox;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        void setNumberOfThreads (unsigned int nr_threads)
+        # protected:
+        # brief The number of threads the scheduler should use.
+        # unsigned int threads_;
+        # brief weighting phase of particle filter method.
+        # calculate the likelihood of all of the particles and set the weights.
+        void weight ();
+###
+
+# class NormalCoherence: public PointCoherence<PointInT>
+cdef extern from "pcl/tracking/normal_coherence.h" namespace "pcl::tracking":
+    cdef cppclass NormalCoherence[T](ParticleFilterTracker[T, S]):
+        NormalCoherence ()
+        # brief set the weight of coherence
+        # param weight the weight of coherence
+        cdef void setWeight (double )
+        # brief get the weight of coherence
+        cdef double getWeight ()
+        # protected:
+        # brief return the normal coherence between the two points.
+        # param source instance of source point.
+        # param target instance of target point.
+        #
+        # double computeCoherence (PointInT &source, PointInT &target);
+        # double weight_;
+
+###
+
+# class ParticleFilterOMPTracker: public ParticleFilterTracker<PointInT, StateT>
+cdef extern from "pcl/tracking/particle_filter_omp.h" namespace "pcl::tracking":
+    cdef cppclass ParticleFilterOMPTracker[T, S](ParticleFilterTracker[T, S]):
+        ParticleFilterOMPTracker ()
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        ParticleFilterOMPTracker (unsigned int )
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::indices_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # using ParticleFilterTracker<PointInT, StateT>::particles_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_counter_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_interval_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::alpha_;
+        # using ParticleFilterTracker<PointInT, StateT>::changed_;
+        # using ParticleFilterTracker<PointInT, StateT>::coherence_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_normal_;
+        # using ParticleFilterTracker<PointInT, StateT>::particle_num_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_filter_;
+        # using ParticleFilterTracker<PointInT, StateT>::transed_reference_vector_;
+        # //using ParticleFilterTracker<PointInT, StateT>::calcLikelihood;
+        # using ParticleFilterTracker<PointInT, StateT>::normalizeWeight;
+        # using ParticleFilterTracker<PointInT, StateT>::normalizeParticleWeight;
+        # using ParticleFilterTracker<PointInT, StateT>::calcBoundingBox;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        void setNumberOfThreads (unsigned int nr_threads)
+        # protected:
+        # brief The number of threads the scheduler should use.
+        # unsigned int threads_;
+        # brief weighting phase of particle filter method.
+        # calculate the likelihood of all of the particles and set the weights.
+        void weight ();
+
+###
+
+cdef extern from "pcl/tracking/tracking.h" namespace "pcl::tracking":
+    # state definition
+    cdef struct ParticleXYZRPY
+    cdef struct ParticleXYR
+    # brief return the value of normal distribution
+    # mean
+    # sigma
+    cdef double sampleNormal (double , double);
+###
\ No newline at end of file
diff --git a/pcl/pcl_tracking_180.pxd b/pcl/pcl_tracking_180.pxd
new file mode 100644
index 0000000..8e67e19
--- /dev/null
+++ b/pcl/pcl_tracking_180.pxd
@@ -0,0 +1,687 @@
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# class Tracker: public PCLBase<PointInT>
+cdef extern from "pcl/tracking/tracker.h" namespace "pcl::tracking":
+    cdef cppclass Tracker[T](cpp.PCLBase[T]):
+        Tracker ()
+        # using PCLBase<PointInT>::deinitCompute;
+        # using PCLBase<PointInT>::indices_;
+        # using PCLBase<PointInT>::input_;
+        # ctypedef PCLBase<PointInT> BaseClass;
+        # ctypedef boost::shared_ptr< Tracker<PointInT, StateT> > Ptr;
+        # ctypedef boost::shared_ptr< const Tracker<PointInT, StateT> > ConstPtr;
+        # ctypedef boost::shared_ptr<pcl::search::Search<PointInT> > SearchPtr;
+        # ctypedef boost::shared_ptr<const pcl::search::Search<PointInT> > SearchConstPtr;
+        # ctypedef pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef pcl::PointCloud<StateT> PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # public:
+        # brief Base method for tracking for all points given in 
+        # <setInputCloud (), setIndices ()> using the indices in setIndices () 
+        cdef void compute ()
+        # protected:
+        # brief The tracker name. 
+        # std::string tracker_name_;
+        # brief A pointer to the spatial search object. 
+        # SearchPtr search_;
+        # brief Get a string representation of the name of this class.
+        # cdef inline const std::string& getClassName ()
+        # brief This method should get called before starting the actual computation.
+        # cdef bool initCompute ();
+        # brief Provide a pointer to a dataset to add additional information
+        # to estimate the features for every point in the input dataset.  This
+        # is optional, if this is not set, it will only use the data in the
+        # input cloud to estimate the features.  This is useful when you only
+        # need to compute the features for a downsampled cloud.  
+        # \param cloud a pointer to a PointCloud message
+        # cdef void setSearchMethod (const SearchPtr &)
+        # brief Get a pointer to the point cloud dataset.
+        # inline SearchPtr getSearchMethod ()
+        # brief Get an instance of the result of tracking.
+        # virtual StateT getResult () const = 0;
+###
+
+cdef extern from "pcl/tracking/coherence.h" namespace "pcl::tracking":
+    cdef cppclass PointCoherence[T]:
+        PointCoherence ()
+        # public:
+        # ctypedef boost::shared_ptr< PointCoherence<PointInT> > Ptr;
+        # ctypedef boost::shared_ptr< const PointCoherence<PointInT> > ConstPtr;
+        # public:
+        # cdef double compute (PointInT &source, PointInT &target);
+        # protected:
+        # std::string coherence_name_;
+        # cdef double computeCoherence (PointInT &source, PointInT &target) = 0;
+        # cdef const std::string& getClassName () const { return (coherence_name_);
+
+###
+
+cdef extern from "pcl/tracking/coherence.h" namespace "pcl::tracking":
+    cdef cppclass PointCloudCoherence[T]:
+        PointCloudCoherence ()
+        # public:
+        # ctypedef boost::shared_ptr< PointCloudCoherence<PointInT> > Ptr;
+        # ctypedef boost::shared_ptr< const PointCloudCoherence<PointInT> > ConstPtr;
+        # ctypedef pcl::PointCloud<PointInT> PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename PointCoherence<PointInT>::Ptr PointCoherencePtr;
+        cdef void compute (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_i);
+        # cdef vector[PointCoherencePtr] getPointCoherences ()
+        cdef void setPointCoherences (std::vector<PointCoherencePtr> coherences)
+        cdef bool initCompute ()
+        cdef void addPointCoherence (PointCoherencePtr coherence)
+        cdef void setTargetCloud (const PointCloudInConstPtr &cloud)
+        # protected:
+        # cdef void computeCoherence (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_j) = 0;
+        # cdef double calcPointCoherence (PointInT &source, PointInT &target);
+        # cdef const std::string& getClassName () const { return (coherence_name_); }
+        # std::string coherence_name_;
+        # PointCloudInConstPtr target_input_;
+        # std::vector<PointCoherencePtr> point_coherences_;
+###
+
+# class NearestPairPointCloudCoherence: public PointCloudCoherence<PointInT>
+cdef extern from "pcl/tracking/nearest_pair_point_cloud_coherence.h" namespace "pcl::tracking":
+    cdef cppclass NearestPairPointCloudCoherence[T](PointCoherence[T]):
+        NearestPairPointCloudCoherence ()
+        # public:
+        # using PointCloudCoherence<PointInT>::getClassName;
+        # using PointCloudCoherence<PointInT>::coherence_name_;
+        # using PointCloudCoherence<PointInT>::target_input_;
+        # ctypedef typename PointCloudCoherence<PointInT>::PointCoherencePtr PointCoherencePtr;
+        # ctypedef typename PointCloudCoherence<PointInT>::PointCloudInConstPtr PointCloudInConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> BaseClass;
+        # ctypedef boost::shared_ptr<NearestPairPointCloudCoherence<PointInT> > Ptr;
+        # ctypedef boost::shared_ptr<const NearestPairPointCloudCoherence<PointInT> > ConstPtr;
+        # ctypedef boost::shared_ptr<pcl::search::Search<PointInT> > SearchPtr;
+        # ctypedef boost::shared_ptr<const pcl::search::Search<PointInT> > SearchConstPtr;
+        # brief Provide a pointer to a dataset to add additional information
+        # to estimate the features for every point in the input dataset.  This
+        # is optional, if this is not set, it will only use the data in the
+        # input cloud to estimate the features.  This is useful when you only
+        # need to compute the features for a downsampled cloud. 
+        # param cloud a pointer to a PointCloud message
+        cdef void setSearchMethod (const SearchPtr &search)
+        # brief Get a pointer to the point cloud dataset.
+        # cdef SearchPtr getSearchMethod ()
+        # brief add a PointCoherence to the PointCloudCoherence.
+        # param coherence a pointer to PointCoherence.
+        cdef void setTargetCloud (const PointCloudInConstPtr &cloud)
+        # brief set maximum distance to be taken into account.
+        # param maximum distance.
+        cdef void setMaximumDistance (double )
+        # protected:
+        # using PointCloudCoherence<PointInT>::point_coherences_;
+        # brief This method should get called before starting the actual computation.
+        # virtual bool initCompute ();
+        # brief A flag which is true if target_input_ is updated
+        # bool new_target_;
+        # brief A pointer to the spatial search object.
+        # SearchPtr search_;
+        # brief max of distance for points to be taken into account
+        # double maximum_distance_;
+        # brief compute the nearest pairs and compute coherence using point_coherences_ 
+        # cdef void computeCoherence (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_j);
+
+###
+
+# class ParticleFilterTracker: public Tracker<PointInT, StateT>
+cdef extern from "pcl/tracking/particle_filter.h" namespace "pcl::tracking":
+    cdef cppclass ParticleFilterTracker[T, S](Tracker[T]):
+        ParticleFilterTracker ()
+        # protected:
+        # using Tracker<PointInT, StateT>::deinitCompute;
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::indices_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # brief set the number of iteration.
+        # param iteration_num the number of iteration.
+        cdef void setIterationNum (int )
+        # brief get the number of iteration.
+        cdef int getIterationNum ()
+        # brief set the number of the particles.
+        # param particle_num the number of the particles.
+        cdef void setParticleNum (const int )
+        # brief get the number of the particles.
+        cdef int getParticleNum ()
+        # brief set a pointer to a reference dataset to be tracked.
+        # param cloud a pointer to a PointCloud message
+        cdef void setReferenceCloud (const PointCloudInConstPtr &ref)
+        # brief get a pointer to a reference dataset to be tracked.
+        cdef PointCloudInConstPtr const getReferenceCloud ()
+        # brief set the PointCloudCoherence as likelihood.
+        # param coherence a pointer to PointCloudCoherence.
+        cdef void setCloudCoherence (const CloudCoherencePtr &coherence)
+        # brief get the PointCloudCoherence to compute likelihood.
+        cdef CloudCoherencePtr getCloudCoherence ()
+        # brief set the covariance of step noise.
+        # param step_noise_covariance the diagonal elements of covariance matrix of step noise.
+        cdef void setStepNoiseCovariance (const std::vector<double> &step_noise_covariance)
+        # brief set the covariance of the initial noise.
+        # it will be used when initializing the particles.
+        # param initial_noise_covariance the diagonal elements of covariance matrix of initial noise.
+        cdef void setInitialNoiseCovariance (const std::vector<double> &initial_noise_covariance)
+        # brief set the mean of the initial noise.
+        # it will be used when initializing the particles.
+        # param initial_noise_mean the mean values of initial noise.
+        cdef void setInitialNoiseMean (const std::vector<double> &initial_noise_mean)
+        # brief set the threshold to re-initialize the particles.
+        # param resample_likelihood_thr threshold to re-initialize.
+        cdef void setResampleLikelihoodThr (const double resample_likelihood_thr)
+        # brief set the threshold of angle to be considered occlusion (default: pi/2).
+        # ParticleFilterTracker does not take the occluded points into account according to the angle
+        # between the normal and the position. 
+        # param occlusion_angle_thr threshold of angle to be considered occlusion.
+        cdef void setOcclusionAngleThe (const double occlusion_angle_thr)
+        # brief set the minimum number of indices (default: 1).
+        # ParticleFilterTracker does not take into account the hypothesis
+        # whose the number of points is smaller than the minimum indices.
+        # param min_indices the minimum number of indices.
+        cdef void setMinIndices (const int min_indices)
+        # brief set the transformation from the world coordinates to the frame of the particles.
+        # param trans Affine transformation from the worldcoordinates to the frame of the particles.
+        cdef void setTrans (const Eigen::Affine3f &trans)
+        # brief get the transformation from the world coordinates to the frame of the particles.
+        cdef Eigen::Affine3f getTrans () const { return trans_; }
+        # brief Get an instance of the result of tracking.
+        # cdef StateT getResult () const { return representative_state_; }
+        # brief convert a state to affine transformation from the world coordinates frame.
+        # param particle an instance of StateT.
+        cdef Eigen::Affine3f toEigenMatrix (const StateT& particle)
+        # brief get a pointer to a pointcloud of the particles.
+        cdef PointCloudStatePtr getParticles ()
+        # brief normalize the weight of a particle using
+        # exp(1- alpha ( w - w_{min}) / (w_max - w_min)).
+        # this method is described in [P.Azad et. al, ICRA11].
+        # param w the weight to be normalized
+        # param w_min the minimum weight of the particles
+        # param w_max the maximum weight of the particles
+        cdef double normalizeParticleWeight (double , double , double )
+        # brief set the value of alpha.
+        # param alpha the value of alpha
+        cdef void setAlpha (double)
+        # brief get the value of alpha.
+        cdef double getAlpha ()
+        # brief set the value of use_normal_.
+        # param use_normal the value of use_normal_.
+        cdef void setUseNormal (bool)
+        # brief get the value of use_normal_.
+        cdef bool getUseNormal ()
+        # brief set the value of use_change_detector_.
+        # param use_normal the value of use_change_detector_.
+        cdef void setUseChangeDetector (bool )
+        # brief get the value of use_change_detector_.
+        cdef bool getUseChangeDetector ()
+        # brief set the motion ratio
+        # param motion_ratio the ratio of hypothesis to use motion model.
+        cdef void setMotionRatio (double )
+        # brief get the motion ratio
+        cdef double getMotionRatio ()
+        # brief set the number of interval frames to run change detection.
+        # param change_detector_interval the number of interval frames.
+        cdef void setIntervalOfChangeDetection (unsigned int )
+        # brief get the number of interval frames to run change detection.
+        cdef unsigned int getIntervalOfChangeDetection ()
+        # brief set the minimum amount of points required within leaf node to become serialized in change detection
+        # param change_detector_filter the minimum amount of points required within leaf node
+        cdef void setMinPointsOfChangeDetection (unsigned int change_detector_filter)
+        # brief set the resolution of change detection.
+        # param resolution resolution of change detection octree
+        cdef void setResolutionOfChangeDetection (double )
+        # brief get the resolution of change detection.
+        cdef double getResolutionOfChangeDetection ()
+        # brief get the minimum amount of points required within leaf node to become serialized in change detection
+        cdef unsigned int getMinPointsOfChangeDetection ()
+        # brief get the adjustment ratio.
+        cdef double getFitRatio()
+        # brief reset the particles to restart tracking
+        cdef void resetTracking ()
+        ###
+        # protected:
+        # brief compute the parameters for the bounding box of 
+        # hypothesis pointclouds.
+        # param x_min the minimum value of x axis.
+        # param x_max the maximum value of x axis.
+        # param y_min the minimum value of y axis.
+        # param y_max the maximum value of y axis.
+        # param z_min the minimum value of z axis.
+        # param z_max the maximum value of z axis.
+        cdef void calcBoundingBox (double &x_min, double &x_max,
+                              double &y_min, double &y_max,
+                              double &z_min, double &z_max);
+        # brief crop the pointcloud by the bounding box calculated
+        #  from hypothesis and the reference pointcloud.
+        # param cloud a pointer to pointcloud to be cropped.
+        # param output a pointer to be assigned the cropped pointcloud.
+        cdef void cropInputPointCloud (const PointCloudInConstPtr &cloud, PointCloudIn &output);
+
+        # brief compute a reference pointcloud transformed to the pose that
+        # hypothesis represents.
+        # param hypothesis a particle which represents a hypothesis.
+        # param indices the indices which should be taken into account.
+        # param cloud the resultant point cloud model dataset which
+        #             is transformed to hypothesis.
+        cdef void computeTransformedPointCloud (const StateT& hypothesis,
+                                           std::vector<int>& indices,
+                                           PointCloudIn &cloud);
+        # brief compute a reference pointcloud transformed to the pose that
+        # hypothesis represents and calculate indices taking occlusion into \
+        #  account.
+        # param hypothesis a particle which represents a hypothesis.
+        # param indices the indices which should be taken into account.
+        # param cloud the resultant point cloud model dataset which
+        #           is transformed to hypothesis.
+        cdef void computeTransformedPointCloudWithNormal (const StateT& hypothesis,
+                                           std::vector<int>& indices,
+                                           PointCloudIn &cloud);
+        # brief compute a reference pointcloud transformed to the pose that
+        # hypothesis represents and calculate indices without taking
+        # occlusion into account.
+        # param hypothesis a particle which represents a hypothesis.
+        # param cloud the resultant point cloud model dataset which
+        #         is transformed to hypothesis.
+        cdef void computeTransformedPointCloudWithoutNormal (const StateT& hypothesis, PointCloudIn &cloud);
+        # brief This method should get called before starting the actual computation.
+        cdef bool initCompute ()
+        # brief weighting phase of particle filter method.
+        # calculate the likelihood of all of the particles and set the weights.
+        cdef void weight ()
+        # brief resampling phase of particle filter method.
+        # sampling the particles according to the weights calculated in weight method.
+        # in particular, "sample with replacement" is archieved by walker's alias method.
+        cdef void resample ()
+        # brief calculate the weighted mean of the particles and set it as the result
+        cdef void update ()
+        # brief normalize the weights of all the particels.
+        cdef void normalizeWeight ()
+        # brief initialize the particles. initial_noise_covariance_ and initial_noise_mean_ are
+        # used for gausiaan sampling.
+        cdef void initParticles (bool reset)
+        # brief track the pointcloud using particle filter method.
+        cdef void computeTracking ()
+        # brief implementation of "sample with replacement" using Walker's alias method.
+        # about Walker's alias method, you can check the paper below:
+        # param a an alias table, which generated by genAliasTable.
+        # param q a table of weight, which generated by genAliasTable.
+        cdef int sampleWithReplacement (const std::vector<int>& a, const std::vector<double>& q)
+        # brief generate the tables for walker's alias method
+        cdef void genAliasTable (std::vector<int> &a, std::vector<double> &q, const PointCloudStateConstPtr &particles)
+        # brief resampling the particle with replacement
+        cdef void resampleWithReplacement ()
+        # brief resampling the particle in deterministic way
+        cdef void resampleDeterministic ()
+        # brief run change detection and return true if there is a change.
+        # param input a pointer to the input pointcloud.
+        cdef bool testChangeDetection (const PointCloudInConstPtr &input)
+        # the number of iteration of particlefilter.
+        # int iteration_num_;
+        # brief the number of the particles.
+        int particle_num_;
+        # brief the minimum number of points which the hypothesis should have.
+        int min_indices_;
+        # brief adjustment of the particle filter.
+        double fit_ratio_;
+        # brief a pointer to reference point cloud.
+        PointCloudInConstPtr ref_;
+        # brief a pointer to the particles
+        PointCloudStatePtr particles_;
+        # brief a pointer to PointCloudCoherence.
+        CloudCoherencePtr coherence_;
+        # brief the diagonal elements of covariance matrix of the step noise. the covariance matrix is used
+        #    at every resample method.
+        std::vector<double> step_noise_covariance_;
+        # brief the diagonal elements of covariance matrix of the initial noise. the covariance matrix is used
+        # when initialize the particles.
+        std::vector<double> initial_noise_covariance_;
+        # brief the mean values of initial noise.
+        std::vector<double> initial_noise_mean_;
+        # brief the threshold for the particles to be re-initialized
+        double resample_likelihood_thr_;
+        # brief the threshold for the points to be considered as occluded
+        double occlusion_angle_thr_;
+        # brief the weight to be used in normalization
+        #         of the weights of the particles 
+        double alpha_;
+        # brief the result of tracking.
+        StateT representative_state_;
+        # brief an affine transformation from the world coordinates frame to the origin of the particles
+        Eigen::Affine3f trans_;
+        # brief a flag to use normal or not. defaults to false
+        bool use_normal_;
+        # brief difference between the result in t and t-1
+        StateT motion_;
+        # brief ratio of hypothesis to use motion model
+        double motion_ratio_;
+        # brief pass through filter to crop the pointclouds within the hypothesis bounding box
+        pcl::PassThrough<PointInT> pass_x_;
+        # brief pass through filter to crop the pointclouds within the hypothesis bounding box
+        pcl::PassThrough<PointInT> pass_y_;
+        # brief pass through filter to crop the pointclouds within the hypothesis bounding box
+        pcl::PassThrough<PointInT> pass_z_;
+        # brief a list of the pointers to pointclouds
+        std::vector<PointCloudInPtr> transed_reference_vector_;
+        # brief change detector used as a trigger to track
+        boost::shared_ptr<pcl::octree::OctreePointCloudChangeDetector<PointInT> > change_detector_;
+        # brief a flag to be true when change of pointclouds is detected
+        bool changed_;
+        # brief a counter to skip change detection
+        unsigned int change_counter_;
+        # brief minimum points in a leaf when calling change detector. defaults to 10
+        unsigned int change_detector_filter_;
+        # brief the number of interval frame to run change detection. defaults to 10.
+        unsigned int change_detector_interval_;
+        # brief resolution of change detector. defaults to 0.01.
+        double change_detector_resolution_;
+        # brief the flag which will be true if using change detection
+        bool use_change_detector_;
+###
+
+### Inheritance ###
+
+# class ApproxNearestPairPointCloudCoherence: public NearestPairPointCloudCoherence<PointInT>
+cdef extern from "pcl/tracking/approx_nearest_pair_point_cloud_coherence.h" namespace "pcl::tracking":
+    cdef cppclass ApproxNearestPairPointCloudCoherence[T](NearestPairPointCloudCoherence[T]):
+        ApproxNearestPairPointCloudCoherence ()
+        # public:
+        # ctypedef typename NearestPairPointCloudCoherence<PointInT>::PointCoherencePtr PointCoherencePtr;
+        # ctypedef typename NearestPairPointCloudCoherence<PointInT>::PointCloudInConstPtr PointCloudInConstPtr;
+        # using NearestPairPointCloudCoherence<PointInT>::maximum_distance_;
+        # using NearestPairPointCloudCoherence<PointInT>::target_input_;
+        # using NearestPairPointCloudCoherence<PointInT>::point_coherences_;
+        # using NearestPairPointCloudCoherence<PointInT>::coherence_name_;
+        # using NearestPairPointCloudCoherence<PointInT>::new_target_;
+        # using NearestPairPointCloudCoherence<PointInT>::getClassName;
+
+        # protected:
+        # cdef bool initCompute ();
+        # cdef void computeCoherence (const PointCloudInConstPtr &cloud, const IndicesConstPtr &indices, float &w_j);
+        # typename boost::shared_ptr<pcl::search::Octree<PointInT> > search_;
+
+###
+
+# class DistanceCoherence: public PointCoherence<PointInT>
+cdef extern from "pcl/tracking/distance_coherence.h" namespace "pcl::tracking":
+    cdef cppclass DistanceCoherence[T](PointCoherence[T]):
+        DistanceCoherence ()
+        cdef void setWeight (double)
+        cdef double getWeight ()
+        # protected:
+        # cdef double computeCoherence (PointInT &source, PointInT &target);
+        # double weight_;
+###
+
+cdef extern from "pcl/tracking/hsv_color_coherence.h" namespace "pcl::tracking":
+    cdef cppclass HSVColorCoherence[T]:
+        HSVColorCoherence ()
+        cdef void setWeight (double)
+        cdef double getWeight ()
+        # public:
+        cdef void setWeight (double )
+        cdef double getWeight ()
+        cdef void setHWeight (double )
+        cdef double getHWeight ()
+        cdef void setSWeight (double )
+        cdef double getSWeight ()
+        cdef void setVWeight (double )
+        cdef double getVWeight ()
+        # protected:
+        # cdef double computeCoherence (PointInT &source, PointInT &target);
+        # double weight_;
+        # double h_weight_;
+        # double s_weight_;
+        # double v_weight_;
+
+###
+
+# class KLDAdaptiveParticleFilterTracker: public ParticleFilterTracker<PointInT, StateT>
+cdef extern from "pcl/tracking/kld_adaptive_particle_filter.h" namespace "pcl::tracking":
+    cdef cppclass KLDAdaptiveParticleFilterTracker[T, S](ParticleFilterTracker[T, S]):
+        KLDAdaptiveParticleFilterTracker ()
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # using ParticleFilterTracker<PointInT, StateT>::transed_reference_vector_;
+        # using ParticleFilterTracker<PointInT, StateT>::coherence_;
+        # using ParticleFilterTracker<PointInT, StateT>::initParticles;
+        # using ParticleFilterTracker<PointInT, StateT>::weight;
+        # using ParticleFilterTracker<PointInT, StateT>::update;
+        # using ParticleFilterTracker<PointInT, StateT>::iteration_num_;
+        # using ParticleFilterTracker<PointInT, StateT>::particle_num_;
+        # using ParticleFilterTracker<PointInT, StateT>::particles_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_normal_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_resolution_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::motion_;
+        # using ParticleFilterTracker<PointInT, StateT>::motion_ratio_;
+        # using ParticleFilterTracker<PointInT, StateT>::step_noise_covariance_;
+        # using ParticleFilterTracker<PointInT, StateT>::representative_state_;
+        # using ParticleFilterTracker<PointInT, StateT>::sampleWithReplacement;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # cdef void setBinSize (const StateT& bin_size) { bin_size_ = bin_size; }
+        # cdef StateT getBinSize () const { return (bin_size_); }
+        # cdef void setMaximumParticleNum (unsigned int nr) { maximum_particle_number_ = nr; }
+        # cdef unsigned int getMaximumParticleNum () const { return (maximum_particle_number_); }
+        # cdef void setEpsilon (double eps) { epsilon_ = eps; }
+        # cdef double getEpsilon () const { return (epsilon_); }
+        #cdef void setDelta (double delta) { delta_ = delta; }
+        # brief get delta to be used in chi-squared distribution.
+        cdef double getDelta () const { return (delta_); }
+        # protected:
+        # brief return true if the two bins are equal.
+        # param a index of the bin
+        # param b index of the bin
+        # cdef bool equalBin (std::vector<int> a, std::vector<int> b)
+        # brief return upper quantile of standard normal distribution.
+        # param[in] u ratio of quantile.
+        # double normalQuantile (double u)
+        # brief calculate K-L boundary. K-L boundary follows 1/2e*chi(k-1, 1-d)^2.
+        # param[in] k the number of bins and the first parameter of chi distribution.
+        # cdef double calcKLBound (int k)
+        # brief insert a bin into the set of the bins. if that bin is already registered,
+        #   return false. if not, return true.
+        # param bin a bin to be inserted.
+        # param B a set of the bins
+        # cdef bool insertIntoBins (std::vector<int> bin, std::vector<std::vector<int> > &B);
+        # brief This method should get called before starting the actual computation.
+        # cdef bool initCompute ();
+        # brief resampling phase of particle filter method.
+        #  sampling the particles according to the weights calculated in weight method.
+        #  in particular, "sample with replacement" is archieved by walker's alias method.
+        # cdef void resample ();
+        # brief the maximum number of the particles.
+        # unsigned int maximum_particle_number_;
+        # brief error between K-L distance and MLE
+        # double epsilon_;
+        # brief probability of distance between K-L distance and MLE is less than epsilon_
+        # double delta_;
+        # brief the size of a bin.
+        # StateT bin_size_;
+###
+
+# class KLDAdaptiveParticleFilterOMPTracker: public KLDAdaptiveParticleFilterTracker<PointInT, StateT>
+cdef extern from "pcl/tracking/kld_adaptive_particle_filter_omp.h" namespace "pcl::tracking":
+    cdef cppclass KLDAdaptiveParticleFilterOMPTracker[T, S](KLDAdaptiveParticleFilterTracker[T, S]):
+        KLDAdaptiveParticleFilterOMPTracker ()
+        KLDAdaptiveParticleFilterOMPTracker (unsigned int )
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::indices_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::particles_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_detector_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_counter_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_detector_interval_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::use_change_detector_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::pass_x_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::pass_y_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::pass_z_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::alpha_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::changed_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::coherence_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::use_normal_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::particle_num_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::change_detector_filter_;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::transed_reference_vector_;
+        # //using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::calcLikelihood;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::normalizeWeight;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::normalizeParticleWeight;
+        # using KLDAdaptiveParticleFilterTracker<PointInT, StateT>::calcBoundingBox;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        void setNumberOfThreads (unsigned int nr_threads)
+        # protected:
+        # brief The number of threads the scheduler should use.
+        # unsigned int threads_;
+        # brief weighting phase of particle filter method.
+        # calculate the likelihood of all of the particles and set the weights.
+        void weight ();
+###
+
+# class NormalCoherence: public PointCoherence<PointInT>
+cdef extern from "pcl/tracking/normal_coherence.h" namespace "pcl::tracking":
+    cdef cppclass NormalCoherence[T](ParticleFilterTracker[T, S]):
+        NormalCoherence ()
+        # brief set the weight of coherence
+        # param weight the weight of coherence
+        cdef void setWeight (double )
+        # brief get the weight of coherence
+        cdef double getWeight ()
+        # protected:
+        # brief return the normal coherence between the two points.
+        # param source instance of source point.
+        # param target instance of target point.
+        #
+        # double computeCoherence (PointInT &source, PointInT &target);
+        # double weight_;
+
+###
+
+# class ParticleFilterOMPTracker: public ParticleFilterTracker<PointInT, StateT>
+cdef extern from "pcl/tracking/particle_filter_omp.h" namespace "pcl::tracking":
+    cdef cppclass ParticleFilterOMPTracker[T, S](ParticleFilterTracker[T, S]):
+        ParticleFilterOMPTracker ()
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        ParticleFilterOMPTracker (unsigned int )
+        # public:
+        # using Tracker<PointInT, StateT>::tracker_name_;
+        # using Tracker<PointInT, StateT>::search_;
+        # using Tracker<PointInT, StateT>::input_;
+        # using Tracker<PointInT, StateT>::indices_;
+        # using Tracker<PointInT, StateT>::getClassName;
+        # using ParticleFilterTracker<PointInT, StateT>::particles_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_counter_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_interval_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_change_detector_;
+        # using ParticleFilterTracker<PointInT, StateT>::alpha_;
+        # using ParticleFilterTracker<PointInT, StateT>::changed_;
+        # using ParticleFilterTracker<PointInT, StateT>::coherence_;
+        # using ParticleFilterTracker<PointInT, StateT>::use_normal_;
+        # using ParticleFilterTracker<PointInT, StateT>::particle_num_;
+        # using ParticleFilterTracker<PointInT, StateT>::change_detector_filter_;
+        # using ParticleFilterTracker<PointInT, StateT>::transed_reference_vector_;
+        # //using ParticleFilterTracker<PointInT, StateT>::calcLikelihood;
+        # using ParticleFilterTracker<PointInT, StateT>::normalizeWeight;
+        # using ParticleFilterTracker<PointInT, StateT>::normalizeParticleWeight;
+        # using ParticleFilterTracker<PointInT, StateT>::calcBoundingBox;
+        # ctypedef Tracker<PointInT, StateT> BaseClass;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudIn PointCloudIn;
+        # ctypedef typename PointCloudIn::Ptr PointCloudInPtr;
+        # ctypedef typename PointCloudIn::ConstPtr PointCloudInConstPtr;
+        # ctypedef typename Tracker<PointInT, StateT>::PointCloudState PointCloudState;
+        # ctypedef typename PointCloudState::Ptr PointCloudStatePtr;
+        # ctypedef typename PointCloudState::ConstPtr PointCloudStateConstPtr;
+        # ctypedef PointCoherence<PointInT> Coherence;
+        # ctypedef boost::shared_ptr< Coherence > CoherencePtr;
+        # ctypedef boost::shared_ptr< const Coherence > CoherenceConstPtr;
+        # ctypedef PointCloudCoherence<PointInT> CloudCoherence;
+        # ctypedef boost::shared_ptr< CloudCoherence > CloudCoherencePtr;
+        # ctypedef boost::shared_ptr< const CloudCoherence > CloudCoherenceConstPtr;
+        # brief Initialize the scheduler and set the number of threads to use.
+        # param nr_threads the number of hardware threads to use (-1 sets the value back to automatic)
+        void setNumberOfThreads (unsigned int nr_threads)
+        # protected:
+        # brief The number of threads the scheduler should use.
+        # unsigned int threads_;
+        # brief weighting phase of particle filter method.
+        # calculate the likelihood of all of the particles and set the weights.
+        void weight ();
+
+###
+
+cdef extern from "pcl/tracking/tracking.h" namespace "pcl::tracking":
+    # state definition
+    cdef struct ParticleXYZRPY
+    cdef struct ParticleXYR
+    # brief return the value of normal distribution
+    # mean
+    # sigma
+    cdef double sampleNormal (double , double);
+###
\ No newline at end of file
diff --git a/pcl/pcl_visualization.pxd b/pcl/pcl_visualization.pxd
new file mode 100644
index 0000000..beb68ec
--- /dev/null
+++ b/pcl/pcl_visualization.pxd
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-

+# Header for pcl_visualization.pyx functionality that needs sharing with other modules.
+
cimport pcl_visualization_defs as vis

+

+from libc.stddef cimport size_t

+

+from libcpp.vector cimport vector

+from libcpp.string cimport string

+from libcpp cimport bool

+

+# main

+cimport pcl_defs as cpp

+
+# class override(PointCloud)
+cdef class PointCloudColorHandleringCustom:
+    cdef vis.PointCloudColorHandlerCustom_Ptr_t thisptr_shared     # PointCloudColorHandlerCustom[PointXYZ]
+    
+    # cdef inline PointCloudColorHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil:

+    # pcl_visualization_defs

+    cdef inline vis.PointCloudColorHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloudColorHandlerCustom<PointXYZ>.
+        return self.thisptr_shared.get()
+


+

+cdef class PointCloudGeometryHandleringCustom:
+    cdef vis.PointCloudGeometryHandlerCustom_Ptr_t thisptr_shared     # PointCloudGeometryHandlerCustom[PointXYZ]
+    
+    # cdef inline PointCloudGeometryHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil:

+    # pcl_visualization_defs

+    cdef inline vis.PointCloudGeometryHandlerCustom[cpp.PointXYZ] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloudGeometryHandlerCustom<PointXYZ>.
+        return self.thisptr_shared.get()
+


+

diff --git a/pcl/pcl_visualization.pyx b/pcl/pcl_visualization.pyx
new file mode 100644
index 0000000..13634a6
--- /dev/null
+++ b/pcl/pcl_visualization.pyx
@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# cython: embedsignature=True
+from libcpp cimport bool
+
+from collections import Sequence
+import numbers
+import numpy as np
+cimport numpy as cnp
+
+cimport pcl_defs as cpp
+cimport pcl_visualization_defs as vis
+
+cimport cython
+# from cython.operator import dereference as deref
+from cython.operator cimport dereference as deref, preincrement as inc
+
+from cpython cimport Py_buffer
+
+from libcpp.string cimport string
+from libcpp cimport bool
+from libcpp.vector cimport vector
+
+from boost_shared_ptr cimport sp_assign
+
+cnp.import_array()
+
+### Enum ###
+
+### Enum Setting ###
+# pcl_visualization_defs.pxd
+# cdef enum RenderingProperties:
+# Re: [Cython] resolving name conflict -- does not work for enums !? 
+# https://www.mail-archive.com/cython-dev@codespeak.net/msg02494.html
+PCLVISUALIZER_POINT_SIZE = vis.PCL_VISUALIZER_POINT_SIZE
+PCLVISUALIZER_OPACITY = vis.PCL_VISUALIZER_OPACITY
+PCLVISUALIZER_LINE_WIDTH = vis.PCL_VISUALIZER_LINE_WIDTH
+PCLVISUALIZER_FONT_SIZE = vis.PCL_VISUALIZER_FONT_SIZE
+PCLVISUALIZER_COLOR = vis.PCL_VISUALIZER_COLOR
+PCLVISUALIZER_REPRESENTATION = vis.PCL_VISUALIZER_REPRESENTATION
+PCLVISUALIZER_IMMEDIATE_RENDERING = vis.PCL_VISUALIZER_IMMEDIATE_RENDERING
+
+# cdef enum RenderingRepresentationProperties:
+PCLVISUALIZER_REPRESENTATION_POINTS = vis.PCL_VISUALIZER_REPRESENTATION_POINTS
+PCLVISUALIZER_REPRESENTATION_WIREFRAME = vis.PCL_VISUALIZER_REPRESENTATION_WIREFRAME
+PCLVISUALIZER_REPRESENTATION_SURFACE = vis.PCL_VISUALIZER_REPRESENTATION_SURFACE
+
+### Enum Setting(define Class InternalType) ###
+
+###
+
+# PointCloud/Common
+# NG
+# include "pxi/PointCloud__PointXYZ.pxi"
+# include "pxi/PointCloud__PointXYZI.pxi"
+# include "pxi/Common/RangeImage/RangeImages.pxi"
+
+# VTK - Handler(Color)
+include "pxi/Visualization/Handler/PointCloudColorHandleringCustom.pxi"
+include "pxi/Visualization/Handler/PointCloudColorHandleringGenericField.pxi"
+include "pxi/Visualization/Handler/PointCloudColorHandleringHSVField.pxi"
+include "pxi/Visualization/Handler/PointCloudColorHandleringRandom.pxi"
+include "pxi/Visualization/Handler/PointCloudColorHandleringRGBField.pxi"
+include "pxi/Visualization/Handler/PointCloudGeometryHandleringCustom.pxi"
+include "pxi/Visualization/Handler/PointCloudGeometryHandleringSurfaceNormal.pxi"
+include "pxi/Visualization/Handler/PointCloudGeometryHandleringXYZ.pxi"
+
+# VTK
+include "pxi/Visualization/CloudViewing.pxi"
+include "pxi/Visualization/PCLVisualizering.pxi"
+include "pxi/Visualization/PCLHistogramViewing.pxi"
+# include "pxi/Visualization/RangeImageVisualization.pxi"
+
+# NG(vtk Link Error)
+# include "pxi/Visualization/RangeImageVisualization.pxi"
+# include "pxi/Visualization/PCLHistogramViewing.pxi"
diff --git a/pcl/pcl_visualization_172.pxd b/pcl/pcl_visualization_172.pxd
new file mode 100644
index 0000000..be8f2f8
--- /dev/null
+++ b/pcl/pcl_visualization_172.pxd
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+# area_picking_event.h
+# boost.h
+# cloud_viewer.h
+# eigen.h
+# histogram_visualizer.h
+# image_viewer.h
+# interactor.h
+# interactor_style.h
+# keyboard_event.h
+# mouse_event.h
+# pcl_painter2D.h
+# pcl_plotter.h
+# pcl_visualizer.h
+# point_cloud_color_handlers.h
+# point_cloud_geometry_handlers.h
+# point_cloud_handlers.h
+# point_picking_event.h
+# range_image_visualizer.h
+# registration_visualizer.h
+# simple_buffer_visualizer.h
+# vtk.h
+# window.h
+###
\ No newline at end of file
diff --git a/pcl/pcl_visualization_180.pxd b/pcl/pcl_visualization_180.pxd
new file mode 100644
index 0000000..be8f2f8
--- /dev/null
+++ b/pcl/pcl_visualization_180.pxd
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+# area_picking_event.h
+# boost.h
+# cloud_viewer.h
+# eigen.h
+# histogram_visualizer.h
+# image_viewer.h
+# interactor.h
+# interactor_style.h
+# keyboard_event.h
+# mouse_event.h
+# pcl_painter2D.h
+# pcl_plotter.h
+# pcl_visualizer.h
+# point_cloud_color_handlers.h
+# point_cloud_geometry_handlers.h
+# point_cloud_handlers.h
+# point_picking_event.h
+# range_image_visualizer.h
+# registration_visualizer.h
+# simple_buffer_visualizer.h
+# vtk.h
+# window.h
+###
\ No newline at end of file
diff --git a/pcl/pcl_visualization_defs.pxd b/pcl/pcl_visualization_defs.pxd
new file mode 100644
index 0000000..81fe113
--- /dev/null
+++ b/pcl/pcl_visualization_defs.pxd
@@ -0,0 +1,3158 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+from pcl_range_image cimport RangeImage
+
+# Eigen
+cimport eigen as eigen3
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+# point_cloud_handlers.h(1.6.0)
+# point_cloud_handlers.h -> point_cloud_color_handlers.h(1.7.2)
+# template <typename PointT>
+# class PointCloudColorHandler
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudColorHandler[T]:
+        # brief Constructor.
+        # PointCloudColorHandler (const PointCloudConstPtr &cloud)
+        PointCloudColorHandler(shared_ptr[const cpp.PointCloud[T]] &cloud)
+        
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<PointCloudColorHandler<PointT> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandler<PointT> > ConstPtr;
+        
+        # brief Destructor.
+        # virtual ~PointCloudColorHandler () {}
+        
+        # brief Check if this handler is capable of handling the input data or not.
+        # inline bool isCapable () const
+        bool isCapable ()
+        
+        # /** \brief Abstract getName method. */
+        # virtual std::string getName () const = 0;
+        string getName ()
+        
+        # /** \brief Abstract getFieldName method. */
+        # virtual std::string getFieldName () const = 0;
+        string getFieldName ()
+        
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const = 0;
+        # void getColor (vtkSmartPointer[vtkDataArray] &scalars)
+
+
+###
+
+# point_cloud_handlers.h(1.6.0)
+# point_cloud_handlers.h -> point_cloud_geometry_handlers.h(1.7.2)
+# template <typename PointT>
+# class PointCloudGeometryHandler
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudGeometryHandler[T]:
+        # brief Constructor.
+        # PointCloudGeometryHandler (const PointCloudConstPtr &cloud) :
+        PointCloudGeometryHandler(shared_ptr[cpp.PointCloud[T]] &cloud)
+        
+        # public:
+        # typedef pcl::PointCloud<PointT> PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename boost::shared_ptr<PointCloudGeometryHandler<PointT> > Ptr;
+        # typedef typename boost::shared_ptr<const PointCloudGeometryHandler<PointT> > ConstPtr;
+        
+        # brief Abstract getName method.
+        # return the name of the class/object.
+        # virtual std::string getName () const = 0;
+        
+        # /** \brief Abstract getFieldName method. */
+        # virtual std::string getFieldName () const  = 0;
+        
+        # /** \brief Checl if this handler is capable of handling the input data or not. */
+        # inline bool isCapable () const
+        bool isCapable ()
+        
+        # /** \brief Obtain the actual point geometry for the input dataset in VTK format.
+        #   * \param[out] points the resultant geometry
+        # virtual void getGeometry (vtkSmartPointer<vtkPoints> &points) const = 0;
+
+
+###
+
+### Inheritance class ###
+### handler class ###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudColorHandlerCustom : public PointCloudColorHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudColorHandlerCustom[PointT](PointCloudColorHandler[PointT]):
+        # PointCloudColorHandlerCustom ()
+        # brief Constructor.
+        
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerCustom (double r, double g, double b)
+        PointCloudColorHandlerCustom (double r, double g, double b)
+        
+        # ctypedef shared_ptr[Vertices const] VerticesConstPtr
+        # PointCloudColorHandlerCustom (const PointCloudConstPtr &cloud, double r, double g, double b)
+        PointCloudColorHandlerCustom (const shared_ptr[cpp.PointCloud[PointT]] &cloud, double r, double g, double b)
+        
+        # /** \brief Destructor. */
+        # virtual ~PointCloudColorHandlerCustom () {};
+        
+        # /** \brief Abstract getName method. */
+        # virtual inline std::string getName () const
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const
+        
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+
+
+ctypedef PointCloudColorHandlerCustom[cpp.PointXYZ] PointCloudColorHandlerCustom_t
+ctypedef PointCloudColorHandlerCustom[cpp.PointXYZI] PointCloudColorHandlerCustom_PointXYZI_t
+ctypedef PointCloudColorHandlerCustom[cpp.PointXYZRGB] PointCloudColorHandlerCustom_PointXYZRGB_t
+ctypedef PointCloudColorHandlerCustom[cpp.PointXYZRGBA] PointCloudColorHandlerCustom_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudColorHandlerCustom[cpp.PointXYZ]] PointCloudColorHandlerCustom_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerCustom[cpp.PointXYZI]] PointCloudColorHandlerCustom_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerCustom[cpp.PointXYZRGB]] PointCloudColorHandlerCustom_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerCustom[cpp.PointXYZRGBA]] PointCloudColorHandlerCustom_PointXYZRGBA_Ptr_t
+ctypedef PointCloudColorHandlerCustom[cpp.PointWithRange] PointCloudColorHandlerCustom_PointWithRange_t
+ctypedef shared_ptr[PointCloudColorHandlerCustom[cpp.PointWithRange]] PointCloudColorHandlerCustom_PointWithRange_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudGeometryHandlerXYZ : public PointCloudGeometryHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudGeometryHandlerXYZ[PointT](PointCloudGeometryHandler[PointT]):
+        PointCloudGeometryHandlerXYZ()
+        # public:
+        # typedef typename PointCloudGeometryHandler<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename boost::shared_ptr<PointCloudGeometryHandlerXYZ<PointT> > Ptr;
+        # typedef typename boost::shared_ptr<const PointCloudGeometryHandlerXYZ<PointT> > ConstPtr;
+        
+        # /** \brief Constructor. */
+        # PointCloudGeometryHandlerXYZ (const PointCloudConstPtr &cloud);
+        
+        # /** \brief Destructor. */
+        # virtual ~PointCloudGeometryHandlerXYZ () {};
+        
+        # /** \brief Class getName method. */
+        # virtual inline std::string getName () const
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const
+        
+        # /** \brief Obtain the actual point geometry for the input dataset in VTK format.
+        #   * \param[out] points the resultant geometry
+        # virtual void getGeometry (vtkSmartPointer<vtkPoints> &points) const;
+
+
+ctypedef PointCloudGeometryHandlerXYZ[cpp.PointXYZ] PointCloudGeometryHandlerXYZ_t
+ctypedef PointCloudGeometryHandlerXYZ[cpp.PointXYZI] PointCloudGeometryHandlerXYZ_PointXYZI_t
+ctypedef PointCloudGeometryHandlerXYZ[cpp.PointXYZRGB] PointCloudGeometryHandlerXYZ_PointXYZRGB_t
+ctypedef PointCloudGeometryHandlerXYZ[cpp.PointXYZRGBA] PointCloudGeometryHandlerXYZ_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudGeometryHandlerXYZ[cpp.PointXYZ]] PointCloudGeometryHandlerXYZ_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerXYZ[cpp.PointXYZI]] PointCloudGeometryHandlerXYZ_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerXYZ[cpp.PointXYZRGB]] PointCloudGeometryHandlerXYZ_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerXYZ[cpp.PointXYZRGBA]] PointCloudGeometryHandlerXYZ_PointXYZRGBA_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudGeometryHandlerSurfaceNormal : public PointCloudGeometryHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudGeometryHandlerSurfaceNormal[PointT]:
+        PointCloudGeometryHandlerSurfaceNormal()
+        # public:
+        # typedef typename PointCloudGeometryHandler<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename boost::shared_ptr<PointCloudGeometryHandlerSurfaceNormal<PointT> > Ptr;
+        # typedef typename boost::shared_ptr<const PointCloudGeometryHandlerSurfaceNormal<PointT> > ConstPtr;
+        
+        # /** \brief Constructor. */
+        # PointCloudGeometryHandlerSurfaceNormal (const PointCloudConstPtr &cloud);
+        
+        # /** \brief Class getName method. */
+        # virtual inline std::string getName () const
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const
+        
+        # /** \brief Obtain the actual point geometry for the input dataset in VTK format.
+        #   * \param[out] points the resultant geometry
+        # virtual void getGeometry (vtkSmartPointer<vtkPoints> &points) const;
+
+
+ctypedef PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZ] PointCloudGeometryHandlerSurfaceNormal_t
+ctypedef PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZI] PointCloudGeometryHandlerSurfaceNormal_PointXYZI_t
+ctypedef PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZRGB] PointCloudGeometryHandlerSurfaceNormal_PointXYZRGB_t
+ctypedef PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZRGBA] PointCloudGeometryHandlerSurfaceNormal_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZ]] PointCloudGeometryHandlerSurfaceNormal_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZI]] PointCloudGeometryHandlerSurfaceNormal_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZRGB]] PointCloudGeometryHandlerSurfaceNormal_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerSurfaceNormal[cpp.PointXYZRGBA]] PointCloudGeometryHandlerSurfaceNormal_PointXYZRGBA_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudGeometryHandlerCustom : public PointCloudGeometryHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudGeometryHandlerCustom[PointT]:
+        PointCloudGeometryHandlerCustom()
+        # public:
+        # typedef typename PointCloudGeometryHandler<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef typename boost::shared_ptr<PointCloudGeometryHandlerCustom<PointT> > Ptr;
+        # typedef typename boost::shared_ptr<const PointCloudGeometryHandlerCustom<PointT> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudGeometryHandlerCustom (const PointCloudConstPtr &cloud,
+        #                                  const std::string &x_field_name,
+        #                                  const std::string &y_field_name,
+        #                                  const std::string &z_field_name);
+        
+        # /** \brief Class getName method. */
+        # virtual inline std::string getName () const
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const
+        
+        # /** \brief Obtain the actual point geometry for the input dataset in VTK format.
+        #   * \param[out] points the resultant geometry
+        # virtual void getGeometry (vtkSmartPointer<vtkPoints> &points) const;
+
+
+ctypedef PointCloudGeometryHandlerCustom[cpp.PointXYZ] PointCloudGeometryHandlerCustom_t
+ctypedef PointCloudGeometryHandlerCustom[cpp.PointXYZI] PointCloudGeometryHandlerCustom_PointXYZI_t
+ctypedef PointCloudGeometryHandlerCustom[cpp.PointXYZRGB] PointCloudGeometryHandlerCustom_PointXYZRGB_t
+ctypedef PointCloudGeometryHandlerCustom[cpp.PointXYZRGBA] PointCloudGeometryHandlerCustom_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudGeometryHandlerCustom[cpp.PointXYZ]] PointCloudGeometryHandlerCustom_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerCustom[cpp.PointXYZI]] PointCloudGeometryHandlerCustom_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerCustom[cpp.PointXYZRGB]] PointCloudGeometryHandlerCustom_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudGeometryHandlerCustom[cpp.PointXYZRGBA]] PointCloudGeometryHandlerCustom_PointXYZRGBA_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <>
+# class PCL_EXPORTS PointCloudGeometryHandler<sensor_msgs::PointCloud2>
+        # public:
+        # typedef sensor_msgs::PointCloud2 PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<PointCloudGeometryHandler<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudGeometryHandler<PointCloud> > ConstPtr;
+        
+        # /** \brief Constructor. */
+        # PointCloudGeometryHandler (const PointCloudConstPtr &cloud, const Eigen::Vector4f &sensor_origin = Eigen::Vector4f::Zero ())
+        
+        # /** \brief Abstract getName method. */
+        # virtual std::string getName () const = 0;
+        
+        # /** \brief Abstract getFieldName method. */
+        # virtual std::string getFieldName () const  = 0;
+        
+        # /** \brief Check if this handler is capable of handling the input data or not. */
+        # inline bool isCapable () const { return (capable_); }
+        
+        # /** \brief Obtain the actual point geometry for the input dataset in VTK format.
+        #   * \param[out] points the resultant geometry
+        # virtual void getGeometry (vtkSmartPointer<vtkPoints> &points) const;
+###
+
+# point_cloud_handlers.h
+# template <>
+# class PCL_EXPORTS PointCloudGeometryHandlerXYZ<sensor_msgs::PointCloud2> : public PointCloudGeometryHandler<sensor_msgs::PointCloud2>
+        # public:
+        # typedef PointCloudGeometryHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<PointCloudGeometryHandlerXYZ<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudGeometryHandlerXYZ<PointCloud> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudGeometryHandlerXYZ (const PointCloudConstPtr &cloud);
+        
+        # /** \brief Destructor. */
+        # virtual ~PointCloudGeometryHandlerXYZ () {}
+        
+        # /** \brief Class getName method. */
+        # virtual inline std::string getName () const { return ("PointCloudGeometryHandlerXYZ"); }
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const { return ("xyz"); }
+###
+
+# point_cloud_handlers.h
+# template <>
+# class PCL_EXPORTS PointCloudGeometryHandlerSurfaceNormal<sensor_msgs::PointCloud2> : public PointCloudGeometryHandler<sensor_msgs::PointCloud2>
+        # public:
+        # typedef PointCloudGeometryHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<PointCloudGeometryHandlerSurfaceNormal<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudGeometryHandlerSurfaceNormal<PointCloud> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudGeometryHandlerSurfaceNormal (const PointCloudConstPtr &cloud);
+        
+        # /** \brief Class getName method. */
+        # virtual inline std::string getName () const { return ("PointCloudGeometryHandlerSurfaceNormal"); }
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const { return ("normal_xyz"); }
+###
+
+# point_cloud_handlers.h
+# template <>
+# class PCL_EXPORTS PointCloudGeometryHandlerCustom<sensor_msgs::PointCloud2> : public PointCloudGeometryHandler<sensor_msgs::PointCloud2>
+        # public:
+        # typedef PointCloudGeometryHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudGeometryHandlerCustom (const PointCloudConstPtr &cloud,
+        #                                  const std::string &x_field_name,
+        #                                  const std::string &y_field_name,
+        #                                  const std::string &z_field_name);
+        # /** \brief Destructor. */
+        # virtual ~PointCloudGeometryHandlerCustom () {}
+        
+        # /** \brief Class getName method. */
+        # virtual inline std::string getName () const { return ("PointCloudGeometryHandlerCustom"); }
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const { return (field_name_); }
+
+
+###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudColorHandlerRandom : public PointCloudColorHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudColorHandlerRandom[PointT](PointCloudColorHandler[PointT]):
+        PointCloudColorHandlerRandom()
+        # typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerRandom<PointT> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerRandom<PointT> > ConstPtr;
+        
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerRandom (const PointCloudConstPtr &cloud) :
+        
+        # /** \brief Abstract getName method. */
+        # virtual inline std::string getName () const
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const
+        
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+
+
+ctypedef PointCloudColorHandlerRandom[cpp.PointXYZ] PointCloudColorHandlerRandom_t
+ctypedef PointCloudColorHandlerRandom[cpp.PointXYZI] PointCloudColorHandlerRandom_PointXYZI_t
+ctypedef PointCloudColorHandlerRandom[cpp.PointXYZRGB] PointCloudColorHandlerRandom_PointXYZRGB_t
+ctypedef PointCloudColorHandlerRandom[cpp.PointXYZRGBA] PointCloudColorHandlerRandom_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudColorHandlerRandom[cpp.PointXYZ]] PointCloudColorHandlerRandom_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerRandom[cpp.PointXYZI]] PointCloudColorHandlerRandom_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerRandom[cpp.PointXYZRGB]] PointCloudColorHandlerRandom_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerRandom[cpp.PointXYZRGBA]] PointCloudColorHandlerRandom_PointXYZRGBA_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudColorHandlerRGBField : public PointCloudColorHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudColorHandlerRGBField[PointT](PointCloudColorHandler[PointT]):
+        # PointCloudColorHandlerRGBField ()
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerRGBField (const PointCloudConstPtr &cloud);
+        PointCloudColorHandlerRGBField (const shared_ptr[cpp.PointCloud[PointT]] &cloud)
+        
+        # typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerRGBField<PointT> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerRGBField<PointT> > ConstPtr;
+        
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerRGBField (const PointCloudConstPtr &cloud);
+        
+        # /** \brief Destructor. */
+        # virtual ~PointCloudColorHandlerRGBField () {}
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const { return ("rgb"); }
+        
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+
+
+ctypedef PointCloudColorHandlerRGBField[cpp.PointXYZ] PointCloudColorHandlerRGBField_t
+ctypedef PointCloudColorHandlerRGBField[cpp.PointXYZI] PointCloudColorHandlerRGBField_PointXYZI_t
+ctypedef PointCloudColorHandlerRGBField[cpp.PointXYZRGB] PointCloudColorHandlerRGBField_PointXYZRGB_t
+ctypedef PointCloudColorHandlerRGBField[cpp.PointXYZRGBA] PointCloudColorHandlerRGBField_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudColorHandlerRGBField[cpp.PointXYZ]] PointCloudColorHandlerRGBField_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerRGBField[cpp.PointXYZI]] PointCloudColorHandlerRGBField_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerRGBField[cpp.PointXYZRGB]] PointCloudColorHandlerRGBField_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerRGBField[cpp.PointXYZRGBA]] PointCloudColorHandlerRGBField_PointXYZRGBA_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudColorHandlerHSVField : public PointCloudColorHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudColorHandlerHSVField[PointT](PointCloudColorHandler[PointT]):
+        # PointCloudColorHandlerHSVField ()
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerHSVField (const PointCloudConstPtr &cloud);
+        PointCloudColorHandlerHSVField (const shared_ptr[cpp.PointCloud[PointT]] &cloud)
+        
+        # typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerHSVField<PointT> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerHSVField<PointT> > ConstPtr;
+        
+        
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const { return ("hsv"); }
+        
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        #   */
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+
+
+ctypedef PointCloudColorHandlerHSVField[cpp.PointXYZ] PointCloudColorHandlerHSVField_t
+ctypedef PointCloudColorHandlerHSVField[cpp.PointXYZI] PointCloudColorHandlerHSVField_PointXYZI_t
+ctypedef PointCloudColorHandlerHSVField[cpp.PointXYZRGB] PointCloudColorHandlerHSVField_PointXYZRGB_t
+ctypedef PointCloudColorHandlerHSVField[cpp.PointXYZRGBA] PointCloudColorHandlerHSVField_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudColorHandlerHSVField[cpp.PointXYZ]] PointCloudColorHandlerHSVField_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerHSVField[cpp.PointXYZI]] PointCloudColorHandlerHSVField_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerHSVField[cpp.PointXYZRGB]] PointCloudColorHandlerHSVField_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerHSVField[cpp.PointXYZRGBA]] PointCloudColorHandlerHSVField_PointXYZRGBA_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <typename PointT>
+# class PointCloudColorHandlerGenericField : public PointCloudColorHandler<PointT>
+cdef extern from "pcl/visualization/point_cloud_handlers.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PointCloudColorHandlerGenericField[PointT](PointCloudColorHandler[PointT]):
+        PointCloudColorHandlerGenericField ()
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerGenericField (const PointCloudConstPtr &cloud, const std::string &field_name);
+        PointCloudColorHandlerGenericField (const shared_ptr[cpp.PointCloud[PointT]] &cloud, const string &field_name)
+        
+        # typedef typename PointCloudColorHandler<PointT>::PointCloud PointCloud;
+        # typedef typename PointCloud::Ptr PointCloudPtr;
+        # typedef typename PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerGenericField<PointT> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerGenericField<PointT> > ConstPtr;
+        
+        # /** \brief Destructor. */
+        # virtual ~PointCloudColorHandlerGenericField () {}
+        
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const { return (field_name_); }
+        
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+
+
+ctypedef PointCloudColorHandlerGenericField[cpp.PointXYZ] PointCloudColorHandlerGenericField_t
+ctypedef PointCloudColorHandlerGenericField[cpp.PointXYZI] PointCloudColorHandlerGenericField_PointXYZI_t
+ctypedef PointCloudColorHandlerGenericField[cpp.PointXYZRGB] PointCloudColorHandlerGenericField_PointXYZRGB_t
+ctypedef PointCloudColorHandlerGenericField[cpp.PointXYZRGBA] PointCloudColorHandlerGenericField_PointXYZRGBA_t
+ctypedef shared_ptr[PointCloudColorHandlerGenericField[cpp.PointXYZ]] PointCloudColorHandlerGenericField_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerGenericField[cpp.PointXYZI]] PointCloudColorHandlerGenericField_PointXYZI_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerGenericField[cpp.PointXYZRGB]] PointCloudColorHandlerGenericField_PointXYZRGB_Ptr_t
+ctypedef shared_ptr[PointCloudColorHandlerGenericField[cpp.PointXYZRGBA]] PointCloudColorHandlerGenericField_PointXYZRGBA_Ptr_t
+###
+
+# point_cloud_handlers.h
+# template <>
+# class PCL_EXPORTS PointCloudColorHandler<sensor_msgs::PointCloud2>
+        # public:
+        # typedef sensor_msgs::PointCloud2 PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # typedef boost::shared_ptr<PointCloudColorHandler<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandler<PointCloud> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudColorHandler (const PointCloudConstPtr &cloud) :
+        # /** \brief Destructor. */
+        # virtual ~PointCloudColorHandler () {}
+        # /** \brief Return whether this handler is capable of handling the input data or not. */
+        # inline bool
+        # isCapable () const { return (capable_); }
+        # /** \brief Abstract getName method. */
+        # virtual std::string
+        # getName () const = 0;
+        # /** \brief Abstract getFieldName method. */
+        # virtual std::string
+        # getFieldName () const = 0;
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void
+        # getColor (vtkSmartPointer<vtkDataArray> &scalars) const = 0;
+
+
+###
+
+# template <>
+# class PCL_EXPORTS PointCloudColorHandlerRandom<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
+        # typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerRandom<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerRandom<PointCloud> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerRandom (const PointCloudConstPtr &cloud) :
+        # /** \brief Get the name of the class. */
+        # virtual inline std::string getName () const
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+###
+
+# template <>
+# class PCL_EXPORTS PointCloudColorHandlerCustom<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
+        # typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerCustom (const PointCloudConstPtr &cloud, double r, double g, double b) :
+        # /** \brief Get the name of the class. */
+        # virtual inline std::string getName () const
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+        # protected:
+        # /** \brief Internal R, G, B holding the values given by the user. */
+        # double r_, g_, b_;
+###
+
+# template <>
+# class PCL_EXPORTS PointCloudColorHandlerRGBField<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
+        # typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerRGBField<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerRGBField<PointCloud> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerRGBField (const PointCloudConstPtr &cloud);
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+        # protected:
+        # /** \brief Get the name of the class. */
+        # virtual inline std::string getName () const { return ("PointCloudColorHandlerRGBField"); }
+        # /** \brief Get the name of the field used. */
+        # virtual std::string getFieldName () const { return ("rgb"); }
+###
+
+# template <>
+# class PCL_EXPORTS PointCloudColorHandlerHSVField<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
+        # typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerHSVField<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerHSVField<PointCloud> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerHSVField (const PointCloudConstPtr &cloud);
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+
+
+###
+
+# template <>
+# class PCL_EXPORTS PointCloudColorHandlerGenericField<sensor_msgs::PointCloud2> : public PointCloudColorHandler<sensor_msgs::PointCloud2>
+        # typedef PointCloudColorHandler<sensor_msgs::PointCloud2>::PointCloud PointCloud;
+        # typedef PointCloud::Ptr PointCloudPtr;
+        # typedef PointCloud::ConstPtr PointCloudConstPtr;
+        # public:
+        # typedef boost::shared_ptr<PointCloudColorHandlerGenericField<PointCloud> > Ptr;
+        # typedef boost::shared_ptr<const PointCloudColorHandlerGenericField<PointCloud> > ConstPtr;
+        # /** \brief Constructor. */
+        # PointCloudColorHandlerGenericField (const PointCloudConstPtr &cloud, const std::string &field_name);
+        
+        # /** \brief Obtain the actual color for the input dataset as vtk scalars.
+        #   * \param[out] scalars the output scalars containing the color for the dataset
+        # virtual void getColor (vtkSmartPointer<vtkDataArray> &scalars) const;
+
+
+###
+
+
+# pcl_visualizer.h
+# class PCL_EXPORTS PCLVisualizer
+cdef extern from "pcl/visualization/pcl_visualizer.h" namespace "pcl::visualization" nogil:
+    cdef cppclass PCLVisualizer:
+        PCLVisualizer()
+        # public:
+        # brief PCL Visualizer constructor.
+        # param[in] name the window name (empty by default)
+        # param[in] create_interactor if true (default), create an interactor, false otherwise
+        # PCLVisualizer (const std::string &name = "", const bool create_interactor = true);
+        PCLVisualizer (const string name, bool create_interactor)
+        
+        # brief PCL Visualizer constructor.
+        # param[in] argc
+        # param[in] argv
+        # param[in] name the window name (empty by default)
+        # param[in] style interactor style (defaults to PCLVisualizerInteractorStyle)
+        # param[in] create_interactor if true (default), create an interactor, false otherwise
+        # PCLVisualizer (int &argc, char **argv, const std::string &name = "", PCLVisualizerInteractorStyle* style = PCLVisualizerInteractorStyle::New (), const bool create_interactor = true);
+        # 
+        # PCLVisualizer (int &argc, char **argv, const std::string &name = "", PCLVisualizerInteractorStyle* style = PCLVisualizerInteractorStyle::New (), const bool create_interactor = true)
+        
+        # brief PCL Visualizer destructor.
+        # virtual ~PCLVisualizer ();
+        
+        # brief Enables/Disabled the underlying window mode to full screen.
+        # note This might or might not work, depending on your window manager.
+        # See the VTK documentation for additional details.
+        # param[in] mode true for full screen, false otherwise
+        # inline void setFullScreen (bool mode)
+        void setFullScreen (bool mode)
+        
+        # brief Enables or disable the underlying window borders.
+        # note This might or might not work, depending on your window manager.
+        # See the VTK documentation for additional details.
+        # param[in] mode true for borders, false otherwise
+        # inline void setWindowBorders (bool mode)
+        void setWindowBorders (bool mode)
+        
+        # brief Register a callback boost::function for keyboard events
+        # param[in] cb a boost function that will be registered as a callback for a keyboard event
+        # return a connection object that allows to disconnect the callback function.
+        # boost::signals2::connection registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)> cb);
+        
+        # brief Register a callback function for keyboard events
+        # param[in] callback  the function that will be registered as a callback for a keyboard event
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # inline boost::signals2::connection
+        # registerKeyboardCallback (void (*callback) (const pcl::visualization::KeyboardEvent&, void*), void* cookie = NULL)
+        
+        # brief Register a callback function for keyboard events
+        # param[in] callback the member function that will be registered as a callback for a keyboard event
+        # param[in] instance instance to the class that implements the callback function
+        # param[in] cookie   user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # template<typename T> inline boost::signals2::connection
+        # registerKeyboardCallback (void (T::*callback) (const pcl::visualization::KeyboardEvent&, void*), T& instance, void* cookie = NULL)
+        
+        # brief Register a callback function for mouse events
+        # param[in] cb a boost function that will be registered as a callback for a mouse event
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # boost::signals2::connection
+        # registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)> cb);
+        
+        # brief Register a callback function for mouse events
+        # param[in] callback  the function that will be registered as a callback for a mouse event
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # inline boost::signals2::connection
+        # registerMouseCallback (void (*callback) (const pcl::visualization::MouseEvent&, void*), void* cookie = NULL)
+        
+        # brief Register a callback function for mouse events
+        # param[in] callback  the member function that will be registered as a callback for a mouse event
+        # param[in] instance  instance to the class that implements the callback function
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # template<typename T> inline boost::signals2::connection
+        # registerMouseCallback (void (T::*callback) (const pcl::visualization::MouseEvent&, void*), T& instance, void* cookie = NULL)
+        
+        # brief Register a callback function for point picking events
+        # param[in] cb a boost function that will be registered as a callback for a point picking event
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # boost::signals2::connection
+        # registerPointPickingCallback (boost::function<void (const pcl::visualization::PointPickingEvent&)> cb);
+        
+        # brief Register a callback function for point picking events
+        # param[in] callback  the function that will be registered as a callback for a point picking event
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # inline boost::signals2::connection
+        # registerPointPickingCallback (void (*callback) (const pcl::visualization::PointPickingEvent&, void*), void* cookie = NULL)
+        
+        # brief Register a callback function for point picking events
+        # param[in] callback  the member function that will be registered as a callback for a point picking event
+        # param[in] instance  instance to the class that implements the callback function
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # 
+        # template<typename T> inline boost::signals2::connection
+        # registerPointPickingCallback (void (T::*callback) (const pcl::visualization::PointPickingEvent&, void*), T& instance, void* cookie = NULL)
+        
+        # brief Spin method. Calls the interactor and runs an internal loop.
+        void spin ()
+        
+        # brief Spin once method. Calls the interactor and updates the screen once.
+        # param[in] time - How long (in ms) should the visualization loop be allowed to run.
+        # param[in] force_redraw - if false it might return without doing anything if the
+        # interactor's framerate does not require a redraw yet.
+        # void spinOnce (int time = 1, bool force_redraw = false)
+        void spinOnce (int time, bool force_redraw)
+        
+        # brief Adds 3D axes describing a coordinate system to screen at 0,0,0.
+        # param[in] scale the scale of the axes (default: 1)
+        # param[in] viewport the view port where the 3D axes should be added (default: all)
+        # 
+        # void addCoordinateSystem (double scale = 1.0, int viewport = 0);
+        void addCoordinateSystem (double scale, int viewport)
+        
+        # brief Adds 3D axes describing a coordinate system to screen at x, y, z
+        # param[in] scale the scale of the axes (default: 1)
+        # param[in] x the X position of the axes
+        # param[in] y the Y position of the axes
+        # param[in] z the Z position of the axes
+        # param[in] viewport the view port where the 3D axes should be added (default: all)
+        # 
+        # void addCoordinateSystem (double scale, float x, float y, float z, int viewport = 0);
+        void addCoordinateSystem (double scale, float x, float y, float z, int viewport)
+        
+        # brief Adds 3D axes describing a coordinate system to screen at x, y, z, Roll,Pitch,Yaw
+        # param[in] scale the scale of the axes (default: 1)
+        # param[in] t transformation matrix
+        # param[in] viewport the view port where the 3D axes should be added (default: all)
+        # RPY Angles
+        # Rotate the reference frame by the angle roll about axis x
+        # Rotate the reference frame by the angle pitch about axis y
+        # Rotate the reference frame by the angle yaw about axis z
+        # Description:
+        # Sets the orientation of the Prop3D.  Orientation is specified as
+        # X,Y and Z rotations in that order, but they are performed as
+        # RotateZ, RotateX, and finally RotateY.
+        # All axies use right hand rule. x=red axis, y=green axis, z=blue axis
+        # z direction is point into the screen.
+        #     z
+        #      \
+        #       \
+        #        \
+        #         -----------> x
+        #         |
+        #         |
+        #         |
+        #         |
+        #         |
+        #         |
+        #         y
+        # 
+        # void addCoordinateSystem (double scale, const Eigen::Affine3f& t, int viewport = 0);
+        void addCoordinateSystem (double scale, const eigen3.Affine3f& t, int viewport)
+        
+        # brief Removes a previously added 3D axes (coordinate system)
+        # param[in] viewport view port where the 3D axes should be removed from (default: all)
+        # bool removeCoordinateSystem (int viewport = 0);
+        bool removeCoordinateSystem (int viewport)
+        
+        # brief Removes a Point Cloud from screen, based on a given ID.
+        # param[in] id the point cloud object id (i.e., given on \a addPointCloud)
+        # param[in] viewport view port from where the Point Cloud should be removed (default: all)
+        # return true if the point cloud is successfully removed and false if the point cloud is
+        # not actually displayed
+        # bool removePointCloud (const std::string &id = "cloud", int viewport = 0);
+        bool removePointCloud (const string &id, int viewport)
+        
+        # brief Removes a PolygonMesh from screen, based on a given ID.
+        # param[in] id the polygon object id (i.e., given on \a addPolygonMesh)
+        # param[in] viewport view port from where the PolygonMesh should be removed (default: all)
+        # inline bool removePolygonMesh (const std::string &id = "polygon", int viewport = 0)
+        bool removePolygonMesh (const string &id, int viewport)
+        
+        # brief Removes an added shape from screen (line, polygon, etc.), based on a given ID
+        # note This methods also removes PolygonMesh objects and PointClouds, if they match the ID
+        # param[in] id the shape object id (i.e., given on \a addLine etc.)
+        # param[in] viewport view port from where the Point Cloud should be removed (default: all)
+        # bool removeShape (const std::string &id = "cloud", int viewport = 0);
+        bool removeShape (const string &id, int viewport)
+        
+        # brief Removes an added 3D text from the scene, based on a given ID
+        # param[in] id the 3D text id (i.e., given on \a addText3D etc.)
+        # param[in] viewport view port from where the 3D text should be removed (default: all)
+        # bool removeText3D (const std::string &id = "cloud", int viewport = 0);
+        bool removeText3D (const string &id, int viewport)
+        
+        # brief Remove all point cloud data on screen from the given viewport.
+        # param[in] viewport view port from where the clouds should be removed (default: all)
+        # bool removeAllPointClouds (int viewport = 0);
+        bool removeAllPointClouds (int viewport)
+        
+        # brief Remove all 3D shape data on screen from the given viewport.
+        # param[in] viewport view port from where the shapes should be removed (default: all)
+        # bool removeAllShapes (int viewport = 0);
+        bool removeAllShapes (int viewport)
+        
+        # brief Set the viewport's background color.
+        # param[in] r the red component of the RGB color
+        # param[in] g the green component of the RGB color
+        # param[in] b the blue component of the RGB color
+        # param[in] viewport the view port (default: all)
+        # void setBackgroundColor (const double &r, const double &g, const double &b, int viewport = 0);
+        void setBackgroundColor (const double &r, const double &g, const double &b, int viewport)
+        
+        ### addText function
+        # brief Add a text to screen
+        # param[in] text the text to add
+        # param[in] xpos the X position on screen where the text should be added
+        # param[in] ypos the Y position on screen where the text should be added
+        # param[in] id the text object id (default: equal to the "text" parameter)
+        # param[in] viewport the view port (default: all)
+        # bool addText (
+        #          const std::string &text,
+        #          int xpos, int ypos,
+        #          const std::string &id = "", int viewport = 0);
+        bool addText (const string &text, int xpos, int ypos, const string &id, int viewport)
+        
+        # brief Add a text to screen
+        # param[in] text the text to add
+        # param[in] xpos the X position on screen where the text should be added
+        # param[in] ypos the Y position on screen where the text should be added
+        # param[in] r the red color value
+        # param[in] g the green color value
+        # param[in] b the blue color vlaue
+        # param[in] id the text object id (default: equal to the "text" parameter)
+        # param[in] viewport the view port (default: all)
+        # bool addText (const std::string &text, int xpos, int ypos, double r, double g, double b,
+        #               const std::string &id = "", int viewport = 0);
+        bool addText (const string &text, int xpos, int ypos, double r, double g, double b, const string &id, int viewport)
+        # bool addText_rgb "addText" (const string &text, int xpos, int ypos, double r, double g, double b, const string &id, int viewport)
+        
+        # brief Add a text to screen
+        # param[in] text the text to add
+        # param[in] xpos the X position on screen where the text should be added
+        # param[in] ypos the Y position on screen where the text should be added
+        # param[in] fontsize the fontsize of the text
+        # param[in] r the red color value
+        # param[in] g the green color value
+        # param[in] b the blue color vlaue
+        # param[in] id the text object id (default: equal to the "text" parameter)
+        # param[in] viewport the view port (default: all)
+        # bool addText (const std::string &text, int xpos, int ypos, int fontsize, double r, double g, double b,
+        #               const std::string &id = "", int viewport = 0);
+        bool addText (const string &text, int xpos, int ypos, int fontsize, double r, double g, double b, const string &id, int viewport)
+        # bool addText_rgb_ftsize "addText" (const string &text, int xpos, int ypos, int fontsize, double r, double g, double b, const string &id, int viewport)
+        
+        ### addText function
+        
+        ### updateText function
+        # brief Update a text to screen
+        # param[in] text the text to update
+        # param[in] xpos the new X position on screen
+        # param[in] ypos the new Y position on screen 
+        # param[in] id the text object id (default: equal to the "text" parameter)
+        bool updateText (const string &text, int xpos, int ypos, const string &id)
+        
+        # brief Update a text to screen
+        # param[in] text the text to update
+        # param[in] xpos the new X position on screen
+        # param[in] ypos the new Y position on screen 
+        # param[in] r the red color value
+        # param[in] g the green color value
+        # param[in] b the blue color vlaue
+        # param[in] id the text object id (default: equal to the "text" parameter)
+        # bool updateText (const std::string &text, 
+        #                  int xpos, int ypos, double r, double g, double b,
+        #                  const std::string &id = "");
+        bool updateText (const string &text, int xpos, int ypos, double r, double g, double b, const string &id)
+        # bool updateText_rgb "updateText" (const string &text, int xpos, int ypos, double r, double g, double b, const string &id)
+        
+        # brief Update a text to screen
+        # param[in] text the text to update
+        # param[in] xpos the new X position on screen
+        # param[in] ypos the new Y position on screen 
+        # param[in] fontsize the fontsize of the text
+        # param[in] r the red color value
+        # param[in] g the green color value
+        # param[in] b the blue color vlaue
+        # param[in] id the text object id (default: equal to the "text" parameter)
+        # bool updateText (const std::string &text, 
+        #                  int xpos, int ypos, int fontsize, double r, double g, double b,
+        #                  const std::string &id = "");
+        bool updateText (const string &text, int xpos, int ypos, int fontsize, double r, double g, double b, const string &id)
+        # bool updateText_rgb_ftsize "updateText" (const string &text, int xpos, int ypos, int fontsize, double r, double g, double b, const string &id)
+        
+        ### updateText function
+        
+        # brief Set the pose of an existing shape. 
+        # Returns false if the shape doesn't exist, true if the pose was succesfully 
+        # updated.
+        # param[in] id the shape or cloud object id (i.e., given on \a addLine etc.)
+        # param[in] pose the new pose
+        # return false if no shape or cloud with the specified ID was found
+        # bool updateShapePose (const std::string &id, const Eigen::Affine3f& pose);
+        bool updateShapePose (const string &id, const eigen3.Affine3f& pose)
+        
+        # brief Add a 3d text to the scene
+        # param[in] text the text to add
+        # param[in] position the world position where the text should be added
+        # param[in] textScale the scale of the text to render
+        # param[in] r the red color value
+        # param[in] g the green color value
+        # param[in] b the blue color value
+        # param[in] id the text object id (default: equal to the "text" parameter)
+        # param[in] viewport the view port (default: all)
+        # template <typename PointT> bool
+        # addText3D (const std::string &text,
+        #            const PointT &position,
+        #            double textScale = 1.0,
+        #            double r = 1.0, double g = 1.0, double b = 1.0, const std::string &id = "", int viewport = 0);
+        bool addText3D[PointT](const string &text, const PointT &position, double textScale, double r, double g, double b, const string &id, int viewport)
+        
+        ###
+        # brief Add the estimated surface normals of a Point Cloud to screen.
+        # param[in] cloud the input point cloud dataset containing XYZ data and normals
+        # param[in] level display only every level'th point (default: 100)
+        # param[in] scale the normal arrow scale (default: 0.02m)
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointNT> bool
+        # addPointCloudNormals (const typename pcl::PointCloud<PointNT>::ConstPtr &cloud, int level = 100, double scale = 0.02, const std::string &id = "cloud", int viewport = 0);
+        bool addPointCloudNormals[PointNT](cpp.PointCloud[PointNT] cloud, int level, double scale, string id, int viewport)
+        
+        # brief Add the estimated surface normals of a Point Cloud to screen.
+        # param[in] cloud the input point cloud dataset containing the XYZ data
+        # param[in] normals the input point cloud dataset containing the normal data
+        # param[in] level display only every level'th point (default: 100)
+        # param[in] scale the normal arrow scale (default: 0.02m)
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT, typename PointNT> bool
+        # addPointCloudNormals (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #                       const typename pcl::PointCloud<PointNT>::ConstPtr &normals,
+        #                       int level = 100, double scale = 0.02, const std::string &id = "cloud", int viewport = 0);
+        bool addPointCloudNormals [PointT, PointNT] (const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[cpp.PointCloud[PointNT]] &normals, int level, double scale, const string &id, int viewport)
+        
+        ### addPointCloudPrincipalCurvatures function ###
+        ### PCL 1.6.0 NG (not define)
+        ### PCL 1.7.2 
+        # brief Add the estimated principal curvatures of a Point Cloud to screen.
+        # param[in] cloud the input point cloud dataset containing the XYZ data
+        # param[in] normals the input point cloud dataset containing the normal data
+        # param[in] pcs the input point cloud dataset containing the principal curvatures data
+        # param[in] level display only every level'th point. Default: 100
+        # param[in] scale the normal arrow scale. Default: 1.0
+        # param[in] id the point cloud object id. Default: "cloud"
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # bool addPointCloudPrincipalCurvatures (
+        #     const pcl::PointCloud<pcl::PointXYZ>::ConstPtr &cloud,
+        #     const pcl::PointCloud<pcl::Normal>::ConstPtr &normals,
+        #     const pcl::PointCloud<pcl::PrincipalCurvatures>::ConstPtr &pcs,
+        #     int level = 100, double scale = 1.0,
+        #     const std::string &id = "cloud", int viewport = 0);
+        # bool addPointCloudPrincipalCurvatures (
+        #             const shared_ptr[cpp.PointCloud[cpp.PointXYZ]] &cloud,
+        #             const shared_ptr[cpp.PointCloud[cpp.Normal]] &normals,
+        #             const shared_ptr[cpp.PointCloud[cpp.PrincipalCurvatures]] &pcs,
+        #             int level, double scale, string &id, int viewport)
+        
+        ### addPointCloudPrincipalCurvatures function ###
+        
+        ### updatePointCloud Functions ###
+        # brief Updates the XYZ data for an existing cloud object id on screen.
+        # param[in] cloud the input point cloud dataset
+        # param[in] id the point cloud object id to update (default: cloud)
+        # return false if no cloud with the specified ID was found
+        # template <typename PointT> bool updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, const std::string &id = "cloud");
+        bool updatePointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, string &id)
+        
+        # brief Updates the XYZ data for an existing cloud object id on screen.
+        # param[in] cloud the input point cloud dataset
+        # param[in] geometry_handler the geometry handler to use
+        # param[in] id the point cloud object id to update (default: cloud)
+        # return false if no cloud with the specified ID was found
+        # template <typename PointT> bool
+        # updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, const PointCloudGeometryHandler<PointT> &geometry_handler, const std::string &id = "cloud");
+        # bool updatePointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudGeometryHandler[PointT] &geometry_handler, string &id)
+        bool updatePointCloud_GeometryHandler "updatePointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudGeometryHandler[PointT] &geometry_handler, string &id)
+        
+        # brief Updates the XYZ data for an existing cloud object id on screen.
+        # param[in] cloud the input point cloud dataset
+        # param[in] color_handler the color handler to use
+        # param[in] id the point cloud object id to update (default: cloud)
+        # return false if no cloud with the specified ID was found
+        # template <typename PointT> bool
+        # updatePointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, const PointCloudColorHandler<PointT> &color_handler, const std::string &id = "cloud");
+        # bool updatePointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandler[PointT] &color_handler, const string &id)
+        bool updatePointCloud_ColorHandler "updatePointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandler[PointT] &color_handler, const string &id)
+        
+        ### updatePointCloud Functions ###
+        
+        ### addPointCloud Functions ###
+        # typedef boost::shared_ptr<const PointCloudColorHandler<PointT> > ConstPtr;
+        # brief Add a Point Cloud (templated) to screen.
+        # param[in] cloud the input point cloud dataset
+        # param[in] id the point cloud object id (default: cloud)
+        # param viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT> bool
+        # addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, const std::string &id = "cloud", int viewport = 0);
+        bool addPointCloud[PointT] (const shared_ptr[const cpp.PointCloud[PointT]] &cloud, string id, int viewport)
+        
+        # brief Add a Point Cloud (templated) to screen.
+        # param[in] cloud the input point cloud dataset
+        # param[in] geometry_handler use a geometry handler object to extract the XYZ data
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT> bool
+        # addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #                const PointCloudGeometryHandler<PointT> &geometry_handler,
+        #                const std::string &id = "cloud", int viewport = 0);
+        # bool addPointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudGeometryHandler[PointT] &geometry_handler, const string &id, int viewport)
+        bool addPointCloud_GeometryHandler "addPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudGeometryHandler[PointT] &geometry_handler, const string &id, int viewport)
+        
+        # \brief Add a Point Cloud (templated) to screen.
+        # Because the geometry handler is given as a pointer, it will be pushed back to the list of available
+        # handlers, rather than replacing the current active geometric handler. This makes it possible to
+        # switch between different geometric handlers 'on-the-fly' at runtime, from the PCLVisualizer
+        # interactor interface (using Alt+0..9).
+        # \param[in] cloud the input point cloud dataset
+        # \param[in] geometry_handler use a geometry handler object to extract the XYZ data
+        # \param[in] id the point cloud object id (default: cloud)
+        # \param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT> bool
+        # addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, const GeometryHandlerConstPtr &geometry_handler, const std::string &id = "cloud", int viewport = 0);
+        # set BaseClass(use NG)
+        # bool addPointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudGeometryHandler[PointT]] &geometry_handler, const string &id, int viewport)
+        # set InheritanceClass
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudGeometryHandlerCustom[PointT]] &geometry_handler, const string &id, int viewport)
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudGeometryHandlerSurfaceNormal[PointT]] &geometry_handler, const string &id, int viewport)
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudGeometryHandlerXYZ[PointT]] &geometry_handler, const string &id, int viewport)
+        bool addPointCloud_GeometryHandler2 "addPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudGeometryHandlerXYZ[PointT]] &geometry_handler, const string &id, int viewport)
+        
+        # brief Add a Point Cloud (templated) to screen.
+        # param[in] cloud the input point cloud dataset
+        # param[in] color_handler a specific PointCloud visualizer handler for colors
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT> bool
+        # addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, const PointCloudColorHandler<PointT> &color_handler, const std::string &id = "cloud", int viewport = 0);
+        # set BaseClass(use NG)
+        bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandlerCustom[PointT] &color_handler, const string &id, int viewport)
+        # set InheritanceClass
+        bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandler[PointT] color_handler, const string &id, int viewport)
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandlerGenericField[PointT] color_handler, const string &id, int viewport)
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandlerHSVField[PointT] color_handler, const string &id, int viewport)
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandlerRandom[PointT] color_handler, const string &id, int viewport)
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandlerRGBField[PointT] color_handler, const string &id, int viewport)
+        bool addPointCloud_ColorHandler "addPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandlerCustom[PointT] &color_handler, const string &id, int viewport)
+        
+        # brief Add a Point Cloud (templated) to screen.
+        # Because the color handler is given as a pointer, it will be pushed back to the list of available
+        # handlers, rather than replacing the current active color handler. This makes it possible to
+        # switch between different color handlers 'on-the-fly' at runtime, from the PCLVisualizer
+        # interactor interface (using 0..9).
+        # param[in] cloud the input point cloud dataset
+        # param[in] color_handler a specific PointCloud visualizer handler for colors
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT> bool
+        # addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud, const ColorHandlerConstPtr &color_handler, const std::string &id = "cloud", int viewport = 0);
+        # bool addPointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudColorHandler[PointT]] &color_handler, const string &id, int viewport)
+        bool addPointCloud_ColorHandler2 "addPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudColorHandler[PointT]] &color_handler, const string &id, int viewport)
+        
+        # brief Add a Point Cloud (templated) to screen.
+        # param[in] cloud the input point cloud dataset
+        # param[in] color_handler a specific PointCloud visualizer handler for colors
+        # param[in] geometry_handler use a geometry handler object to extract the XYZ data
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT> bool
+        # addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #                const PointCloudColorHandler<PointT> &color_handler,
+        #                const PointCloudGeometryHandler<PointT> &geometry_handler,
+        #                const std::string &id = "cloud", int viewport = 0);
+        # bool addPointCloud [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandler[PointT] &color_handler, const PointCloudGeometryHandler[PointT] &geometry_handler, const string &id, int viewport)
+        bool addPointCloud_ColorGeometryHandler "addPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudColorHandler[PointT] &color_handler, const PointCloudGeometryHandler[PointT] &geometry_handler, const string &id, int viewport)
+        
+        # brief Add a Point Cloud (templated) to screen.
+        # Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
+        # available handlers, rather than replacing the current active handler. This makes it possible to
+        # switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
+        # interface (using [Alt+]0..9).
+        # param[in] cloud the input point cloud dataset
+        # param[in] geometry_handler a specific PointCloud visualizer handler for geometry
+        # param[in] color_handler a specific PointCloud visualizer handler for colors
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # template <typename PointT> bool
+        # addPointCloud (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #                const GeometryHandlerConstPtr &geometry_handler,
+        #                const ColorHandlerConstPtr &color_handler,
+        #                const std::string &id = "cloud", int viewport = 0);
+        # bool addPointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudGeometryHandler[PointT] &geometry_handler, const shared_ptr[PointCloudColorHandler[PointT]] &color_handler, const string &id, int viewport)
+        # bool addPointCloud_ColorGeometryHandler2 "addPointCloud" [PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[PointCloudGeometryHandler[PointT] &geometry_handler, const shared_ptr[PointCloudColorHandler[PointT]] &color_handler, const string &id, int viewport)
+        
+        # brief Add a binary blob Point Cloud to screen.
+        # Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
+        # available handlers, rather than replacing the current active handler. This makes it possible to
+        # switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
+        # interface (using [Alt+]0..9).
+        # param[in] cloud the input point cloud dataset
+        # param[in] geometry_handler a specific PointCloud visualizer handler for geometry
+        # param[in] color_handler a specific PointCloud visualizer handler for colors
+        # param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
+        # param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # pcl 1.6.0
+        # bool addPointCloud (const sensor_msgs::PointCloud2::ConstPtr &cloud,
+        #                const GeometryHandlerConstPtr &geometry_handler,
+        #                const ColorHandlerConstPtr &color_handler,
+        #                const Eigen::Vector4f& sensor_origin,
+        #                const Eigen::Quaternion<float>& sensor_orientation,
+        #                const std::string &id = "cloud", int viewport = 0);
+        
+        # brief Add a binary blob Point Cloud to screen.
+        # Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
+        # available handlers, rather than replacing the current active handler. This makes it possible to
+        # switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
+        # interface (using [Alt+]0..9).
+        # param[in] cloud the input point cloud dataset
+        # param[in] geometry_handler a specific PointCloud visualizer handler for geometry
+        # param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
+        # param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # pcl 1.6.0
+        # bool addPointCloud (const sensor_msgs::PointCloud2::ConstPtr &cloud,
+        #                const GeometryHandlerConstPtr &geometry_handler,
+        #                const Eigen::Vector4f& sensor_origin,
+        #                const Eigen::Quaternion<float>& sensor_orientation,
+        #                const std::string &id = "cloud", int viewport = 0);
+        
+        # brief Add a binary blob Point Cloud to screen.
+        # Because the geometry/color handler is given as a pointer, it will be pushed back to the list of
+        # available handlers, rather than replacing the current active handler. This makes it possible to
+        # switch between different handlers 'on-the-fly' at runtime, from the PCLVisualizer interactor
+        # interface (using [Alt+]0..9).
+        # param[in] cloud the input point cloud dataset
+        # param[in] color_handler a specific PointCloud visualizer handler for colors
+        # param[in] sensor_origin the origin of the cloud data in global coordinates (defaults to 0,0,0)
+        # param[in] sensor_orientation the orientation of the cloud data in global coordinates (defaults to 1,0,0,0)
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] viewport the view port where the Point Cloud should be added (default: all)
+        # pcl 1.6.0
+        # bool addPointCloud (const sensor_msgs::PointCloud2::ConstPtr &cloud,
+        #                const ColorHandlerConstPtr &color_handler,
+        #                const Eigen::Vector4f& sensor_origin,
+        #                const Eigen::Quaternion<float>& sensor_orientation,
+        #                const std::string &id = "cloud", int viewport = 0);
+        ### addPointCloud
+        
+        # /** \brief Add a PolygonMesh object to screen
+        #   * \param[in] polymesh the polygonal mesh
+        #   * \param[in] id the polygon object id (default: "polygon")
+        #   * \param[in] viewport the view port where the PolygonMesh should be added (default: all)
+        #   */
+        # bool addPolygonMesh (const pcl::PolygonMesh &polymesh, const std::string &id = "polygon", int viewport = 0);
+        bool addPolygonMesh (const cpp.PolygonMesh &polymesh, const string &id, int viewport)
+        
+        # /** \brief Add a PolygonMesh object to screen
+        #   * \param[in] cloud the polygonal mesh point cloud
+        #   * \param[in] vertices the polygonal mesh vertices
+        #   * \param[in] id the polygon object id (default: "polygon")
+        #   * \param[in] viewport the view port where the PolygonMesh should be added (default: all)
+        #   */
+        # template <typename PointT> bool
+        # addPolygonMesh (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #                 const std::vector<pcl::Vertices> &vertices,
+        #                 const std::string &id = "polygon",
+        #                 int viewport = 0);
+        bool addPolygonMesh[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const vector[cpp.Vertices] &vertices, const string &id, int viewport)
+        
+        # /** \brief Update a PolygonMesh object on screen
+        #   * \param[in] cloud the polygonal mesh point cloud
+        #   * \param[in] vertices the polygonal mesh vertices
+        #   * \param[in] id the polygon object id (default: "polygon")
+        #   * \return false if no polygonmesh with the specified ID was found
+        #   */
+        # template <typename PointT> bool
+        # updatePolygonMesh (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #                    const std::vector<pcl::Vertices> &vertices,
+        #                    const std::string &id = "polygon");
+        bool updatePolygonMesh[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const vector[cpp.Vertices] &vertices, const string &id)
+        
+        # /** \brief Add a Polygonline from a polygonMesh object to screen
+        #   * \param[in] polymesh the polygonal mesh from where the polylines will be extracted
+        #   * \param[in] id the polygon object id (default: "polygon")
+        #   * \param[in] viewport the view port where the PolygonMesh should be added (default: all)
+        #   */
+        bool addPolylineFromPolygonMesh (const cpp.PolygonMesh &polymesh, const string &id, int viewport)
+        
+        # /** \brief Add the specified correspondences to the display.
+        #   * \param[in] source_points The source points
+        #   * \param[in] target_points The target points
+        #   * \param[in] correspondences The mapping from source points to target points. Each element must be an index into target_points
+        #   * \param[in] id the polygon object id (default: "correspondences")
+        #   * \param[in] viewport the view port where the correspondences should be added (default: all)
+        #   */
+        # template <typename PointT> bool
+        # addCorrespondences (const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
+        #                     const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
+        #                     const std::vector<int> & correspondences,
+        #                     const std::string &id = "correspondences",
+        #                     int viewport = 0);
+        # bool addCorrespondences[PointT](const shared_ptr[cpp.PointCloud[PointT]] &source_points, const shared_ptr[cpp.PointCloud[PointT]] &target_points, const vector[int] & correspondences, const string &id, int viewport)
+        
+        ### addCorrespondences
+        # /** \brief Add the specified correspondences to the display.
+        #   * \param[in] source_points The source points
+        #   * \param[in] target_points The target points
+        #   * \param[in] correspondences The mapping from source points to target points. Each element must be an index into target_points
+        #   * \param[in] id the polygon object id (default: "correspondences")
+        #   * \param[in] viewport the view port where the correspondences should be added (default: all)
+        #   */
+        # template <typename PointT> bool
+        # addCorrespondences (const typename pcl::PointCloud<PointT>::ConstPtr &source_points,
+        #                     const typename pcl::PointCloud<PointT>::ConstPtr &target_points,
+        #                     const pcl::Correspondences &correspondences,
+        #                     const std::string &id = "correspondences",
+        #                     int viewport = 0);
+        # bool addCorrespondences[PointT](const shared_ptr[cpp.PointCloud[PointT]] &source_points, const shared_ptr[cpp.PointCloud[PointT]] &target_points, const cpp.Correspondences &correspondences, const string &id, int viewport)
+        
+        # /** \brief Remove the specified correspondences from the display.
+        #   * \param[in] id the polygon correspondences object id (i.e., given on \ref addCorrespondences)
+        #   * \param[in] viewport view port from where the correspondences should be removed (default: all)
+        #   */
+        # inline void removeCorrespondences (const std::string &id = "correspondences", int viewport = 0)
+        void removeCorrespondences (const string &id, int viewport)
+        
+        # /** \brief Get the color handler index of a rendered PointCloud based on its ID
+        #   * \param[in] id the point cloud object id
+        #   */
+        # inline int getColorHandlerIndex (const std::string &id)
+        int getColorHandlerIndex (const string &id)
+        
+        # /** \brief Get the geometry handler index of a rendered PointCloud based on its ID
+        #   * \param[in] id the point cloud object id
+        #   */
+        # inline int getGeometryHandlerIndex (const std::string &id)
+        int getGeometryHandlerIndex (const string &id)
+        
+        # /** \brief Update/set the color index of a renderered PointCloud based on its ID
+        #   * \param[in] id the point cloud object id
+        #   * \param[in] index the color handler index to use
+        #   */
+        # bool updateColorHandlerIndex (const std::string &id, int index);
+        bool updateColorHandlerIndex (const string &id, int index)
+        
+        # /** \brief Set the rendering properties of a PointCloud (3x values - e.g., RGB)
+        #   * \param[in] property the property type
+        #   * \param[in] val1 the first value to be set
+        #   * \param[in] val2 the second value to be set
+        #   * \param[in] val3 the third value to be set
+        #   * \param[in] id the point cloud object id (default: cloud)
+        #   * \param[in] viewport the view port where the Point Cloud's rendering properties should be modified (default: all)
+        #   */
+        # bool setPointCloudRenderingProperties (int property, double val1, double val2, double val3, const std::string &id = "cloud", int viewport = 0);
+        bool setPointCloudRenderingProperties (int property, double val1, double val2, double val3, string &id, int viewport)
+        
+        # /** \brief Set the rendering properties of a PointCloud
+        #  * \param[in] property the property type
+        #  * \param[in] value the value to be set
+        #  * \param[in] id the point cloud object id (default: cloud)
+        #  * \param[in] viewport the view port where the Point Cloud's rendering properties should be modified (default: all)
+        #  */
+        # bool setPointCloudRenderingProperties (int property, double value, const std::string &id = "cloud", int viewport = 0);
+        bool setPointCloudRenderingProperties (int property, double value, const string id, int viewport)
+        
+        # /** \brief Get the rendering properties of a PointCloud
+        #  * \param[in] property the property type
+        #  * \param[in] value the resultant property value
+        #  * \param[in] id the point cloud object id (default: cloud)
+        #  */
+        # bool getPointCloudRenderingProperties (int property, double &value, const std::string &id = "cloud");
+        bool getPointCloudRenderingProperties (int property, double &value, const string &id)
+        
+        # /** \brief Set the rendering properties of a shape
+        #  * \param[in] property the property type
+        #  * \param[in] value the value to be set
+        #  * \param[in] id the shape object id
+        #  * \param[in] viewport the view port where the shape's properties should be modified (default: all)
+        #  */
+        # bool setShapeRenderingProperties (int property, double value, const std::string &id, int viewport = 0);
+        bool setShapeRenderingProperties (int property, double value, const string &id, int viewport)
+        
+        # /** \brief Set the rendering properties of a shape (3x values - e.g., RGB)
+        #   * \param[in] property the property type
+        #   * \param[in] val1 the first value to be set
+        #   * \param[in] val2 the second value to be set
+        #   * \param[in] val3 the third value to be set
+        #   * \param[in] id the shape object id
+        #   * \param[in] viewport the view port where the shape's properties should be modified (default: all)
+        #   */
+        # bool setShapeRenderingProperties (int property, double val1, double val2, double val3, const std::string &id, int viewport = 0);
+        bool setShapeRenderingProperties (int property, double val1, double val2, double val3, const string &id, int viewport)
+        
+        bool wasStopped ()
+        void resetStoppedFlag ()
+        void close ()
+        
+        # /** \brief Create a new viewport from [xmin,ymin] -> [xmax,ymax].
+        #   * \param[in] xmin the minimum X coordinate for the viewport (0.0 <= 1.0)
+        #   * \param[in] ymin the minimum Y coordinate for the viewport (0.0 <= 1.0)
+        #   * \param[in] xmax the maximum X coordinate for the viewport (0.0 <= 1.0)
+        #   * \param[in] ymax the maximum Y coordinate for the viewport (0.0 <= 1.0)
+        #   * \param[in] viewport the id of the new viewport
+        #   * \note If no renderer for the current window exists, one will be created, and 
+        #   * the viewport will be set to 0 ('all'). In case one or multiple renderers do 
+        #   * exist, the viewport ID will be set to the total number of renderers - 1.
+        # void createViewPort (double xmin, double ymin, double xmax, double ymax, int &viewport);
+        void createViewPort (double xmin, double ymin, double xmax, double ymax, int &viewport)
+        
+        # /** \brief Add a polygon (polyline) that represents the input point cloud (connects all
+        #   * points in order)
+        #   * \param[in] cloud the point cloud dataset representing the polygon
+        #   * \param[in] r the red channel of the color that the polygon should be rendered with
+        #   * \param[in] g the green channel of the color that the polygon should be rendered with
+        #   * \param[in] b the blue channel of the color that the polygon should be rendered with
+        #   * \param[in] id (optional) the polygon id/name (default: "polygon")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # template <typename PointT> bool
+        # addPolygon (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #             double r, double g, double b, const std::string &id = "polygon", int viewport = 0);
+        bool addPolygon[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, double r, double g, double b, const string &id, int viewport)
+        
+        # /** \brief Add a polygon (polyline) that represents the input point cloud (connects all
+        #   * points in order)
+        #   * \param[in] cloud the point cloud dataset representing the polygon
+        #   * \param[in] id the polygon id/name (default: "polygon")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # template <typename PointT> bool
+        # addPolygon (const typename pcl::PointCloud<PointT>::ConstPtr &cloud,
+        #             const std::string &id = "polygon", int viewport = 0);
+        bool addPolygon[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const string &id, int viewport)
+        
+        # /** \brief Add a line segment from two points
+        #   * \param[in] pt1 the first (start) point on the line
+        #   * \param[in] pt2 the second (end) point on the line
+        #   * \param[in] id the line id/name (default: "line")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   */
+        # template <typename P1, typename P2> bool
+        # addLine (const P1 &pt1, const P2 &pt2, const std::string &id = "line", int viewport = 0);
+        bool addLine[P1, P2](const P1 &pt1, const P2 &pt2, const string &id, int viewport)
+        
+        # /** \brief Add a line segment from two points
+        #   * \param[in] pt1 the first (start) point on the line
+        #   * \param[in] pt2 the second (end) point on the line
+        #   * \param[in] r the red channel of the color that the line should be rendered with
+        #   * \param[in] g the green channel of the color that the line should be rendered with
+        #   * \param[in] b the blue channel of the color that the line should be rendered with
+        #   * \param[in] id the line id/name (default: "line")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   */
+        # template <typename P1, typename P2> bool
+        # addLine (const P1 &pt1, const P2 &pt2, double r, double g, double b, const std::string &id = "line", int viewport = 0);
+        bool addLine[P1, P2](const P1 &pt1, const P2 &pt2, double r, double g, double b, const string &id, int viewport)
+        
+        # /** \brief Add a line arrow segment between two points, and display the distance between them
+        #   * \param[in] pt1 the first (start) point on the line
+        #   * \param[in] pt2 the second (end) point on the line
+        #   * \param[in] r the red channel of the color that the line should be rendered with
+        #   * \param[in] g the green channel of the color that the line should be rendered with
+        #   * \param[in] b the blue channel of the color that the line should be rendered with
+        #   * \param[in] id the arrow id/name (default: "arrow")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   */
+        # template <typename P1, typename P2> bool
+        # addArrow (const P1 &pt1, const P2 &pt2, double r, double g, double b, const std::string &id = "arrow", int viewport = 0);
+        bool addArrow[P1, P2](const P1 &pt1, const P2 &pt2, double r, double g, double b, const string &id, int viewport)
+        
+        # /** \brief Add a line arrow segment between two points, and display the distance between them
+        #   * \param[in] pt1 the first (start) point on the line
+        #   * \param[in] pt2 the second (end) point on the line
+        #   * \param[in] r the red channel of the color that the line should be rendered with
+        #   * \param[in] g the green channel of the color that the line should be rendered with
+        #   * \param[in] b the blue channel of the color that the line should be rendered with
+        #   * \param[in] display_length true if the length should be displayed on the arrow as text
+        #   * \param[in] id the line id/name (default: "arrow")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # template <typename P1, typename P2> bool
+        # addArrow (const P1 &pt1, const P2 &pt2, double r, double g, double b, bool display_length, const std::string &id = "arrow", int viewport = 0);
+        bool addArrow[P1, P2](const P1 &pt1, const P2 &pt2, double r, double g, double b, bool display_length, const string &id, int viewport)
+        
+        # /** \brief Add a sphere shape from a point and a radius
+        #   * \param[in] center the center of the sphere
+        #   * \param[in] radius the radius of the sphere
+        #   * \param[in] id the sphere id/name (default: "sphere")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # template <typename PointT> bool
+        # addSphere (const PointT &center, double radius, const std::string &id = "sphere", int viewport = 0);
+        bool addSphere[PointT](const PointT &center, double radius, const string &id, int viewport)
+        
+        # /** \brief Add a sphere shape from a point and a radius
+        #   * \param[in] center the center of the sphere
+        #   * \param[in] radius the radius of the sphere
+        #   * \param[in] r the red channel of the color that the sphere should be rendered with
+        #   * \param[in] g the green channel of the color that the sphere should be rendered with
+        #   * \param[in] b the blue channel of the color that the sphere should be rendered with
+        #   * \param[in] id the line id/name (default: "sphere")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # template <typename PointT> bool
+        # addSphere (const PointT &center, double radius, double r, double g, double b, const std::string &id = "sphere", int viewport = 0);
+        bool addSphere[PointT](const PointT &center, double radius, double r, double g, double b, const string &id, int viewport)
+        
+        # /** \brief Update an existing sphere shape from a point and a radius
+        #   * \param[in] center the center of the sphere
+        #   * \param[in] radius the radius of the sphere
+        #   * \param[in] r the red channel of the color that the sphere should be rendered with
+        #   * \param[in] g the green channel of the color that the sphere should be rendered with
+        #   * \param[in] b the blue channel of the color that the sphere should be rendered with
+        #   * \param[in] id the sphere id/name (default: "sphere")
+        # template <typename PointT> bool
+        # updateSphere (const PointT &center, double radius, double r, double g, double b, const std::string &id = "sphere");
+        bool updateSphere[PointT](const PointT &center, double radius, double r, double g, double b, const string &id)
+        
+        #  /** \brief Add a vtkPolydata as a mesh
+        #   * \param[in] polydata vtkPolyData
+        #   * \param[in] id the model id/name (default: "PolyData")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # bool addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, const std::string & id = "PolyData", int viewport = 0);
+        # bool addModelFromPolyData (vtkSmartPointer[vtkPolyData] polydata, const string & id, int viewport)
+        
+        # /** \brief Add a vtkPolydata as a mesh
+        #   * \param[in] polydata vtkPolyData
+        #   * \param[in] transform transformation to apply
+        #   * \param[in] id the model id/name (default: "PolyData")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # bool addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, vtkSmartPointer<vtkTransform> transform, const std::string &id = "PolyData", int viewport = 0);
+        # bool addModelFromPolyData (vtkSmartPointer[vtkPolyData] polydata, vtkSmartPointer[vtkTransform] transform, const string &id, int viewport)
+        
+        # /** \brief Add a PLYmodel as a mesh
+        #   * \param[in] filename of the ply file
+        #   * \param[in] id the model id/name (default: "PLYModel")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # bool addModelFromPLYFile (const std::string &filename, const std::string &id = "PLYModel", int viewport = 0);
+        bool addModelFromPLYFile (const string &filename, const string &id, int viewport)
+        
+        # /** \brief Add a PLYmodel as a mesh and applies given transformation
+        #   * \param[in] filename of the ply file
+        #   * \param[in] transform transformation to apply
+        #   * \param[in] id the model id/name (default: "PLYModel")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        # bool addModelFromPLYFile (const std::string &filename, vtkSmartPointer<vtkTransform> transform, const std::string &id = "PLYModel", int viewport = 0);
+        # bool addModelFromPLYFile (const string &filename, vtkSmartPointer[vtkTransform] transform, const string &id, int viewport)
+        
+        # /** \brief Add a cylinder from a set of given model coefficients
+        #   * \param[in] coefficients the model coefficients (point_on_axis, axis_direction, radius)
+        #   * \param[in] id the cylinder id/name (default: "cylinder")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   * \code
+        #   * // The following are given (or computed using sample consensus techniques)
+        #   * // See SampleConsensusModelCylinder for more information.
+        #   * // Eigen::Vector3f pt_on_axis, axis_direction;
+        #   * // float radius;
+        #   * pcl::ModelCoefficients cylinder_coeff;
+        #   * cylinder_coeff.values.resize (7);    // We need 7 values
+        #   * cylinder_coeff.values[0] = pt_on_axis.x ();
+        #   * cylinder_coeff.values[1] = pt_on_axis.y ();
+        #   * cylinder_coeff.values[2] = pt_on_axis.z ();
+        #   * cylinder_coeff.values[3] = axis_direction.x ();
+        #   * cylinder_coeff.values[4] = axis_direction.y ();
+        #   * cylinder_coeff.values[5] = axis_direction.z ();
+        #   * cylinder_coeff.values[6] = radius;
+        #   * addCylinder (cylinder_coeff);
+        #   * \endcode
+        #   */
+        # bool addCylinder (const pcl::ModelCoefficients &coefficients, const std::string &id = "cylinder", int viewport = 0);
+        bool addCylinder (const cpp.ModelCoefficients &coefficients, const string &id, int viewport)
+        
+        # /** \brief Add a sphere from a set of given model coefficients
+        #   * \param[in] coefficients the model coefficients (sphere center, radius)
+        #   * \param[in] id the sphere id/name (default: "sphere")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   * \code
+        #   * // The following are given (or computed using sample consensus techniques)
+        #   * // See SampleConsensusModelSphere for more information
+        #   * // Eigen::Vector3f sphere_center;
+        #   * // float radius;
+        #   * pcl::ModelCoefficients sphere_coeff;
+        #   * sphere_coeff.values.resize (4);    // We need 4 values
+        #   * sphere_coeff.values[0] = sphere_center.x ();
+        #   * sphere_coeff.values[1] = sphere_center.y ();
+        #   * sphere_coeff.values[2] = sphere_center.z ();
+        #   * sphere_coeff.values[3] = radius;
+        #   * addSphere (sphere_coeff);
+        #   * \endcode
+        #   */
+        # bool addSphere (const pcl::ModelCoefficients &coefficients, const std::string &id = "sphere", int viewport = 0);
+        bool addSphere (const cpp.ModelCoefficients &coefficients, const string &id, int viewport)
+        
+        # /** \brief Add a line from a set of given model coefficients
+        #   * \param[in] coefficients the model coefficients (point_on_line, direction)
+        #   * \param[in] id the line id/name (default: "line")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   * \code
+        #   * // The following are given (or computed using sample consensus techniques)
+        #   * // See SampleConsensusModelLine for more information
+        #   * // Eigen::Vector3f point_on_line, line_direction;
+        #   * pcl::ModelCoefficients line_coeff;
+        #   * line_coeff.values.resize (6);    // We need 6 values
+        #   * line_coeff.values[0] = point_on_line.x ();
+        #   * line_coeff.values[1] = point_on_line.y ();
+        #   * line_coeff.values[2] = point_on_line.z ();
+        #   * line_coeff.values[3] = line_direction.x ();
+        #   * line_coeff.values[4] = line_direction.y ();
+        #   * line_coeff.values[5] = line_direction.z ();
+        #   * addLine (line_coeff);
+        #   * \endcode
+        #   */
+        # bool addLine (const pcl::ModelCoefficients &coefficients, const std::string &id = "line", int viewport = 0);
+        bool addLine (const cpp.ModelCoefficients &coefficients, const string &id, int viewport)
+        
+        # /** \brief Add a plane from a set of given model coefficients
+        #   * \param[in] coefficients the model coefficients (a, b, c, d with ax+by+cz+d=0)
+        #   * \param[in] id the plane id/name (default: "plane")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   * \code
+        #   * // The following are given (or computed using sample consensus techniques)
+        #   * // See SampleConsensusModelPlane for more information
+        #   * // Eigen::Vector4f plane_parameters;
+        #   * pcl::ModelCoefficients plane_coeff;
+        #   * plane_coeff.values.resize (4);    // We need 4 values
+        #   * plane_coeff.values[0] = plane_parameters.x ();
+        #   * plane_coeff.values[1] = plane_parameters.y ();
+        #   * plane_coeff.values[2] = plane_parameters.z ();
+        #   * plane_coeff.values[3] = plane_parameters.w ();
+        #   * addPlane (plane_coeff);
+        #   * \endcode
+        #   */
+        # bool addPlane (const pcl::ModelCoefficients &coefficients, const std::string &id = "plane", int viewport = 0);
+        bool addPlane (const cpp.ModelCoefficients &coefficients, const string &id, int viewport)
+        
+        # /** \brief Add a circle from a set of given model coefficients
+        #   * \param[in] coefficients the model coefficients (x, y, radius)
+        #   * \param[in] id the circle id/name (default: "circle")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   * \code
+        #   * // The following are given (or computed using sample consensus techniques)
+        #   * // See SampleConsensusModelCircle2D for more information
+        #   * // float x, y, radius;
+        #   * pcl::ModelCoefficients circle_coeff;
+        #   * circle_coeff.values.resize (3);    // We need 3 values
+        #   * circle_coeff.values[0] = x;
+        #   * circle_coeff.values[1] = y;
+        #   * circle_coeff.values[2] = radius;
+        #   * vtkSmartPointer<vtkDataSet> data = pcl::visualization::create2DCircle (circle_coeff, z);
+        #   * \endcode
+        #    */
+        # bool addCircle (const pcl::ModelCoefficients &coefficients, const std::string &id = "circle", int viewport = 0);
+        bool addCircle (const cpp.ModelCoefficients &coefficients, const string &id, int viewport)
+        
+        # /** \brief Add a cone from a set of given model coefficients
+        #   * \param[in] coefficients the model coefficients (point_on_axis, axis_direction, radiu)
+        #   * \param[in] id the cone id/name (default: "cone")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   */
+        # bool addCone (const pcl::ModelCoefficients &coefficients, const std::string &id = "cone", int viewport = 0);
+        bool addCone (const cpp.ModelCoefficients &coefficients, const string &id, int viewport)
+        
+        # /** \brief Add a cube from a set of given model coefficients
+        #   * \param[in] coefficients the model coefficients (Tx, Ty, Tz, Qx, Qy, Qz, Qw, width, height, depth)
+        #   * \param[in] id the cube id/name (default: "cube")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   */
+        # bool addCube (const pcl::ModelCoefficients &coefficients, const std::string &id = "cube", int viewport = 0);
+        bool addCube (const cpp.ModelCoefficients &coefficients, const string &id, int viewport)
+        
+        # /** \brief Add a cube from a set of given model coefficients
+        #   * \param[in] translation a translation to apply to the cube from 0,0,0
+        #   * \param[in] rotation a quaternion-based rotation to apply to the cube
+        #   * \param[in] width the cube's width
+        #   * \param[in] height the cube's height
+        #   * \param[in] depth the cube's depth
+        #   * \param[in] id the cube id/name (default: "cube")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   */
+        # bool addCube (const Eigen::Vector3f &translation, const Eigen::Quaternionf &rotation, double width, double height, double depth, const std::string &id = "cube", int viewport = 0);
+        bool addCube (const eigen3.Vector3f &translation, const eigen3.Quaternionf &rotation, double width, double height, double depth, const string &id, int viewport)
+        
+        # /** \brief Add a cube from a set of bounding points
+        #   * \param[in] x_min is the minimum x value of the box
+        #   * \param[in] x_max is the maximum x value of the box
+        #   * \param[in] y_min is the minimum y value of the box 
+        #   * \param[in] y_max is the maximum y value of the box
+        #   * \param[in] z_min is the minimum z value of the box
+        #   * \param[in] z_max is the maximum z value of the box
+        #   * \param[in] r the red color value (default: 1.0)
+        #   * \param[in] g the green color value (default: 1.0)
+        #   * \param[in] b the blue color vlaue (default: 1.0)
+        #   * \param[in] id the cube id/name (default: "cube")
+        #   * \param[in] viewport (optional) the id of the new viewport (default: 0)
+        #   */
+        # bool
+        # addCube (double x_min, double x_max,
+        #          double y_min, double y_max,
+        #          double z_min, double z_max,
+        #          double r = 1.0, double g = 1.0, double b = 1.0,
+        #          const std::string &id = "cube",
+        #          int viewport = 0);
+        bool addCube (double x_min, double x_max, double y_min, double y_max, double z_min, double z_max, double r, double g, double b, const string &id, int viewport)
+        
+        # /** \brief Changes the visual representation for all actors to surface representation. */
+        # void setRepresentationToSurfaceForAllActors ();
+        void setRepresentationToSurfaceForAllActors ()
+                
+        # /** \brief Changes the visual representation for all actors to points representation. */
+        # void setRepresentationToPointsForAllActors ();
+        void setRepresentationToPointsForAllActors ()
+        
+        # /** \brief Changes the visual representation for all actors to wireframe representation. */
+        # void setRepresentationToWireframeForAllActors ();
+        void setRepresentationToWireframeForAllActors ()
+        
+        # /** \brief Renders a virtual scene as seen from the camera viewpoint and returns the rendered point cloud.
+        #   * ATT: This method will only render the scene if only on viewport exists. Otherwise, returns an empty
+        #   * point cloud and exits immediately.
+        #   * \param[in] xres is the size of the window (X) used to render the scene
+        #   * \param[in] yres is the size of the window (Y) used to render the scene
+        #   * \param[in] cloud is the rendered point cloud
+        #   */
+        # void renderView (int xres, int yres, pcl::PointCloud<pcl::PointXYZ>::Ptr & cloud);
+        void renderView (int xres, int yres, shared_ptr[cpp.PointCloud[cpp.PointXYZ]] &cloud)
+        
+        # /** \brief The purpose of this method is to render a CAD model added to the visualizer from different viewpoints
+        #   * in order to simulate partial views of model. The viewpoint locations are the vertices of a tesselated sphere
+        #   * build from an icosaheadron. The tesselation paremeter controls how many times the triangles of the original
+        #   * icosahedron are divided to approximate the sphere and thus the number of partial view generated for a model,
+        #   * with a tesselation_level of 0, 12 views are generated if use_vertices=true and 20 views if use_vertices=false
+        #   * \param[in] xres the size of the window (X) used to render the partial view of the object
+        #   * \param[in] yres the size of the window (Y) used to render the partial view of the object
+        #   * \param[in] cloud is a vector of pointcloud with XYZ information that represent the model as seen from the respective viewpoints.
+        #   * \param[out] poses represent the transformation from object coordinates to camera coordinates for the respective viewpoint.
+        #   * \param[out] enthropies are values between 0 and 1 representing which percentage of the model is seen from the respective viewpoint.
+        #   * \param[in] tesselation_level represents the number of subdivisions applied to the triangles of original icosahedron.
+        #   * \param[in] view_angle field of view of the virtual camera. Default: 45
+        #   * \param[in] radius_sphere the tesselated sphere radius. Default: 1
+        #   * \param[in] use_vertices if true, use the vertices of tesselated icosahedron (12,42,...) or if false, use the faces of tesselated
+        #   * icosahedron (20,80,...). Default: true
+        #   */
+        # void renderViewTesselatedSphere (
+        #     int xres, int yres,
+        #     std::vector<pcl::PointCloud<pcl::PointXYZ>,Eigen::aligned_allocator< pcl::PointCloud<pcl::PointXYZ> > > & cloud,
+        #     std::vector<Eigen::Matrix4f,Eigen::aligned_allocator< Eigen::Matrix4f > > & poses, std::vector<float> & enthropies, int tesselation_level,
+        #     float view_angle = 45, float radius_sphere = 1, bool use_vertices = true);
+        # void renderViewTesselatedSphere (
+        #       int xres, int yres,vector[cpp.PointCloud[cpp.PointXYZ]], eigen3.aligned_allocator[cpp.PointCloud[cpp.PointXYZ]]] &cloud,
+        #       vector[eigen3.Matrix4f, eigen3.aligned_allocator[eigen3.Matrix4f]] &poses, vector[float] &enthropies, int tesselation_level,
+        #       float view_angl, float radius_sphere, bool use_vertices)
+        
+        # /** \brief Camera view, window position and size. */
+        # Camera camera_;
+        
+        # /** \brief Initialize camera parameters with some default values. */
+        # void initCameraParameters ();
+        void initCameraParameters()
+        
+        # /** \brief Search for camera parameters at the command line and set them internally.
+        #   * \param[in] argc
+        #   * \param[in] argv
+        #   */
+        # bool getCameraParameters (int argc, char **argv);
+        
+        # /** \brief Checks whether the camera parameters were manually loaded from file.*/
+        # bool cameraParamsSet () const;
+        bool cameraParamsSet ()
+        
+        # /** \brief Update camera parameters and render. */
+        # void updateCamera ();
+        void updateCamera ()
+        
+        # /** \brief Reset camera parameters and render. */
+        # void resetCamera ();
+        void resetCamera ()
+        
+        # /** \brief Reset the camera direction from {0, 0, 0} to the center_{x, y, z} of a given dataset.
+        #   * \param[in] id the point cloud object id (default: cloud)
+        #   */
+        # void resetCameraViewpoint (const std::string &id = "cloud");
+        void resetCameraViewpoint (const string &id)
+        
+        # /** \brief sets the camera pose given by position, viewpoint and up vector
+        #   * \param posX the x co-ordinate of the camera location
+        #   * \param posY the y co-ordinate of the camera location
+        #   * \param posZ the z co-ordinate of the camera location
+        #   * \param viewX the x component of the view upoint of the camera
+        #   * \param viewY the y component of the view point of the camera
+        #   * \param viewZ the z component of the view point of the camera
+        #   * \param upX the x component of the view up direction of the camera
+        #   * \param upY the y component of the view up direction of the camera
+        #   * \param upZ the y component of the view up direction of the camera
+        #   * \param viewport the viewport to modify camera of, if 0, modifies all cameras
+        # void setCameraPose (double posX, double posY, double posZ, double viewX, double viewY, double viewZ, double upX, double upY, double upZ, int viewport = 0);
+        void setCameraPose (double posX, double posY, double posZ, double viewX, double viewY, double viewZ, double upX, double upY, double upZ, int viewport)
+        
+        # /** \brief Set the camera location and viewup according to the given arguments
+        #   * \param[in] posX the x co-ordinate of the camera location
+        #   * \param[in] posY the y co-ordinate of the camera location
+        #   * \param[in] posZ the z co-ordinate of the camera location
+        #   * \param[in] viewX the x component of the view up direction of the camera
+        #   * \param[in] viewY the y component of the view up direction of the camera
+        #   * \param[in] viewZ the z component of the view up direction of the camera
+        #   * \param[in] viewport the viewport to modify camera of, if 0, modifies all cameras
+        # void setCameraPosition (double posX,double posY, double posZ, double viewX, double viewY, double viewZ, int viewport = 0);
+        void setCameraPosition (double posX,double posY, double posZ, double viewX, double viewY, double viewZ, int viewport)
+        
+        # /** \brief Get the current camera parameters. */
+        # void getCameras (std::vector<Camera>& cameras);
+        # void getCameras (vector[Camera]& cameras)
+        
+        # /** \brief Get the current viewing pose. */
+        # Eigen::Affine3f getViewerPose ();
+        eigen3.Affine3f getViewerPose ()
+        
+        # /** \brief Save the current rendered image to disk, as a PNG screenshot.
+        #   * \param[in] file the name of the PNG file
+        # void saveScreenshot (const std::string &file);
+        void saveScreenshot (const string &file)
+        
+        # /** \brief Return a pointer to the underlying VTK Render Window used. */
+        # vtkSmartPointer<vtkRenderWindow> getRenderWindow ()
+        
+        # /** \brief Create the internal Interactor object. */
+        # void createInteractor ();
+        void createInteractor ()
+        
+        # /** \brief Set up our unique PCL interactor style for a given vtkRenderWindowInteractor object
+        #   * attached to a given vtkRenderWindow
+        #   * \param[in,out] iren the vtkRenderWindowInteractor object to set up
+        #   * \param[in,out] win a vtkRenderWindow object that the interactor is attached to
+        # void setupInteractor (vtkRenderWindowInteractor *iren, vtkRenderWindow *win);
+        
+        # /** \brief Get a pointer to the current interactor style used. */
+        # inline vtkSmartPointer<PCLVisualizerInteractorStyle> getInteractorStyle ()
+
+
+# ctypedef PCLVisualizer PCLVisualizer_t
+ctypedef shared_ptr[PCLVisualizer] PCLVisualizerPtr_t
+###
+
+# cloud_viewer.h
+cdef extern from "pcl/visualization/cloud_viewer.h" namespace "pcl::visualization" nogil:
+    cdef cppclass CloudViewer:
+        # CloudViewer ()
+        CloudViewer (string& window_name)
+        # public:
+        # /** \brief Show a cloud, with an optional key for multiple clouds.
+        # * \param[in] cloud RGB point cloud
+        # * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
+        # void showCloud (const ColorCloud::ConstPtr &cloud, const std::string& cloudname = "cloud");
+        void showCloud (cpp.PointCloud_PointXYZRGB_Ptr_t cloud, const string cloudname)
+        
+        # /** \brief Show a cloud, with an optional key for multiple clouds.
+        #  * \param[in] cloud RGBA point cloud
+        #  * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
+        # void showCloud (const ColorACloud::ConstPtr &cloud, const std::string& cloudname = "cloud");
+        void showCloud (cpp.PointCloud_PointXYZRGBA_Ptr_t cloud, const string cloudname)
+        
+        # /** \brief Show a cloud, with an optional key for multiple clouds.
+        #   * \param[in] cloud XYZI point cloud
+        #   * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
+        void showCloud (cpp.PointCloud_PointXYZI_Ptr_t cloud, string cloudname)
+        
+        # /** \brief Show a cloud, with an optional key for multiple clouds.
+        #   * \param[in] cloud XYZ point cloud
+        #   * \param[in] cloudname a key for the point cloud, use the same name if you would like to overwrite the existing cloud.
+        void showCloud (cpp.PointCloudPtr_t cloud, string cloudname)
+        
+        # /** \brief Check if the gui was quit, you should quit also
+        #  * \param millis_to_wait This will request to "spin" for the number of milliseconds, before exiting.
+        #  * \return true if the user signaled the gui to stop
+        bool wasStopped (int millis_to_wait)
+        
+        # /** Visualization callable function, may be used for running things on the UI thread.
+        # ctypedef boost::function1<void, pcl::visualization::PCLVisualizer&> VizCallable;
+        
+        # /** \brief Run a callbable object on the UI thread. Will persist until removed
+        #  * @param x Use boost::ref(x) for a function object that you would like to not copy
+        #  * \param key The key for the callable -- use the same key to overwrite.
+        # void runOnVisualizationThread (VizCallable x, const std::string& key = "callable");
+        
+        # /** \brief Run a callbable object on the UI thread. This will run once and be removed
+        #  * @param x Use boost::ref(x) for a function object that you would like to not copy
+        # void runOnVisualizationThreadOnce (VizCallable x);
+        
+        # /** \brief Remove a previously added callable object, NOP if it doesn't exist.
+        #  * @param key the key that was registered with the callable object.
+        # void removeVisualizationCallable (string& key = "callable")
+        
+        # /** \brief Register a callback function for keyboard events
+        #   * \param[in] callback  the function that will be registered as a callback for a keyboard event
+        #   * \param[in] cookie    user data that is passed to the callback
+        #   * \return              connection object that allows to disconnect the callback function.
+        # inline boost::signals2::connection registerKeyboardCallback (void (*callback) (const pcl::visualization::KeyboardEvent&, void*), void* cookie = NULL)
+        
+        # /** \brief Register a callback function for keyboard events
+        #   * \param[in] callback  the member function that will be registered as a callback for a keyboard event
+        #   * \param[in] instance  instance to the class that implements the callback function
+        #   * \param[in] cookie    user data that is passed to the callback
+        #   * \return              connection object that allows to disconnect the callback function.
+        # template<typename T> inline boost::signals2::connection registerKeyboardCallback (void (T::*callback) (const pcl::visualization::KeyboardEvent&, void*), T& instance, void* cookie = NULL)
+        
+        # /** \brief Register a callback function for mouse events
+        #   * \param[in] callback  the function that will be registered as a callback for a mouse event
+        #   * \param[in] cookie    user data that is passed to the callback
+        #   * \return              connection object that allows to disconnect the callback function.
+        # inline boost::signals2::connection registerMouseCallback (void (*callback) (const pcl::visualization::MouseEvent&, void*), void* cookie = NULL)
+        
+        # /** \brief Register a callback function for mouse events
+        #   * \param[in] callback  the member function that will be registered as a callback for a mouse event
+        #   * \param[in] instance  instance to the class that implements the callback function
+        #   * \param[in] cookie    user data that is passed to the callback
+        #   * \return              connection object that allows to disconnect the callback function.
+        # template<typename T> inline boost::signals2::connection registerMouseCallback (void (T::*callback) (const pcl::visualization::MouseEvent&, void*), T& instance, void* cookie = NULL)
+        
+        # /** \brief Register a callback function for point picking events
+        #   * \param[in] callback  the function that will be registered as a callback for a point picking event
+        #   * \param[in] cookie    user data that is passed to the callback
+        #   * \return              connection object that allows to disconnect the callback function.
+        # inline boost::signals2::connection  registerPointPickingCallback (void (*callback) (const pcl::visualization::PointPickingEvent&, void*), void* cookie = NULL)
+        
+        # /** \brief Register a callback function for point picking events
+        #   * \param[in] callback  the member function that will be registered as a callback for a point picking event
+        #   * \param[in] instance  instance to the class that implements the callback function
+        #   * \param[in] cookie    user data that is passed to the callback
+        #   * \return              connection object that allows to disconnect the callback function.
+        #   */
+        # template<typename T> inline boost::signals2::connection  registerPointPickingCallback (void (T::*callback) (const pcl::visualization::PointPickingEvent&, void*), T& instance, void* cookie = NULL)
+
+
+# ctypedef CloudViewer CloudViewer_t
+ctypedef shared_ptr[CloudViewer] CloudViewerPtr_t
+# ctypedef boost::function1<void, pcl::visualization::PCLVisualizer&> VizCallable;
+# ctypedef function1[void, PCLVisualizer] VizCallable;
+###
+
+# histogram_visualizer.h
+cdef extern from "pcl/visualization/histogram_visualizer.h" namespace "pcl::visualization":
+    cdef cppclass PCLHistogramVisualizer:
+        PCLHistogramVisualizer ()
+        
+        # brief Spin once method. Calls the interactor and updates the screen once. 
+        # void spinOnce (int time = 1, bool force_redraw = false)
+        void spinOnce ()
+        # void spinOnce (int time, bool force_redraw)
+        
+        # brief Spin method. Calls the interactor and runs an internal loop. */
+        void spin ()
+        
+        # brief Set the viewport's background color.
+        # param[in] r the red component of the RGB color
+        # param[in] g the green component of the RGB color
+        # param[in] b the blue component of the RGB color
+        # param[in] viewport the view port (default: all)
+        # void setBackgroundColor (const double &r, const double &g, const double &b, int viewport = 0)
+        void setBackgroundColor (const double &r, const double &g, const double &b, int viewport)
+        
+        # brief Add a histogram feature to screen as a separate window, from a cloud containing a single histogram.
+        # param[in] cloud the PointCloud dataset containing the histogram
+        # param[in] hsize the length of the histogram
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] win_width the width of the window
+        # param[in] win_height the height of the window
+        # template <typename PointT> bool 
+        # addFeatureHistogram (const pcl::PointCloud<PointT> &cloud, int hsize, const std::string &id = "cloud", int win_width = 640, int win_height = 200);
+        bool addFeatureHistogram[PointT](const cpp.PointCloud[PointT] &cloud, int hsize, string cloudname, int win_width, int win_height)
+        
+        # brief Add a histogram feature to screen as a separate window from a cloud containing a single histogram.
+        # param[in] cloud the PointCloud dataset containing the histogram
+        # param[in] field_name the field name containing the histogram
+        # param[in] id the point cloud object id (default: cloud)
+        # param[in] win_width the width of the window
+        # param[in] win_height the height of the window
+        # bool addFeatureHistogram (const sensor_msgs::PointCloud2 &cloud,  const std::string &field_name, const std::string &id = "cloud", int win_width = 640, int win_height = 200);
+        
+        # /** \brief Add a histogram feature to screen as a separate window.
+        #   * \param[in] cloud the PointCloud dataset containing the histogram
+        #   * \param[in] field_name the field name containing the histogram
+        #   * \param[in] index the point index to extract the histogram from
+        #   * \param[in] id the point cloud object id (default: cloud)
+        #   * \param[in] win_width the width of the window
+        #   * \param[in] win_height the height of the window 
+        # template <typename PointT> bool 
+        # addFeatureHistogram (const pcl::PointCloud<PointT> &cloud, 
+        #                      const std::string &field_name, 
+        #                      const int index,
+        #                      const std::string &id = "cloud", int win_width = 640, int win_height = 200);
+        # Override before addFeatureHistogram Function
+        # bool addFeatureHistogram[PointT](const cpp.PointCloud[PointT] &cloud, string field_name, int index, string id, int win_width, int win_height)
+        
+        # /** \brief Add a histogram feature to screen as a separate window.
+        #   * \param[in] cloud the PointCloud dataset containing the histogram
+        #   * \param[in] field_name the field name containing the histogram
+        #   * \param[in] index the point index to extract the histogram from
+        #   * \param[in] id the point cloud object id (default: cloud)
+        #   * \param[in] win_width the width of the window
+        #   * \param[in] win_height the height of the window
+        # bool 
+        # addFeatureHistogram (const sensor_msgs::PointCloud2 &cloud, 
+        #                      const std::string &field_name, 
+        #                      const int index,
+        #                      const std::string &id = "cloud", int win_width = 640, int win_height = 200);
+        
+        # /** \brief Update a histogram feature that is already on screen, with a cloud containing a single histogram.
+        #   * \param[in] cloud the PointCloud dataset containing the histogram
+        #   * \param[in] hsize the length of the histogram
+        #   * \param[in] id the point cloud object id (default: cloud)
+        # template <typename PointT> bool updateFeatureHistogram (const pcl::PointCloud<PointT> &cloud, int hsize, const std::string &id = "cloud");
+        bool updateFeatureHistogram[PointT](const cpp.PointCloud[PointT] &cloud, int hsize, const string &id)
+        
+        # /** \brief Update a histogram feature that is already on screen, with a cloud containing a single histogram.
+        #   * \param[in] cloud the PointCloud dataset containing the histogram
+        #   * \param[in] field_name the field name containing the histogram
+        #   * \param[in] id the point cloud object id (default: cloud)
+        # bool updateFeatureHistogram (const sensor_msgs::PointCloud2 &cloud, const std::string &field_name, const std::string &id = "cloud");
+        
+        # /** \brief Update a histogram feature that is already on screen, with a cloud containing a single histogram.
+        #   * \param[in] cloud the PointCloud dataset containing the histogram
+        #   * \param[in] field_name the field name containing the histogram
+        #   * \param[in] index the point index to extract the histogram from
+        #   * \param[in] id the point cloud object id (default: cloud)
+        # template <typename PointT> bool 
+        # updateFeatureHistogram (const pcl::PointCloud<PointT> &cloud, const std::string &field_name, const int index, const std::string &id = "cloud");
+        bool updateFeatureHistogram[PointT](const cpp.PointCloud[PointT]  &cloud, const string &field_name, const int index, const string &id)
+        
+        # /** \brief Update a histogram feature that is already on screen, with a cloud containing a single histogram.
+        #   * \param[in] cloud the PointCloud dataset containing the histogram
+        #   * \param[in] field_name the field name containing the histogram
+        #   * \param[in] index the point index to extract the histogram from
+        #   * \param[in] id the point cloud object id (default: cloud)
+        # bool updateFeatureHistogram (const sensor_msgs::PointCloud2 &cloud, const std::string &field_name, const int index, const std::string &id = "cloud");
+        
+        # /** \brief Set the Y range to minp-maxp for all histograms.
+        #    * \param[in] minp the minimum Y range
+        #    * \param[in] maxp the maximum Y range
+        # void setGlobalYRange (float minp, float maxp);
+        void setGlobalYRange (float minp, float maxp)
+        
+        # /** \brief Update all window positions on screen so that they fit. */
+        # void updateWindowPositions ();
+        void updateWindowPositions ()
+        
+        # #if ((VTK_MAJOR_VERSION) == 5 && (VTK_MINOR_VERSION <= 4))
+        # /** \brief Returns true when the user tried to close the window */
+        # bool wasStopped ();
+        # /** \brief Set the stopped flag back to false */
+        # void resetStoppedFlag ();
+        # #endif
+
+# ctypedef CloudViewer CloudViewer_t
+ctypedef shared_ptr[PCLHistogramVisualizer] PCLHistogramVisualizerPtr_t
+###
+
+# image_viewer.h
+# class PCL_EXPORTS ImageViewer
+cdef extern from "pcl/visualization/image_viewer.h" namespace "pcl::visualization" nogil:
+    cdef cppclass ImageViewer:
+        ImageViewer()
+        ImageViewer(const string& window_title)
+        # ImageViewer()
+        # ImageViewer (const std::string& window_title = "");
+        
+        # public:
+        # /** \brief Show a monochrome 2D image on screen.
+        #   * \param[in] data the input data representing the image
+        #   * \param[in] width the width of the image
+        #   * \param[in] height the height of the image
+        #   * \param[in] layer_id the name of the layer (default: "image")
+        #   * \param[in] opacity the opacity of the layer (default: 1.0)
+        #   */
+        # void  showMonoImage (const unsigned char* data, unsigned width, unsigned height, const std::string &layer_id = "mono_image", double opacity = 1.0);
+        void showMonoImage (const unsigned char* data, unsigned width, unsigned height,const string &layer_id, double opacity)
+        
+        # brief Add a monochrome 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] data the input data representing the image
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void addMonoImage (const unsigned char* data, unsigned width, unsigned height, const std::string &layer_id = "mono_image", double opacity = 1.0)
+        void addMonoImage (const unsigned char* data, unsigned width, unsigned height, const string &layer_id, double opacity)
+        
+        # brief Show a 2D RGB image on screen.
+        # param[in] data the input data representing the image
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void showRGBImage (const unsigned char* data, unsigned width, unsigned height, 
+        #               const std::string &layer_id = "rgb_image", double opacity = 1.0);
+        void showRGBImage (const unsigned char* data, unsigned width, unsigned height, const string &layer_id, double opacity)
+        
+        # brief Add an RGB 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] data the input data representing the image
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void addRGBImage (const unsigned char* data, unsigned width, unsigned height, 
+        #              const std::string &layer_id = "rgb_image", double opacity = 1.0);
+        void addRGBImage (const unsigned char* data, unsigned width, unsigned height, const string &layer_id, double opacity)
+        
+        # brief Show a 2D image on screen, obtained from the RGB channel of a point cloud.
+        # param[in] data the input data representing the RGB point cloud 
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # template <typename T> inline void 
+        # showRGBImage (const typename pcl::PointCloud<T>::ConstPtr &cloud,
+        #               const std::string &layer_id = "rgb_image", double opacity = 1.0)
+        # void showRGBImage (const shared_ptr[cpp.PointCloud[PointT]] &cloud, const string &layer_id, double opacity)
+        
+        # brief Add an RGB 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] data the input data representing the RGB point cloud 
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # template <typename T> inline void 
+        # addRGBImage (const typename pcl::PointCloud<T>::ConstPtr &cloud, const std::string &layer_id = "rgb_image", double opacity = 1.0)
+        # void addRGBImage[T](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const string &layer_id, double opacity)
+        
+        # brief Show a 2D image on screen, obtained from the RGB channel of a point cloud.
+        # param[in] data the input data representing the RGB point cloud 
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # template <typename T> void 
+        # showRGBImage (const pcl::PointCloud<T> &cloud, const std::string &layer_id = "rgb_image", double opacity = 1.0);
+        # void showRGBImage[T](const cpp.PointCloud[T] &cloud, const string &layer_id, double opacity)
+        
+        # brief Add an RGB 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] data the input data representing the RGB point cloud 
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # template <typename T> void 
+        # addRGBImage (const pcl::PointCloud<T> &cloud, const std::string &layer_id = "rgb_image", double opacity = 1.0);
+        # void addRGBImage (const cpp.PointCloud[T] &cloud, const string &layer_id, double opacity)
+        
+        # brief Show a 2D image (float) on screen.
+        # param[in] data the input data representing the image in float format
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] min_value filter all values in the image to be larger than this minimum value
+        # param[in] max_value filter all values in the image to be smaller than this maximum value
+        # param[in] grayscale show data as grayscale (true) or not (false). Default: false
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void showFloatImage (const float* data, unsigned int width, unsigned int height, 
+        #                 float min_value = std::numeric_limits<float>::min (), 
+        #                 float max_value = std::numeric_limits<float>::max (), bool grayscale = false,
+        #                 const std::string &layer_id = "float_image", double opacity = 1.0);
+        void showFloatImage (
+                        const float* data,
+                        unsigned int width,
+                        unsigned int height, 
+                        float min_value, 
+                        float max_value,
+                        bool grayscale,
+                        const string &layer_id,
+                        double opacity)
+        
+        # brief Add a float 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] data the input data representing the image in float format
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] min_value filter all values in the image to be larger than this minimum value
+        # param[in] max_value filter all values in the image to be smaller than this maximum value
+        # param[in] grayscale show data as grayscale (true) or not (false). Default: false
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void addFloatImage (const float* data, unsigned int width, unsigned int height, 
+        #                float min_value = std::numeric_limits<float>::min (), 
+        #                float max_value = std::numeric_limits<float>::max (), bool grayscale = false,
+        #                const std::string &layer_id = "float_image", double opacity = 1.0);
+        void addFloatImage (
+                        const float* data,
+                        unsigned int width,
+                        unsigned int height,
+                        float min_value, 
+                        float max_value,
+                        bool grayscale,
+                        const string &layer_id,
+                        double opacity)
+        
+        
+        # brief Show a 2D image (unsigned short) on screen.
+        # param[in] short_image the input data representing the image in unsigned short format
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] min_value filter all values in the image to be larger than this minimum value
+        # param[in] max_value filter all values in the image to be smaller than this maximum value
+        # param[in] grayscale show data as grayscale (true) or not (false). Default: false
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void
+        # showShortImage (const unsigned short* short_image, unsigned int width, unsigned int height, 
+        #                 unsigned short min_value = std::numeric_limits<unsigned short>::min (), 
+        #                 unsigned short max_value = std::numeric_limits<unsigned short>::max (), bool grayscale = false,
+        #                 const std::string &layer_id = "short_image", double opacity = 1.0);
+        # void showShortImage (
+        #                       const unsigned short* short_image, 
+        #                       unsigned int width, 
+        #                       unsigned int height, 
+        #                       unsigned short min_value, 
+        #                       unsigned short max_value, 
+        #                       bool grayscale = false,
+        #                       const string &layer_id,
+        #                       double opacity)
+        
+        # brief Add a short 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] short_image the input data representing the image in unsigned short format
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] min_value filter all values in the image to be larger than this minimum value
+        # param[in] max_value filter all values in the image to be smaller than this maximum value
+        # param[in] grayscale show data as grayscale (true) or not (false). Default: false
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void
+        # addShortImage (const unsigned short* short_image, unsigned int width, unsigned int height, 
+        #                unsigned short min_value = std::numeric_limits<unsigned short>::min (), 
+        #                unsigned short max_value = std::numeric_limits<unsigned short>::max (), bool grayscale = false,
+        #                const std::string &layer_id = "short_image", double opacity = 1.0);
+        void addShortImage (
+                            const unsigned short* short_image, 
+                            unsigned int width, unsigned int height, 
+                            unsigned short min_value, unsigned short max_value,
+                            bool grayscale,
+                            const string &layer_id, double opacity)
+        
+        # brief Show a 2D image on screen representing angle data.
+        # param[in] data the input data representing the image
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void showAngleImage (const float* data, unsigned width, unsigned height, const std::string &layer_id = "angle_image", double opacity = 1.0);
+        void showAngleImage (const float* data, unsigned width, unsigned height, const string &layer_id, double opacity)
+        
+        # brief Add an angle 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] data the input data representing the image
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void addAngleImage (const float* data, unsigned width, unsigned height, const std::string &layer_id = "angle_image", double opacity = 1.0);
+        void addAngleImage (const float* data, unsigned width, unsigned height, const string &layer_id, double opacity)
+        
+        # brief Show a 2D image on screen representing half angle data.
+        # param[in] data the input data representing the image
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void showHalfAngleImage (const float* data, unsigned width, unsigned height, const std::string &layer_id = "half_angle_image", double opacity = 1.0);
+        void showHalfAngleImage (const float* data, unsigned width, unsigned height, const string &layer_id, double opacity)
+        
+        # brief Add a half angle 2D image layer, but do not render it (use spin/spinOnce to update).
+        # param[in] data the input data representing the image
+        # param[in] width the width of the image
+        # param[in] height the height of the image
+        # param[in] layer_id the name of the layer (default: "image")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void addHalfAngleImage (const float* data, unsigned width, unsigned height,
+        #                         const std::string &layer_id = "half_angle_image", double opacity = 1.0);
+        void addHalfAngleImage (const float* data, unsigned width, unsigned height, const string &layer_id, double opacity)
+        
+        # brief Sets the pixel at coordinates(u,v) to color while setting the neighborhood to another
+        # param[in] u the u/x coordinate of the pixel
+        # param[in] v the v/y coordinate of the pixel
+        # param[in] fg_color the pixel color
+        # param[in] bg_color the neighborhood color
+        # param[in] radius the circle radius around the pixel
+        # param[in] layer_id the name of the layer (default: "points")
+        # param[in] opacity the opacity of the layer (default: 1.0)
+        # void markPoint (size_t u, size_t v, Vector3ub fg_color, Vector3ub bg_color = red_color, double radius = 3.0,
+        #                 const std::string &layer_id = "points", double opacity = 1.0);
+        # Vector3ub Unknown
+        # void markPoint (size_t u, size_t v, Vector3ub fg_color, Vector3ub bg_color, double radius, const string &layer_id, double opacity)
+        
+        # brief Set the window title name
+        # param[in] name the window title
+        # void setWindowTitle (const std::string& name)
+        void setWindowTitle (const string& name)
+        
+        # brief Spin method. Calls the interactor and runs an internal loop. */
+        # void spin ();
+        void spin ()
+        
+        # brief Spin once method. Calls the interactor and updates the screen once. 
+        # param[in] time - How long (in ms) should the visualization loop be allowed to run.
+        # param[in] force_redraw - if false it might return without doing anything if the 
+        # interactor's framerate does not require a redraw yet.
+        # void spinOnce (int time = 1, bool force_redraw = true);
+        void spinOnce (int time, bool force_redraw)
+        
+        # brief Register a callback function for keyboard events
+        # param[in] callback  the function that will be registered as a callback for a keyboard event
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # boost::signals2::connection 
+        # registerKeyboardCallback (void (*callback) (const pcl::visualization::KeyboardEvent&, void*), 
+        #                           void* cookie = NULL)
+        
+        # brief Register a callback function for keyboard events
+        # param[in] callback  the member function that will be registered as a callback for a keyboard event
+        # param[in] instance  instance to the class that implements the callback function
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # template<typename T> boost::signals2::connection 
+        # registerKeyboardCallback (void (T::*callback) (const pcl::visualization::KeyboardEvent&, void*), 
+        #                           T& instance, void* cookie = NULL)
+        
+        # brief Register a callback boost::function for keyboard events
+        # param[in] cb the boost function that will be registered as a callback for a keyboard event
+        # return a connection object that allows to disconnect the callback function.
+        # boost::signals2::connection 
+        # registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)> cb);
+        
+        # brief Register a callback boost::function for mouse events
+        # param[in] callback  the function that will be registered as a callback for a mouse event
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # boost::signals2::connection 
+        # registerMouseCallback (void (*callback) (const pcl::visualization::MouseEvent&, void*), 
+        #                        void* cookie = NULL)
+        
+        # brief Register a callback function for mouse events
+        # param[in] callback  the member function that will be registered as a callback for a mouse event
+        # param[in] instance  instance to the class that implements the callback function
+        # param[in] cookie    user data that is passed to the callback
+        # return a connection object that allows to disconnect the callback function.
+        # template<typename T> boost::signals2::connection 
+        # registerMouseCallback(void (T::*callback) (const pcl::visualization::MouseEvent&, void*), 
+        #                        T& instance, void* cookie = NULL)
+        # boost::signals2::connection registerMouseCallback[T](void (T::*callback) (const pcl::visualization::MouseEvent&, void*),  T& instance, void* cookie = NULL)
+        
+        # brief Register a callback function for mouse events
+        # param[in] cb the boost function that will be registered as a callback for a mouse event
+        # return a connection object that allows to disconnect the callback function.
+        # boost::signals2::connection 
+        # registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)> cb);
+        
+        # brief Set the position in screen coordinates.
+        # param[in] x where to move the window to (X)
+        # param[in] y where to move the window to (Y)
+        # void setPosition (int x, int y)
+        void setPosition (int x, int y)
+        
+        # brief Set the window size in screen coordinates.
+        # param[in] xw window size in horizontal (pixels)
+        # param[in] yw window size in vertical (pixels)
+        # void setSize (int xw, int yw)
+        void setSize (int xw, int yw)
+        
+        # brief Returns true when the user tried to close the window
+        # bool wasStopped () const
+        bool wasStopped ()
+        
+        # brief Add a circle shape from a point and a radius
+        # param[in] x the x coordinate of the circle center
+        # param[in] y the y coordinate of the circle center
+        # param[in] radius the radius of the circle
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addCircle (unsigned int x, unsigned int y, double radius, const std::string &layer_id = "circles", double opacity = 1.0);
+        bool addCircle (unsigned int x, unsigned int y, double radius, const string &layer_id, double opacity)
+        
+        # brief Add a circle shape from a point and a radius
+        # param[in] x the x coordinate of the circle center
+        # param[in] y the y coordinate of the circle center
+        # param[in] radius the radius of the circle
+        # param[in] r the red channel of the color that the sphere should be rendered with (0.0 -> 1.0)
+        # param[in] g the green channel of the color that the sphere should be rendered with (0.0 -> 1.0)
+        # param[in] b the blue channel of the color that the sphere should be rendered with (0.0 -> 1.0)
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addCircle (unsigned int x, unsigned int y, double radius, 
+        #            double r, double g, double b,
+        #            const std::string &layer_id = "circles", double opacity = 1.0);
+        bool addCircle (unsigned int x, unsigned int y, double radius, double r, double g, double b, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and color its edges with a given color
+        # param[in] min_pt the X,Y min coordinate
+        # param[in] max_pt the X,Y max coordinate
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addRectangle (const pcl::PointXY &min_pt, const pcl::PointXY &max_pt,
+        #               const std::string &layer_id = "rectangles", double opacity = 1.0);
+        # bool addRectangle (const pcl::PointXY &min_pt, const pcl::PointXY &max_pt, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and color its edges with a given color
+        # param[in] min_pt the X,Y min coordinate
+        # param[in] max_pt the X,Y max coordinate
+        # param[in] r the red channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] g the green channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] b the blue channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addRectangle (const pcl::PointXY &min_pt, const pcl::PointXY &max_pt,
+        #               double r, double g, double b,
+        #               const std::string &layer_id = "rectangles", double opacity = 1.0);
+        # bool addRectangle (const pcl::PointXY &min_pt, const pcl::PointXY &max_pt, double r, double g, double b, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and color its edges with a given color
+        # param[in] x_min the X min coordinate
+        # param[in] x_max the X max coordinate
+        # param[in] y_min the Y min coordinate
+        # param[in] y_max the Y max coordinate 
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addRectangle (unsigned int x_min, unsigned int x_max, unsigned int y_min, unsigned int y_max,  
+        #               const std::string &layer_id = "rectangles", double opacity = 1.0);
+        # bool addRectangle (unsigned int x_min, unsigned int x_max, unsigned int y_min, unsigned int y_max, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and color its edges with a given color
+        # param[in] x_min the X min coordinate
+        # param[in] x_max the X max coordinate
+        # param[in] y_min the Y min coordinate
+        # param[in] y_max the Y max coordinate 
+        # param[in] r the red channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] g the green channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] b the blue channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addRectangle (unsigned int x_min, unsigned int x_max, unsigned int y_min, unsigned int y_max,  
+        #               double r, double g, double b,
+        #               const std::string &layer_id = "rectangles", double opacity = 1.0);
+        # bool addRectangle (unsigned int x_min, unsigned int x_max, unsigned int y_min, unsigned int y_max, double r, double g, double b, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and color its edges with a given color
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] min_pt the X,Y min coordinate
+        # param[in] max_pt the X,Y max coordinate
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # template <typename T> bool
+        # addRectangle (const typename pcl::PointCloud<T>::ConstPtr &image, 
+        #               const T &min_pt, const T &max_pt,
+        #               const std::string &layer_id = "rectangles", double opacity = 1.0);
+        # bool addRectangle (const shared_ptr[cpp.PointCloud[T]] &image, const T &min_pt, const T &max_pt, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and color its edges with a given color
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] min_pt the X,Y min coordinate
+        # param[in] max_pt the X,Y max coordinate
+        # param[in] r the red channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] g the green channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] b the blue channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # template <typename T> bool
+        # addRectangle (const typename pcl::PointCloud<T>::ConstPtr &image, 
+        #               const T &min_pt, const T &max_pt,
+        #               double r, double g, double b,
+        #               const std::string &layer_id = "rectangles", double opacity = 1.0);
+        # bool addRectangle (const shared_ptr[cpp.PointCloud[T]] &image, const T &min_pt, const T &max_pt, double r, double g, double b, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box that contains a given image mask and color its edges
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] mask the point data representing the mask that we want to draw
+        # param[in] r the red channel of the color that the mask should be rendered with 
+        # param[in] g the green channel of the color that the mask should be rendered with
+        # param[in] b the blue channel of the color that the mask should be rendered with
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn.
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # template <typename T> bool
+        # addRectangle (const typename pcl::PointCloud<T>::ConstPtr &image, const pcl::PointCloud<T> &mask, 
+        #               double r, double g, double b, 
+        #               const std::string &layer_id = "rectangles", double opacity = 1.0);
+        # bool addRectangle (
+        #                     const cpp.PointCloud[T] &image,
+        #                     const cpp.PointCloud[T] &mask, 
+        #                     double r, double g, double b, 
+        #                     const string &layer_id, double opacity)
+        
+        # brief Add a 2D box that contains a given image mask and color its edges in red
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] mask the point data representing the mask that we want to draw
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn.
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # template <typename T> bool
+        # addRectangle (const typename pcl::PointCloud<T>::ConstPtr &image, const pcl::PointCloud<T> &mask, 
+        #               const std::string &layer_id = "image_mask", double opacity = 1.0);
+        # bool addRectangle (const shared_ptr[cpp.PointCloud[T]] &image, const shared_ptr[cpp.PointCloud[T]] &mask, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and fill it in with a given color
+        # param[in] x_min the X min coordinate
+        # param[in] x_max the X max coordinate
+        # param[in] y_min the Y min coordinate
+        # param[in] y_max the Y max coordinate 
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 0.5)
+        # bool
+        # addFilledRectangle (unsigned int x_min, unsigned int x_max, unsigned int y_min, unsigned int y_max,  
+        #                     const std::string &layer_id = "boxes", double opacity = 0.5);
+        bool addFilledRectangle (unsigned int x_min, unsigned int x_max, unsigned int y_min, unsigned int y_max, const string &layer_id, double opacity)
+        
+        # brief Add a 2D box and fill it in with a given color
+        # param[in] x_min the X min coordinate
+        # param[in] x_max the X max coordinate
+        # param[in] y_min the Y min coordinate
+        # param[in] y_max the Y max coordinate 
+        # param[in] r the red channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] g the green channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] b the blue channel of the color that the box should be rendered with (0.0 -> 1.0)
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 0.5)
+        # bool addFilledRectangle (unsigned int x_min, unsigned int x_max, unsigned int y_min, unsigned int y_max,  
+        #                     double r, double g, double b,
+        #                     const std::string &layer_id = "boxes", double opacity = 0.5);
+        bool addFilledRectangle (
+                                    unsigned int x_min, unsigned int x_max,
+                                    unsigned int y_min, unsigned int y_max,  
+                                    double r, double g, double b,
+                                    const string &layer_id, double opacity)
+        
+        # brief Add a 2D line with a given color
+        # param[in] x_min the X min coordinate
+        # param[in] y_min the Y min coordinate
+        # param[in] x_max the X max coordinate
+        # param[in] y_max the Y max coordinate 
+        # param[in] r the red channel of the color that the line should be rendered with (0.0 -> 1.0)
+        # param[in] g the green channel of the color that the line should be rendered with (0.0 -> 1.0)
+        # param[in] b the blue channel of the color that the line should be rendered with (0.0 -> 1.0)
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addLine (unsigned int x_min, unsigned int y_min, unsigned int x_max, unsigned int y_max,
+        #          double r, double g, double b, 
+        #          const std::string &layer_id = "line", double opacity = 1.0);
+        bool addLine (
+                      unsigned int x_min, unsigned int y_min,
+                      unsigned int x_max, unsigned int y_max,
+                      double r, double g, double b, 
+                      const string &layer_id, double opacity)
+        
+        # brief Add a 2D line with a given color
+        # param[in] x_min the X min coordinate
+        # param[in] y_min the Y min coordinate
+        # param[in] x_max the X max coordinate
+        # param[in] y_max the Y max coordinate 
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn. 
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # bool
+        # addLine (unsigned int x_min, unsigned int y_min, unsigned int x_max, unsigned int y_max,
+        #          const std::string &layer_id = "line", double opacity = 1.0);
+        bool addLine (
+                        unsigned int x_min, unsigned int y_min,
+                        unsigned int x_max, unsigned int y_max,
+                        const string &layer_id, double opacity)
+        
+        # brief Add a generic 2D mask to an image 
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] mask the point data representing the mask that we want to draw
+        # param[in] r the red channel of the color that the mask should be rendered with 
+        # param[in] g the green channel of the color that the mask should be rendered with
+        # param[in] b the blue channel of the color that the mask should be rendered with
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn.
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 0.5)
+        # template <typename T> bool
+        # addMask (const typename pcl::PointCloud<T>::ConstPtr &image, const pcl::PointCloud<T> &mask, 
+        #          double r, double g, double b, 
+        #          const std::string &layer_id = "image_mask", double opacity = 0.5);
+        # addMask (const shared_ptr[cpp.PointCloud[T]] &image, const shared_ptr[cpp.PointCloud[T]] &mask, double r, double g, double b, const string &layer_id, double opacity)
+        
+        # brief Add a generic 2D mask to an image (colored in red)
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] mask the point data representing the mask that we want to draw
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn.
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 0.5)
+        # template <typename T> bool
+        # addMask (const typename pcl::PointCloud<T>::ConstPtr &image, const pcl::PointCloud<T> &mask, 
+        #          const std::string &layer_id = "image_mask", double opacity = 0.5);
+        # bool addMask (const shared_ptr[cpp.PointCloud[T]] &image, const shared_ptr[cpp.PointCloud[T]] &mask, const string &layer_id, double opacity)
+        
+        # brief Add a generic 2D planar polygon to an image 
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] polygon the point data representing the polygon that we want to draw. 
+        # A line will be drawn from each point to the next in the dataset.
+        # param[in] r the red channel of the color that the polygon should be rendered with 
+        # param[in] g the green channel of the color that the polygon should be rendered with
+        # param[in] b the blue channel of the color that the polygon should be rendered with
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn.
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # template <typename T> bool
+        # addPlanarPolygon (const typename pcl::PointCloud<T>::ConstPtr &image, const pcl::PlanarPolygon<T> &polygon, 
+        #                   double r, double g, double b, 
+        #                   const std::string &layer_id = "planar_polygon", double opacity = 1.0);
+        # bool addPlanarPolygon (const shared_ptr[cpp.PointCloud[T]] &image, const cpp.PlanarPolygon[T] &polygon, double r, double g, double b, const string &layer_id, double opacity)
+        
+        # brief Add a generic 2D planar polygon to an image 
+        # param[in] image the organized point cloud dataset containing the image data
+        # param[in] polygon the point data representing the polygon that we want to draw. 
+        # A line will be drawn from each point to the next in the dataset.
+        # param[in] layer_id the 2D layer ID where we want the extra information to be drawn.
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 1.0)
+        # 
+        # template <typename T> bool
+        # addPlanarPolygon (const typename pcl::PointCloud<T>::ConstPtr &image, const pcl::PlanarPolygon<T> &polygon, 
+        #                   const std::string &layer_id = "planar_polygon", double opacity = 1.0);
+        # bool addPlanarPolygon (const shared_ptr[cpp.PointCloud[T]] &image, const cpp.PlanarPolygon[T] &polygon, const string &layer_id, double opacity)
+        
+        # brief Add a new 2D rendering layer to the viewer. 
+        # param[in] layer_id the name of the layer
+        # param[in] width the width of the layer
+        # param[in] height the height of the layer
+        # param[in] opacity the opacity of the layer: 0 for invisible, 1 for opaque. (default: 0.5)
+        # bool addLayer (const std::string &layer_id, int width, int height, double opacity = 0.5);
+        bool addLayer (const string &layer_id, int width, int height, double opacity)
+        
+        # brief Remove a 2D layer given by its ID.
+        # param[in] layer_id the name of the layer
+        # void removeLayer (const std::string &layer_id);
+        void removeLayer (const string &layer_id)
+
+
+###
+
+# interactor.h
+# namespace pcl
+# namespace visualization
+#     /** \brief The PCLVisualizer interactor */
+# #ifdef _WIN32
+#     class PCL_EXPORTS PCLVisualizerInteractor : public vtkWin32RenderWindowInteractor
+# #elif defined VTK_USE_CARBON
+#     class PCLVisualizerInteractor : public vtkCarbonRenderWindowInteractor
+# #elif defined VTK_USE_COCOA
+#     class PCLVisualizerInteractor : public vtkCocoaRenderWindowInteractor
+# #else
+#     class PCLVisualizerInteractor : public vtkXRenderWindowInteractor
+# #endif
+        # public:
+        # static PCLVisualizerInteractor *New ();
+        # 
+        # void stopLoop ();
+        # 
+        # bool stopped;
+        # int timer_id_;
+        # 
+        # #ifdef _WIN32
+        # int BreakLoopFlag;                // if true quit the GetMessage loop
+        # virtual void Start ();                         // Redefine the vtkWin32RenderWindowInteractor::Start method...
+        # vtkGetMacro (BreakLoopFlag, int);
+        # void SetBreakLoopFlag (int);           // Change the value of BreakLoopFlag
+        # void BreakLoopFlagOff ();              // set BreakLoopFlag to 0
+        # void BreakLoopFlagOn ();               // set BreakLoopFlag to 1 (quit)
+        # #endif
+
+
+###
+
+# interactor_style.h
+# namespace pcl
+# namespace visualization
+# /** \brief A list of potential keyboard modifiers for \ref PCLVisualizerInteractorStyle.
+#   * Defaults to Alt. 
+#   */ 
+# enum InteractorKeyboardModifier
+# {
+#   INTERACTOR_KB_MOD_ALT,
+#   INTERACTOR_KB_MOD_CTRL,
+#   INTERACTOR_KB_MOD_SHIFT
+# };
+
+# interactor_style.h
+# namespace pcl
+# namespace visualization
+# /** \brief PCLVisualizerInteractorStyle defines an unique, custom VTK
+#   * based interactory style for PCL Visualizer applications. Besides
+#   * defining the rendering style, we also create a list of custom actions
+#   * that are triggered on different keys being pressed:
+#   *
+#   * -        p, P   : switch to a point-based representation
+#   * -        w, W   : switch to a wireframe-based representation (where available)
+#   * -        s, S   : switch to a surface-based representation (where available)
+#   * -        j, J   : take a .PNG snapshot of the current window view
+#   * -        c, C   : display current camera/window parameters
+#   * -        f, F   : fly to point mode
+#   * -        e, E   : exit the interactor\
+#   * -        q, Q   : stop and call VTK's TerminateApp
+#   * -       + / -   : increment/decrement overall point size
+#   * -        g, G   : display scale grid (on/off)
+#   * -        u, U   : display lookup table (on/off)
+#   * -  r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]
+#   * -  ALT + s, S   : turn stereo mode on/off
+#   * -  ALT + f, F   : switch between maximized window mode and original size
+#   * -        l, L           : list all available geometric and color handlers for the current actor map
+#   * -  ALT + 0..9 [+ CTRL]  : switch between different geometric handlers (where available)
+#   * -        0..9 [+ CTRL]  : switch between different color handlers (where available)
+#   * - 
+#   * -  SHIFT + left click   : select a point
+#   *
+#   * \author Radu B. Rusu
+#   * \ingroup visualization
+#   */
+# class PCL_EXPORTS PCLVisualizerInteractorStyle : public vtkInteractorStyleTrackballCamera
+        # typedef boost::shared_ptr<CloudActorMap> CloudActorMapPtr;
+        # public:
+        # static PCLVisualizerInteractorStyle *New ();
+        # 
+        # /** \brief Empty constructor. */
+        # PCLVisualizerInteractorStyle () : 
+        #   init_ (), rens_ (), actors_ (), win_height_ (), win_width_ (), win_pos_x_ (), win_pos_y_ (),
+        #   max_win_height_ (), max_win_width_ (), grid_enabled_ (), grid_actor_ (), lut_enabled_ (),
+        #   lut_actor_ (), snapshot_writer_ (), wif_ (), mouse_signal_ (), keyboard_signal_ (),
+        #   point_picking_signal_ (), stereo_anaglyph_mask_default_ (), mouse_callback_ (), modifier_ ()
+        # {}
+        # 
+        # // this macro defines Superclass, the isA functionality and the safe downcast method
+        # vtkTypeMacro (PCLVisualizerInteractorStyle, vtkInteractorStyleTrackballCamera);
+        # 
+        # /** \brief Initialization routine. Must be called before anything else. */
+        # virtual void Initialize ();
+        # 
+        # /** \brief Pass a pointer to the actor map
+        #   * \param[in] actors the actor map that will be used with this style
+        #   */
+        # inline void setCloudActorMap (const CloudActorMapPtr &actors) { actors_ = actors; }
+        # 
+        # /** \brief Get the cloud actor map pointer. */
+        # inline CloudActorMapPtr getCloudActorMap () { return (actors_); }
+        # 
+        # /** \brief Pass a set of renderers to the interactor style. 
+        #   * \param[in] rens the vtkRendererCollection to use
+        #   */
+        # void setRendererCollection (vtkSmartPointer<vtkRendererCollection> &rens) { rens_ = rens; }
+        # 
+        # /** \brief Register a callback function for mouse events
+        #   * \param[in] cb a boost function that will be registered as a callback for a mouse event
+        #   * \return a connection object that allows to disconnect the callback function.
+        #   */
+        # boost::signals2::connection registerMouseCallback (boost::function<void (const pcl::visualization::MouseEvent&)> cb);
+        # 
+        # /** \brief Register a callback boost::function for keyboard events
+        #   * \param[in] cb a boost function that will be registered as a callback for a keyboard event
+        #   * \return a connection object that allows to disconnect the callback function.
+        #   */
+        # boost::signals2::connection registerKeyboardCallback (boost::function<void (const pcl::visualization::KeyboardEvent&)> cb);
+        # 
+        # /** \brief Register a callback function for point picking events
+        #   * \param[in] cb a boost function that will be registered as a callback for a point picking event
+        #   * \return a connection object that allows to disconnect the callback function.
+        #   */
+        # boost::signals2::connection registerPointPickingCallback (boost::function<void (const pcl::visualization::PointPickingEvent&)> cb);
+        # 
+        # /** \brief Save the current rendered image to disk, as a PNG screenshot.
+        #   * \param[in] file the name of the PNG file
+        #   */
+        # void saveScreenshot (const std::string &file);
+        # 
+        # /** \brief Change the default keyboard modified from ALT to a different special key.
+        #   * Allowed values are:
+        #   * - INTERACTOR_KB_MOD_ALT
+        #   * - INTERACTOR_KB_MOD_CTRL
+        #   * - INTERACTOR_KB_MOD_SHIFT
+        #   * \param[in] modifier the new keyboard modifier
+        #   */
+        # inline void setKeyboardModifier (const InteractorKeyboardModifier &modifier)
+
+
+###
+
+# interactor_style.h
+# namespace pcl
+# namespace visualization
+# /** \brief PCL histogram visualizer interactory style class.
+#   * \author Radu B. Rusu
+#   */
+# class PCLHistogramVisualizerInteractorStyle : public vtkInteractorStyleTrackballCamera
+        # public:
+        # static PCLHistogramVisualizerInteractorStyle *New ();
+        # 
+        # /** \brief Empty constructor. */
+        # PCLHistogramVisualizerInteractorStyle () : wins_ (), init_ (false) {}
+        # 
+        # /** \brief Initialization routine. Must be called before anything else. */
+        # void Initialize ();
+        # 
+        # /** \brief Pass a map of render/window/interactors to the interactor style. 
+        #   * \param[in] wins the RenWinInteract map to use
+        #   */
+        # void setRenWinInteractMap (const RenWinInteractMap &wins) { wins_ = wins; }
+
+
+###
+
+# keyboard_event.h
+# namespace pcl
+# namespace visualization
+# /** /brief Class representing key hit/release events */
+# class KeyboardEvent
+        # public:
+        # /** \brief bit patter for the ALT key*/
+        # static const unsigned int Alt   = 1;
+        # /** \brief bit patter for the Control key*/
+        # static const unsigned int Ctrl  = 2;
+        # /** \brief bit patter for the Shift key*/
+        # static const unsigned int Shift = 4;
+        # 
+        # /** \brief Constructor
+        #   * \param[in] action    true for key was pressed, false for released
+        #   * \param[in] key_sym   the key-name that caused the action
+        #   * \param[in] key       the key code that caused the action
+        #   * \param[in] alt       whether the alt key was pressed at the time where this event was triggered
+        #   * \param[in] ctrl      whether the ctrl was pressed at the time where this event was triggered
+        #   * \param[in] shift     whether the shift was pressed at the time where this event was triggered
+        #   */
+        # inline KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift);
+        # 
+        # /**
+        #   * \return   whether the alt key was pressed at the time where this event was triggered
+        #   */
+        # inline bool isAltPressed () const;
+        # 
+        # /**
+        #   * \return whether the ctrl was pressed at the time where this event was triggered
+        #   */
+        # inline bool isCtrlPressed () const;
+        # 
+        # /**
+        #   * \return whether the shift was pressed at the time where this event was triggered
+        #   */
+        # inline bool isShiftPressed () const;
+        # 
+        # /**
+        #   * \return the ASCII Code of the key that caused the event. If 0, then it was a special key, like ALT, F1, F2,... PgUp etc. Then the name of the key is in the keysym field.
+        #   */
+        # inline unsigned char getKeyCode () const;
+        # 
+        # /**
+        #   * \return name of the key that caused the event
+        #   */
+        # inline const std::string& getKeySym () const;
+        # 
+        # /**
+        #   * \return true if a key-press caused the event, false otherwise
+        #   */
+        # inline bool keyDown () const;
+        # 
+        # /**
+        #   * \return true if a key-release caused the event, false otherwise
+        #   */
+        # inline bool keyUp () const;
+
+    # KeyboardEvent::KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift)
+    #   : action_ (action)
+    #   , modifiers_ (0)
+    #   , key_code_(key)
+    #   , key_sym_ (key_sym)
+    # 
+    # bool KeyboardEvent::isAltPressed () const
+    # bool KeyboardEvent::isCtrlPressed () const
+    # bool KeyboardEvent::isShiftPressed () const
+    # unsigned char KeyboardEvent::getKeyCode () const
+    # const std::string& KeyboardEvent::getKeySym () const
+    # bool KeyboardEvent::keyDown () const
+    # bool KeyboardEvent::keyUp () const
+
+
+###
+
+# mouse_event.h
+# namespace pcl
+# namespace visualization
+# class MouseEvent
+        # public:
+        # typedef enum
+        # {
+        #   MouseMove = 1,
+        #       MouseButtonPress,
+        #       MouseButtonRelease,
+        #       MouseScrollDown,
+        #       MouseScrollUp,
+        #       MouseDblClick
+        # } Type;
+        # 
+        # typedef enum
+        # {
+        #       NoButton      = 0,
+        #       LeftButton,
+        #       MiddleButton,
+        #       RightButton,
+        #       VScroll /*other buttons, scroll wheels etc. may follow*/
+        # } MouseButton;
+        # 
+        # /** Constructor.
+        #   * \param[in] type   event type
+        #   * \param[in] button The Button that causes the event
+        #   * \param[in] x      x position of mouse pointer at that time where event got fired
+        #   * \param[in] y      y position of mouse pointer at that time where event got fired
+        #   * \param[in] alt    whether the ALT key was pressed at that time where event got fired
+        #   * \param[in] ctrl   whether the CTRL key was pressed at that time where event got fired
+        #   * \param[in] shift  whether the Shift key was pressed at that time where event got fired
+        #   */
+        # inline MouseEvent (const Type& type, const MouseButton& button, unsigned int x, unsigned int y, bool alt, bool ctrl, bool shift);
+        # 
+        # /**
+        #   * \return type of mouse event
+        #   */
+        # inline const Type& getType () const;
+        # 
+        # /**
+        #   * \brief Sets the mouse event type
+        #   */
+        # inline void setType (const Type& type);
+        # 
+        # /**
+        #   * \return the Button that caused the action
+        #   */
+        # inline const MouseButton& getButton () const;
+        # 
+        # /** \brief Set the button that caused the event */
+        # inline void setButton (const MouseButton& button);
+        # 
+        # /**
+        #   * \return the x position of the mouse pointer at that time where the event got fired
+        #   */
+        # inline unsigned int getX () const;
+        # 
+        # /**
+        #   * \return the y position of the mouse pointer at that time where the event got fired
+        #   */
+        # inline unsigned int getY () const;
+        # 
+        # /**
+        #   * \return returns the keyboard modifiers state at that time where the event got fired
+        #   */
+        # inline unsigned int getKeyboardModifiers () const;
+        # 
+
+    # MouseEvent::MouseEvent (const Type& type, const MouseButton& button, unsigned x, unsigned y,  bool alt, bool ctrl, bool shift)
+    # : type_ (type)
+    # , button_ (button)
+    # , pointer_x_ (x)
+    # , pointer_y_ (y)
+    # , key_state_ (0)
+    # 
+    # const MouseEvent::Type& MouseEvent::getType () const
+    # void MouseEvent::setType (const Type& type)
+    # const MouseEvent::MouseButton& MouseEvent::getButton () const
+    # void MouseEvent::setButton (const MouseButton& button)
+    # unsigned int MouseEvent::getX () const
+    # unsigned int MouseEvent::getY () const
+    # unsigned int MouseEvent::getKeyboardModifiers () const
+
+
+###
+
+# point_picking_event.h
+# class PCL_EXPORTS PointPickingCallback : public vtkCommand
+        # public:
+        # static PointPickingCallback *New () 
+        # PointPickingCallback () : x_ (0), y_ (0), z_ (0), idx_ (-1), pick_first_ (false) {}
+        # 
+        # virtual void Execute (vtkObject *caller, unsigned long eventid, void*);
+        # 
+        # int performSinglePick (vtkRenderWindowInteractor *iren);
+        # 
+        # int performSinglePick (vtkRenderWindowInteractor *iren, float &x, float &y, float &z);
+###
+
+# class PCL_EXPORTS PointPickingEvent
+        # public:
+        # PointPickingEvent (int idx) : idx_ (idx), idx2_ (-1), x_ (), y_ (), z_ (), x2_ (), y2_ (), z2_ () {}
+        # PointPickingEvent (int idx, float x, float y, float z) : idx_ (idx), idx2_ (-1), x_ (x), y_ (y), z_ (z), x2_ (), y2_ (), z2_ () {}
+        # 
+        # PointPickingEvent (int idx1, int idx2, float x1, float y1, float z1, float x2, float y2, float z2) :
+        
+        # /** \brief Obtain the ID of a point that the user just clicked on. */
+        # inline int getPointIndex () const
+        
+        # /** \brief Obtain the XYZ point coordinates of a point that the user just clicked on.
+        #   * \param[out] x the x coordinate of the point that got selected by the user
+        #   * \param[out] y the y coordinate of the point that got selected by the user
+        #   * \param[out] z the z coordinate of the point that got selected by the user
+        #   */
+        # inline void getPoint (float &x, float &y, float &z) const
+        
+        # /** \brief For situations when multiple points are selected in a sequence, return the point coordinates.
+        #   * \param[out] x1 the x coordinate of the first point that got selected by the user
+        #   * \param[out] y1 the y coordinate of the first point that got selected by the user
+        #   * \param[out] z1 the z coordinate of the firts point that got selected by the user
+        #   * \param[out] x2 the x coordinate of the second point that got selected by the user
+        #   * \param[out] y2 the y coordinate of the second point that got selected by the user
+        #   * \param[out] z2 the z coordinate of the second point that got selected by the user
+        #   * \return true, if two points are available and have been clicked by the user, false otherwise
+        # inline bool getPoints (float &x1, float &y1, float &z1, float &x2, float &y2, float &z2) const
+###
+
+# range_image_visualizer.h
+# class PCL_EXPORTS RangeImageVisualizer : public ImageViewer
+cdef extern from "pcl/visualization/range_image_visualizer.h" namespace "pcl::visualization" nogil:
+    cdef cppclass RangeImageVisualizer(ImageViewer):
+        RangeImageVisualizer()
+        RangeImageVisualizer (const string name)
+        # public:
+        # =====CONSTRUCTOR & DESTRUCTOR=====
+        # //! Constructor
+        # RangeImageVisualizer (const std::string& name="Range Image");
+        # //! Destructor
+        # ~RangeImageVisualizer ();
+        
+        # =====PUBLIC STATIC METHODS=====
+        # Get a widget visualizing the given range image.
+        # You are responsible for deleting it after usage!
+        # static RangeImageVisualizer* getRangeImageWidget (
+        #                                   const pcl::RangeImage& range_image, float min_value,
+        #                                   float max_value, bool grayscale, const std::string& name="Range image");
+        # RangeImageVisualizer* getRangeImageWidget (pcl.RangeImage& range_image, float min_value, float max_value, bool grayscale, const string& name)
+        
+        # Visualize the given range image and the detected borders in it.
+        # Borders on the obstacles are marked green, borders on the background are marked bright blue.
+        # void visualizeBorders (const pcl::RangeImage& range_image, float min_value, float max_value, bool grayscale,
+        #                        const pcl::PointCloud<pcl::BorderDescription>& border_descriptions);
+        # void visualizeBorders (const pcl.RangeImage& range_image, float min_value, float max_value, bool grayscale, const cpp.PointCloud[cpp.BorderDescription] &border_descriptions)
+        
+        # /** Same as above, but returning a new widget. You are responsible for deleting it after usage!
+        # static RangeImageVisualizer* getRangeImageBordersWidget (const pcl::RangeImage& range_image, float min_value,
+        #               float max_value, bool grayscale, const pcl::PointCloud<pcl::BorderDescription>& border_descriptions,
+        #               const std::string& name="Range image with borders");
+        # RangeImageVisualizer* getRangeImageBordersWidget (
+        #                 const pcl.RangeImage& range_image, 
+        #                 float min_value,
+        #                 float max_value,
+        #                 bool grayscale, 
+        #                 const cpp.PointCloud[cpp.BorderDescription] &border_descriptions,
+        #                 const string& name)
+        
+        # Get a widget visualizing the given angle image (assuming values in (-PI, PI]).
+        # -PI and PI will return the same color
+        # You are responsible for deleting it after usage!
+        # static RangeImageVisualizer* getAnglesWidget (const pcl::RangeImage& range_image, float* angles_image, const std::string& name);
+        RangeImageVisualizer* getAnglesWidget (const RangeImage& range_image, float* angles_image, const string& name)
+        
+        # Get a widget visualizing the given angle image (assuming values in (-PI/2, PI/2]).
+        # -PI/2 and PI/2 will return the same color
+        # You are responsible for deleting it after usage!
+        # RangeImageVisualizer* getHalfAnglesWidget (const pcl.RangeImage& range_image, float* angles_image, const string& name)
+        RangeImageVisualizer* getHalfAnglesWidget (const RangeImage& range_image, float* angles_image, const string& name)
+        
+        # /** Get a widget visualizing the interest values and extracted interest points.
+        #  * The interest points will be marked green.
+        #  *  You are responsible for deleting it after usage! */
+        # static RangeImageVisualizer* getInterestPointsWidget (const pcl::RangeImage& range_image, const float* interest_image, float min_value, float max_value,
+        #                                                       const pcl::PointCloud<pcl::InterestPoint>& interest_points, const std::string& name);
+        RangeImageVisualizer* getInterestPointsWidget (const RangeImage& range_image, const float* interest_image, float min_value, float max_value, const cpp.PointCloud[cpp.InterestPoint] &interest_points, const string& name)
+        
+        # // =====PUBLIC METHODS=====
+        # //! Visualize a range image
+        # /* void  */
+        # /* setRangeImage (const pcl::RangeImage& range_image,  */
+        # /*                float min_value = -std::numeric_limits<float>::infinity (),  */
+        # /*                float max_value =  std::numeric_limits<float>::infinity (),  */
+        # /*                bool grayscale  = false); */
+        
+        # void showRangeImage (const pcl::RangeImage& range_image, 
+        #                       float min_value = -std::numeric_limits<float>::infinity (), 
+        #                       float max_value =  std::numeric_limits<float>::infinity (), 
+        #                       bool grayscale  = false);
+        void showRangeImage (const RangeImage range_image,  float min_value, float max_value, bool grayscale)
+
+
+###
+
+# registration_visualizer.h
+# template<typename PointSource, typename PointTarget>
+# class RegistrationVisualizer
+cdef extern from "pcl/visualization/registration_visualizer.h" namespace "pcl::visualization" nogil:
+    cdef cppclass RegistrationVisualizer[Source, Target]:
+        RegistrationVisualizer ()
+        
+        # public:
+        # /** \brief Set the registration algorithm whose intermediate steps will be rendered.
+        # * The method creates the local callback function pcl::RegistrationVisualizer::update_visualizer_ and
+        # * binds it to the local biffers update function pcl::RegistrationVisualizer::updateIntermediateCloud().
+        # * The local callback function pcl::RegistrationVisualizer::update_visualizer_ is then linked to
+        # * the pcl::Registration::update_visualizer_ callback function.
+        # * \param registration represents the registration method whose intermediate steps will be rendered.
+        # bool setRegistration (pcl::Registration<PointSource, PointTarget> &registration)
+        # bool setRegistration (pcl.Registration[Source, Target] &registration)
+        
+        # /** \brief Start the viewer thread
+        # void startDisplay ();
+        void startDisplay ()
+        
+        # /** \brief Stop the viewer thread
+        # void stopDisplay ();
+        void stopDisplay ()
+        
+        # /** \brief Updates visualizer local buffers cloud_intermediate, cloud_intermediate_indices, cloud_target_indices with
+        # * the newest registration intermediate results.
+        # * \param cloud_src represents the initial source point cloud
+        # * \param indices_src represents the incices of the intermediate source points used for the estimation of rigid transformation
+        # * \param cloud_tgt represents the target point cloud
+        # * \param indices_tgt represents the incices of the target points used for the estimation of rigid transformation
+        # void updateIntermediateCloud (const pcl::PointCloud<PointSource> &cloud_src, const std::vector<int> &indices_src, const pcl::PointCloud<PointTarget> &cloud_tgt, const std::vector<int> &indices_tgt);
+        void updateIntermediateCloud (const cpp.PointCloud[Source] &cloud_src, const vector[int] &indices_src,
+                                      const cpp.PointCloud[Target] &cloud_tgt, const vector[int] &indices_tgt)
+        
+        # /** \brief Set maximum number of corresponcence lines whch will be rendered. */
+        # inline void setMaximumDisplayedCorrespondences (const int maximum_displayed_correspondences)
+        void setMaximumDisplayedCorrespondences (const int maximum_displayed_correspondences)
+        
+        # /** \brief Return maximum number of corresponcence lines which are rendered. */
+        # inline size_t getMaximumDisplayedCorrespondences()
+        size_t getMaximumDisplayedCorrespondences()
+
+
+###
+
+# vtk.h
+# header file include define
+###
+
+# window.h
+# class PCL_EXPORTS Window
+cdef extern from "pcl/visualization/window.h" namespace "pcl::visualization" nogil:
+    cdef cppclass Window:
+        Window ()
+        # public:
+        # Window (const std::string& window_name = "");
+        # Window (const Window &src);
+        # Window& operator = (const Window &src);
+        # virtual ~Window ();
+        
+        # /** \brief Spin method. Calls the interactor and runs an internal loop. */
+        # void spin ()
+        
+        # /** \brief Spin once method. Calls the interactor and updates the screen once.
+        #   *  \param time - How long (in ms) should the visualization loop be allowed to run.
+        #   *  \param force_redraw - if false it might return without doing anything if the
+        #   *  interactor's framerate does not require a redraw yet.
+        # void spinOnce (int time = 1, bool force_redraw = false);
+        
+        # /** \brief Returns true when the user tried to close the window */
+        # bool wasStopped () const
+        
+        # /**
+        #   * @brief registering a callback function for keyboard events
+        #   * @param callback  the function that will be registered as a callback for a keyboard event
+        #   * @param cookie    user data that is passed to the callback
+        #   * @return          connection object that allows to disconnect the callback function.
+        # boost::signals2::connection registerKeyboardCallback (void (*callback) (const pcl::visualization::KeyboardEvent&, void*), void* cookie = NULL)
+        
+        # /**
+        #   * @brief registering a callback function for keyboard events
+        #   * @param callback  the member function that will be registered as a callback for a keyboard event
+        #   * @param instance  instance to the class that implements the callback function
+        #   * @param cookie    user data that is passed to the callback
+        #   * @return          connection object that allows to disconnect the callback function.
+        # template<typename T> boost::signals2::connection
+        # registerKeyboardCallback (void (T::*callback) (const pcl::visualization::KeyboardEvent&, void*), T& instance, void* cookie = NULL)
+        
+        # /**
+        #   * @brief
+        #   * @param callback  the function that will be registered as a callback for a mouse event
+        #   * @param cookie    user data that is passed to the callback
+        #   * @return          connection object that allows to disconnect the callback function.
+        # boost::signals2::connection
+        # registerMouseCallback (void (*callback) (const pcl::visualization::MouseEvent&, void*), void* cookie = NULL)
+        
+        # /**
+        #   * @brief registering a callback function for mouse events
+        #   * @param callback  the member function that will be registered as a callback for a mouse event
+        #   * @param instance  instance to the class that implements the callback function
+        #   * @param cookie    user data that is passed to the callback
+        #   * @return          connection object that allows to disconnect the callback function.
+        # template<typename T> boost::signals2::connection
+        # registerMouseCallback (void (T::*callback) (const pcl::visualization::MouseEvent&, void*), T& instance, void* cookie = NULL)
+
+
+###
+
+###############################################################################
+# Enum
+###############################################################################
+
+# common.h
+cdef extern from "pcl/visualization/common/common.h" namespace "pcl::visualization":
+    cdef enum FrustumCull:
+        PCL_INSIDE_FRUSTUM
+        PCL_INTERSECT_FRUSTUM
+        PCL_OUTSIDE_FRUSTUM
+
+cdef extern from "pcl/visualization/common/common.h" namespace "pcl::visualization":
+    cdef enum RenderingProperties:
+        PCL_VISUALIZER_POINT_SIZE
+        PCL_VISUALIZER_OPACITY
+        PCL_VISUALIZER_LINE_WIDTH
+        PCL_VISUALIZER_FONT_SIZE
+        PCL_VISUALIZER_COLOR
+        PCL_VISUALIZER_REPRESENTATION
+        PCL_VISUALIZER_IMMEDIATE_RENDERING
+        # PCL_VISUALIZER_SHADING
+
+cdef extern from "pcl/visualization/common/common.h" namespace "pcl::visualization":
+    cdef enum RenderingRepresentationProperties:
+        PCL_VISUALIZER_REPRESENTATION_POINTS
+        PCL_VISUALIZER_REPRESENTATION_WIREFRAME
+        PCL_VISUALIZER_REPRESENTATION_SURFACE
+
+cdef extern from "pcl/visualization/common/common.h" namespace "pcl::visualization":
+    cdef enum ShadingRepresentationProperties:
+        PCL_VISUALIZER_SHADING_FLAT
+        PCL_VISUALIZER_SHADING_GOURAUD
+        PCL_VISUALIZER_SHADING_PHONG
+
+###############################################################################
+# Activation
+###############################################################################
diff --git a/pcl/pxi/Common/Common.txt b/pcl/pxi/Common/Common.txt
new file mode 100644
index 0000000..0e00831
--- /dev/null
+++ b/pcl/pxi/Common/Common.txt
@@ -0,0 +1,199 @@
+cdef class Common:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s" type(init))
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+		
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZ *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.PointXYZ* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
+###
+# 
+# include "Segmentation.pxi"
+# include "SegmentationNormal.pxi"
+# include "StatisticalOutlierRemovalFilter.pxi"
+# include "VoxelGridFilter.pxi"
+# include "PassThroughFilter.pxi"
+# include "MovingLeastSquares.pxi"
+# include "KdTree_FLANN.pxi"
+# include "OctreePointCloud.pxi"
+# include "Vertices.pxi"
+# include "CropHull.pxi"
+# include "CropBox.pxi"
+# include "ProjectInliers.pxi"
+# include "RadiusOutlierRemoval.pxi"
+# include "ConditionAnd.pxi"
+# include "ConditionalRemoval.pxi"
+# # Ubuntu/Mac NG(1.7? 1.8?)
+# # include "UniformSampling.pxi"
+# # include "IntegralImageNormalEstimation.pxi"
+
diff --git a/pcl/pxi/Common/RangeImage/RangeImagePlanar.pxi b/pcl/pxi/Common/RangeImage/RangeImagePlanar.pxi
new file mode 100644
index 0000000..488cc01
--- /dev/null
+++ b/pcl/pxi/Common/RangeImage/RangeImagePlanar.pxi
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+from _pcl cimport PointCloud
+from _pcl cimport PointCloud_PointWithViewpoint
+cimport pcl_defs as cpp
+cimport pcl_range_image as pcl_r_img
+
+cimport eigen as eigen3
+from boost_shared_ptr cimport sp_assign
+
+from cython.operator cimport dereference as deref, preincrement as inc
+
+cdef class RangeImagePlanar:
+    """
+    RangeImagePlanar
+    """
+
+    def __cinit__(self):
+        # self.me = new pcl_r_img.RangeImagePlanar_t()
+        sp_assign(self.thisptr_shared, new pcl_r_img.RangeImagePlanar_t())
+        pass
+
+    def __cinit__(self, PointCloud pc not None):
+        # self.me = new pcl_r_img.RangeImagePlanar_t()
+        # self.point = pc.thisptr_shared
+        sp_assign(self.thisptr_shared,  new pcl_r_img.RangeImagePlanar_t())
+        self.thisptr().setInputCloud(pc.thisptr_shared)
+
+    def CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height, 
+        pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+        
+        print('CreateFromPointCloud enter')
+        
+        # cdef cpp.PointCloudPtr_t point
+        # point = cloud.thisptr_shared
+        # Eigen::Translation3f
+        cdef eigen3.Affine3f sensor_pose
+        cdef float *data = sensor_pose.data()
+        # print('sensor_pose size = ' + str( len(data) ) )
+        # cdef eigen3.Translation3f data(0.0, 0.0, 0.0)
+        # data[0] = 0.0
+        # data[1] = 0.0
+        # data[2] = 0.0
+        # data[3] = 0.0
+        # print('sensor_pose = ' + data)
+        # (Eigen::Affine3f)Eigen::Translation3f(0.0f, 0.0f, 0.0f);  
+        sensor_pose = <eigen3.Affine3f>eigen3.Translation3f(0.0, 0.0, 0.0)
+        
+        print('angular_resolution = ' + str(angular_resolution) )
+        print('max_angle_width = ' + str(max_angle_width) )
+        print('max_angle_height = ' + str(max_angle_height) )
+        print('noise_level = ' + str(noise_level) )
+        print('min_range = ' + str(min_range) )
+        print('border_size = ' + str(border_size) )
+        
+        print('cloud.size = ' + str(cloud.size) )
+        print('cloud.width = ' + str(cloud.width) )
+        print('cloud.height = ' + str(cloud.height) )
+        
+        print('call createFromPointCloud')
+        
+        self.thisptr().createFromPointCloud(
+            cloud.thisptr()[0],
+            angular_resolution,
+            max_angle_width,
+            max_angle_height,
+            sensor_pose, 
+            coordinate_frame, 
+            noise_level, 
+            min_range, 
+            border_size)
+    
+    def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):
+        self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+    
+    def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):
+        # cdef pcl_r_img.RangeImage_t *user
+        # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        self.thisptr().integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.thisprt()[0].integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+    
+    def SetUnseenToMaxRange(self):
+        self.thisptr()[0].setUnseenToMaxRange()
+
+
+###
+
diff --git a/pcl/pxi/Common/RangeImage/RangeImagePlanar_172.pxi b/pcl/pxi/Common/RangeImage/RangeImagePlanar_172.pxi
new file mode 100644
index 0000000..c609ddb
--- /dev/null
+++ b/pcl/pxi/Common/RangeImage/RangeImagePlanar_172.pxi
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+from _pcl cimport PointCloud
+from _pcl cimport PointCloud_PointWithViewpoint
+cimport pcl_defs as cpp
+cimport pcl_range_image_172 as pcl_r_img
+
+cimport eigen as eigen3
+from boost_shared_ptr cimport sp_assign
+
+from cython.operator cimport dereference as deref, preincrement as inc
+
+cdef class RangeImagePlanar:
+    """
+    RangeImagePlanar
+    """
+
+    def __cinit__(self):
+        # self.me = new pcl_r_img.RangeImagePlanar_t()
+        sp_assign(self.thisptr_shared, new pcl_r_img.RangeImagePlanar_t())
+        pass
+
+    def __cinit__(self, PointCloud pc not None):
+        # self.me = new pcl_r_img.RangeImagePlanar_t()
+        # self.point = pc.thisptr_shared
+        sp_assign(self.thisptr_shared,  new pcl_r_img.RangeImagePlanar_t())
+        self.thisptr().setInputCloud(pc.thisptr_shared)
+
+    def CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height, 
+        pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+        
+        print('CreateFromPointCloud enter')
+        
+        # cdef cpp.PointCloudPtr_t point
+        # point = cloud.thisptr_shared
+        # Eigen::Translation3f
+        cdef eigen3.Affine3f sensor_pose
+        cdef float *data = sensor_pose.data()
+        # print('sensor_pose size = ' + str( len(data) ) )
+        # cdef eigen3.Translation3f data(0.0, 0.0, 0.0)
+        # data[0] = 0.0
+        # data[1] = 0.0
+        # data[2] = 0.0
+        # data[3] = 0.0
+        # print('sensor_pose = ' + data)
+        # (Eigen::Affine3f)Eigen::Translation3f(0.0f, 0.0f, 0.0f);  
+        sensor_pose = <eigen3.Affine3f>eigen3.Translation3f(0.0, 0.0, 0.0)
+        
+        print('angular_resolution = ' + str(angular_resolution) )
+        print('max_angle_width = ' + str(max_angle_width) )
+        print('max_angle_height = ' + str(max_angle_height) )
+        print('noise_level = ' + str(noise_level) )
+        print('min_range = ' + str(min_range) )
+        print('border_size = ' + str(border_size) )
+        
+        print('cloud.size = ' + str(cloud.size) )
+        print('cloud.width = ' + str(cloud.width) )
+        print('cloud.height = ' + str(cloud.height) )
+        
+        print('call createFromPointCloud')
+        
+        self.thisptr().createFromPointCloud(
+            cloud.thisptr()[0],
+            angular_resolution,
+            max_angle_width,
+            max_angle_height,
+            sensor_pose, 
+            coordinate_frame, 
+            noise_level, 
+            min_range, 
+            border_size)
+    
+    def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):
+        self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+    
+    def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):
+        # cdef pcl_r_img.RangeImage_t *user
+        # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        self.thisptr().integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.thisprt()[0].integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+    
+    def SetUnseenToMaxRange(self):
+        self.thisptr()[0].setUnseenToMaxRange()
+
+
+###
+
diff --git a/pcl/pxi/Common/RangeImage/RangeImages.pxi b/pcl/pxi/Common/RangeImage/RangeImages.pxi
new file mode 100644
index 0000000..91280c2
--- /dev/null
+++ b/pcl/pxi/Common/RangeImage/RangeImages.pxi
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+from _pcl cimport PointCloud
+from _pcl cimport PointCloud_PointWithViewpoint
+cimport pcl_defs as cpp
+cimport pcl_range_image as pcl_r_img
+
+cimport eigen as eigen3
+from boost_shared_ptr cimport sp_assign
+
+from cython.operator cimport dereference as deref, preincrement as inc
+
+cdef class RangeImages:
+    """
+    rangeImage
+    """
+    def __cinit__(self):
+        # self.me = new pcl_r_img.RangeImage_t()
+        # NG : Compiler crash
+        # sp_assign(self.thisptr_shared, new pcl_r_img.RangeImage_t())
+        pass
+
+    # def __cinit__(self, PointCloud pc not None):
+    #     # self.me = new pcl_r_img.RangeImage_t()
+    #     # self.point = pc.thisptr_shared
+    #     # sp_assign(self.thisptr_shared,  new pcl_r_img.RangeImage_t())
+    #     # self.thisptr().setInputCloud(pc.thisptr_shared)
+    #     pass
+
+    def CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height, 
+        pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+        
+        print('CreateFromPointCloud enter')
+        
+        # cdef cpp.PointCloudPtr_t point
+        # point = cloud.thisptr_shared
+        # Eigen::Translation3f
+        cdef eigen3.Affine3f sensor_pose
+        cdef float *data = sensor_pose.data()
+        # print('sensor_pose size = ' + str( len(data) ) )
+        # cdef eigen3.Translation3f data(0.0, 0.0, 0.0)
+        # data[0] = 0.0
+        # data[1] = 0.0
+        # data[2] = 0.0
+        # data[3] = 0.0
+        # print('sensor_pose = ' + data)
+        # (Eigen::Affine3f)Eigen::Translation3f(0.0f, 0.0f, 0.0f);  
+        sensor_pose = <eigen3.Affine3f>eigen3.Translation3f(0.0, 0.0, 0.0)
+        
+        print('angular_resolution = ' + str(angular_resolution) )
+        print('max_angle_width = ' + str(max_angle_width) )
+        print('max_angle_height = ' + str(max_angle_height) )
+        print('noise_level = ' + str(noise_level) )
+        print('min_range = ' + str(min_range) )
+        print('border_size = ' + str(border_size) )
+        
+        print('cloud.size = ' + str(cloud.size) )
+        print('cloud.width = ' + str(cloud.width) )
+        print('cloud.height = ' + str(cloud.height) )
+        
+        print('call createFromPointCloud')
+        
+        self.thisptr().createFromPointCloud(
+            cloud.thisptr()[0],
+            angular_resolution,
+            max_angle_width,
+            max_angle_height,
+            sensor_pose, 
+            coordinate_frame, 
+            noise_level, 
+            min_range, 
+            border_size)
+
+    def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):
+        self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+
+    def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):
+        # cdef pcl_r_img.RangeImage_t *user
+        # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        self.thisptr().integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.thisprt()[0].integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+
+    def SetUnseenToMaxRange(self):
+        self.thisptr()[0].setUnseenToMaxRange()
+
+
+###
+
diff --git a/pcl/pxi/Common/RangeImage/RangeImages_172.pxi b/pcl/pxi/Common/RangeImage/RangeImages_172.pxi
new file mode 100644
index 0000000..c2ad409
--- /dev/null
+++ b/pcl/pxi/Common/RangeImage/RangeImages_172.pxi
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+from _pcl cimport PointCloud
+from _pcl cimport PointCloud_PointWithViewpoint
+cimport pcl_defs as cpp
+cimport pcl_range_image_172 as pcl_r_img
+
+cimport eigen as eigen3
+from boost_shared_ptr cimport sp_assign
+
+from cython.operator cimport dereference as deref, preincrement as inc
+
+cdef class RangeImages:
+    """
+    rangeImage
+    """
+    def __cinit__(self):
+        # self.me = new pcl_r_img.RangeImage_t()
+        # NG : Compiler crash
+        # sp_assign(self.thisptr_shared, new pcl_r_img.RangeImage_t())
+        pass
+
+    # def __cinit__(self, PointCloud pc not None):
+    #     # self.me = new pcl_r_img.RangeImage_t()
+    #     # self.point = pc.thisptr_shared
+    #     # sp_assign(self.thisptr_shared,  new pcl_r_img.RangeImage_t())
+    #     # self.thisptr().setInputCloud(pc.thisptr_shared)
+
+    def CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height, 
+        pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+        
+        print('CreateFromPointCloud enter')
+        
+        # cdef cpp.PointCloudPtr_t point
+        # point = cloud.thisptr_shared
+        # Eigen::Translation3f
+        cdef eigen3.Affine3f sensor_pose
+        cdef float *data = sensor_pose.data()
+        # print('sensor_pose size = ' + str( len(data) ) )
+        # cdef eigen3.Translation3f data(0.0, 0.0, 0.0)
+        # data[0] = 0.0
+        # data[1] = 0.0
+        # data[2] = 0.0
+        # data[3] = 0.0
+        # print('sensor_pose = ' + data)
+        # (Eigen::Affine3f)Eigen::Translation3f(0.0f, 0.0f, 0.0f);  
+        sensor_pose = <eigen3.Affine3f>eigen3.Translation3f(0.0, 0.0, 0.0)
+        
+        print('angular_resolution = ' + str(angular_resolution) )
+        print('max_angle_width = ' + str(max_angle_width) )
+        print('max_angle_height = ' + str(max_angle_height) )
+        print('noise_level = ' + str(noise_level) )
+        print('min_range = ' + str(min_range) )
+        print('border_size = ' + str(border_size) )
+        
+        print('cloud.size = ' + str(cloud.size) )
+        print('cloud.width = ' + str(cloud.width) )
+        print('cloud.height = ' + str(cloud.height) )
+        
+        print('call createFromPointCloud')
+        
+        self.thisptr().createFromPointCloud(
+            cloud.thisptr()[0],
+            angular_resolution,
+            max_angle_width,
+            max_angle_height,
+            sensor_pose, 
+            coordinate_frame, 
+            noise_level, 
+            min_range, 
+            border_size)
+
+    def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):
+        self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+
+    def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):
+        # cdef pcl_r_img.RangeImage_t *user
+        # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        self.thisptr().integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.thisprt()[0].integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+
+    def SetUnseenToMaxRange(self):
+        self.thisptr()[0].setUnseenToMaxRange()
+
+
+###
+
diff --git a/pcl/pxi/Common/RangeImage/RangeImages_180.pxi b/pcl/pxi/Common/RangeImage/RangeImages_180.pxi
new file mode 100644
index 0000000..e45fec4
--- /dev/null
+++ b/pcl/pxi/Common/RangeImage/RangeImages_180.pxi
@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+from _pcl cimport PointCloud
+from _pcl cimport PointCloud_PointWithViewpoint
+cimport pcl_defs as cpp
+cimport pcl_range_image_180 as pcl_r_img
+
+cimport eigen as eigen3
+from boost_shared_ptr cimport sp_assign
+
+from cython.operator cimport dereference as deref, preincrement as inc
+
+cdef class RangeImages:
+    """
+    rangeImage
+    """
+    def __cinit__(self):
+        # self.me = new pcl_r_img.RangeImage_t()
+        # NG : Compiler crash
+        # sp_assign(self.thisptr_shared, new pcl_r_img.RangeImage_t())
+        pass
+
+    # def __cinit__(self, PointCloud pc not None):
+    #     # self.me = new pcl_r_img.RangeImage_t()
+    #     # self.point = pc.thisptr_shared
+    #     # sp_assign(self.thisptr_shared,  new pcl_r_img.RangeImage_t())
+    #     # self.thisptr().setInputCloud(pc.thisptr_shared)
+    #     pass
+
+    def CreateFromPointCloud(self, PointCloud cloud, float angular_resolution, float max_angle_width, float max_angle_height, 
+        pcl_r_img.CoordinateFrame2 coordinate_frame, float noise_level, float min_range, int border_size):
+        
+        print('CreateFromPointCloud enter')
+        
+        # cdef cpp.PointCloudPtr_t point
+        # point = cloud.thisptr_shared
+        # Eigen::Translation3f
+        cdef eigen3.Affine3f sensor_pose
+        cdef float *data = sensor_pose.data()
+        # print('sensor_pose size = ' + str( len(data) ) )
+        # cdef eigen3.Translation3f data(0.0, 0.0, 0.0)
+        # data[0] = 0.0
+        # data[1] = 0.0
+        # data[2] = 0.0
+        # data[3] = 0.0
+        # print('sensor_pose = ' + data)
+        # (Eigen::Affine3f)Eigen::Translation3f(0.0f, 0.0f, 0.0f);  
+        sensor_pose = <eigen3.Affine3f>eigen3.Translation3f(0.0, 0.0, 0.0)
+        
+        print('angular_resolution = ' + str(angular_resolution) )
+        print('max_angle_width = ' + str(max_angle_width) )
+        print('max_angle_height = ' + str(max_angle_height) )
+        print('noise_level = ' + str(noise_level) )
+        print('min_range = ' + str(min_range) )
+        print('border_size = ' + str(border_size) )
+        
+        print('cloud.size = ' + str(cloud.size) )
+        print('cloud.width = ' + str(cloud.width) )
+        print('cloud.height = ' + str(cloud.height) )
+        
+        print('call createFromPointCloud')
+        
+        self.thisptr().createFromPointCloud(
+            cloud.thisptr()[0],
+            angular_resolution,
+            max_angle_width,
+            max_angle_height,
+            sensor_pose, 
+            coordinate_frame, 
+            noise_level, 
+            min_range, 
+            border_size)
+
+    def SetAngularResolution(self, float angular_resolution_x, float angular_resolution_y):
+        self.thisptr()[0].setAngularResolution(angular_resolution_x, angular_resolution_y)
+
+    def IntegrateFarRanges(self, PointCloud_PointWithViewpoint viewpoint):
+        # cdef pcl_r_img.RangeImage_t *user
+        # (<pcl_r_img.RangeImage *> self.thisptr()).integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        self.thisptr().integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.thisprt()[0].integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> viewpoint.thisptr()[0])
+        # self.me.integrateFarRanges(<cpp.PointCloud_PointWithViewpoint_t&> deref(viewpoint.thisptr()))
+
+    def SetUnseenToMaxRange(self):
+        self.thisptr()[0].setUnseenToMaxRange()
+
+
+###
+
diff --git a/pcl/pxi/Features/AddList.txt b/pcl/pxi/Features/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/Features/AddList.txt
diff --git a/pcl/pxi/Features/DifferenceOfNormalsEstimation_172.pxi b/pcl/pxi/Features/DifferenceOfNormalsEstimation_172.pxi
new file mode 100644
index 0000000..1af43d7
--- /dev/null
+++ b/pcl/pxi/Features/DifferenceOfNormalsEstimation_172.pxi
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_172 as pcl_ftr
+
+from boost_shared_ptr cimport sp_assign
+
+cdef class DifferenceOfNormalsEstimation:
+    """
+    DifferenceOfNormalsEstimation class for 
+    """
+    cdef pcl_ftr.DifferenceOfNormalsEstimation_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pcl_ftr.DifferenceOfNormalsEstimation_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+
diff --git a/pcl/pxi/Features/DifferenceOfNormalsEstimation_180.pxi b/pcl/pxi/Features/DifferenceOfNormalsEstimation_180.pxi
new file mode 100644
index 0000000..7ddf85f
--- /dev/null
+++ b/pcl/pxi/Features/DifferenceOfNormalsEstimation_180.pxi
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_180 as pcl_ftr
+
+from boost_shared_ptr cimport sp_assign
+
+cdef class DifferenceOfNormalsEstimation:
+    """
+    DifferenceOfNormalsEstimation class for 
+    """
+    cdef pcl_ftr.DifferenceOfNormalsEstimation_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pcl_ftr.DifferenceOfNormalsEstimation_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+
diff --git a/pcl/pxi/Features/IntegralImageNormalEstimation.pxi b/pcl/pxi/Features/IntegralImageNormalEstimation.pxi
new file mode 100644
index 0000000..bd151fa
--- /dev/null
+++ b/pcl/pxi/Features/IntegralImageNormalEstimation.pxi
@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features as pcl_ftr
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "minipcl.h":
+    void mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_compute(pcl_ftr.IntegralImageNormalEstimation_t, cpp.PointCloud_Normal_t ) except +
+
+cdef class IntegralImageNormalEstimation:
+    """
+    IntegralImageNormalEstimation class for 
+    """
+    # cdef pcl_ftr.IntegralImageNormalEstimation_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        print ('__cinit__ start')
+        sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())
+        # NG : Reference Count 
+        self.thisptr().setInputCloud(pc.thisptr_shared)
+        print ('__cinit__ end')
+        # self.me = new pcl_ftr.IntegralImageNormalEstimation_t()
+        # self.me.setInputCloud(pc.thisptr_shared)
+        # pass
+
+    def set_NormalEstimation_Method_AVERAGE_3D_GRADIENT (self):
+       mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_COVARIANCE_MATRIX (self):
+       mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (self):
+       mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (self):
+       mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    # enum Set NG
+    # def set_NormalEstimation_Method (self):
+    #    self.thisptr().setNormalEstimationMethod(pcl_ftr.NormalEstimationMethod2.ESTIMATIONMETHOD_COVARIANCE_MATRIX)
+
+    def set_MaxDepthChange_Factor(self, double param):
+        self.thisptr().setMaxDepthChangeFactor(param)
+
+    def set_NormalSmoothingSize(self, double param):
+        self.thisptr().setNormalSmoothingSize(param)
+
+    def compute(self, PointCloud pc not None):
+        # cdef PointCloud_PointNormal normal = PointCloud_PointNormal()
+        # normal = PointCloud_PointNormal()
+        normal = PointCloud_Normal()
+        # NG : No Python object
+        # normal = PointCloud_Normal(pc)
+        cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        print ('3')
+        # print (str(self.thisptr().size))
+        
+        # compute function based Features class
+        # NG 
+        # self.thisptr().compute (cPointCloudNormal.makeShared())
+        # self.thisptr().compute (cPointCloudNormal.makeShared().get())
+        # from cython cimport address
+        # self.thisptr().compute (cython.address(cPointCloudNormal.makeShared().get()))
+        # self.thisptr().compute (<cpp.PointCloud[Normal]> deref(cPointCloudNormal.makeShared().get()))
+        # NG : (Exception)
+        # self.thisptr().compute (deref(cPointCloudNormal.makeShared().get()))
+        self.thisptr().compute (deref(cPointCloudNormal))
+        print ('4')
+        return normal
+
+    def compute2(self, PointCloud pc not None):
+        normal = PointCloud_Normal()
+        cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        print ('3')
+        # OK
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), normals)
+        print ('3a')
+        # Copy?
+        cPointCloudNormal = normals.makeShared().get()
+        print ('3b')
+        
+        # NG : Normal Pointer Nothing?
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal.makeShared().get()))
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), cPointCloudNormal.makeShared().get())
+        # NG : Normal Pointer Nothing?
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal))
+        print ('4')
+        return normal
+
diff --git a/pcl/pxi/Features/IntegralImageNormalEstimation_172.pxi b/pcl/pxi/Features/IntegralImageNormalEstimation_172.pxi
new file mode 100644
index 0000000..e4798ed
--- /dev/null
+++ b/pcl/pxi/Features/IntegralImageNormalEstimation_172.pxi
@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_172 as pcl_ftr
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "minipcl.h":
+    void mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_compute(pcl_ftr.IntegralImageNormalEstimation_t, cpp.PointCloud_Normal_t ) except +
+
+cdef class IntegralImageNormalEstimation:
+    """
+    IntegralImageNormalEstimation class for 
+    """
+    # cdef pcl_ftr.IntegralImageNormalEstimation_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        print ('__cinit__ start')
+        sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())
+        # NG : Reference Count 
+        self.thisptr().setInputCloud(pc.thisptr_shared)
+        print ('__cinit__ end')
+        # self.me = new pcl_ftr.IntegralImageNormalEstimation_t()
+        # self.me.setInputCloud(pc.thisptr_shared)
+        # pass
+
+    def set_NormalEstimation_Method_AVERAGE_3D_GRADIENT (self):
+       mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_COVARIANCE_MATRIX (self):
+       mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (self):
+       mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (self):
+       mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    # enum Set NG
+    # def set_NormalEstimation_Method (self):
+    #    self.thisptr().setNormalEstimationMethod(pcl_ftr.NormalEstimationMethod2.ESTIMATIONMETHOD_COVARIANCE_MATRIX)
+
+    def set_MaxDepthChange_Factor(self, double param):
+        self.thisptr().setMaxDepthChangeFactor(param)
+
+    def set_NormalSmoothingSize(self, double param):
+        self.thisptr().setNormalSmoothingSize(param)
+
+    def compute(self, PointCloud pc not None):
+        # cdef PointCloud_PointNormal normal = PointCloud_PointNormal()
+        # normal = PointCloud_PointNormal()
+        normal = PointCloud_Normal()
+        # NG : No Python object
+        # normal = PointCloud_Normal(pc)
+        cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        print ('3')
+        # print (str(self.thisptr().size))
+        
+        # compute function based Features class
+        # NG 
+        # self.thisptr().compute (cPointCloudNormal.makeShared())
+        # self.thisptr().compute (cPointCloudNormal.makeShared().get())
+        # from cython cimport address
+        # self.thisptr().compute (cython.address(cPointCloudNormal.makeShared().get()))
+        # self.thisptr().compute (<cpp.PointCloud[Normal]> deref(cPointCloudNormal.makeShared().get()))
+        # NG : (Exception)
+        # self.thisptr().compute (deref(cPointCloudNormal.makeShared().get()))
+        self.thisptr().compute (deref(cPointCloudNormal))
+        print ('4')
+        return normal
+
+    def compute2(self, PointCloud pc not None):
+        normal = PointCloud_Normal()
+        cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        print ('3')
+        # OK
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), normals)
+        print ('3a')
+        # Copy?
+        cPointCloudNormal = normals.makeShared().get()
+        print ('3b')
+        
+        # NG : Normal Pointer Nothing?
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal.makeShared().get()))
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), cPointCloudNormal.makeShared().get())
+        # NG : Normal Pointer Nothing?
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal))
+        print ('4')
+        return normal
+
diff --git a/pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi b/pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi
new file mode 100644
index 0000000..60650e5
--- /dev/null
+++ b/pcl/pxi/Features/IntegralImageNormalEstimation_180.pxi
@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_180 as pcl_ftr
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "minipcl.h":
+    void mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(pcl_ftr.IntegralImageNormalEstimation_t ) except +
+    void mpcl_features_NormalEstimationMethod_compute(pcl_ftr.IntegralImageNormalEstimation_t, cpp.PointCloud_Normal_t ) except +
+
+cdef class IntegralImageNormalEstimation:
+    """
+    IntegralImageNormalEstimation class for 
+    """
+    # cdef pcl_ftr.IntegralImageNormalEstimation_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        print ('__cinit__ start')
+        sp_assign(self.thisptr_shared, new pcl_ftr.IntegralImageNormalEstimation[cpp.PointXYZ, cpp.Normal]())
+        # NG : Reference Count 
+        self.thisptr().setInputCloud(pc.thisptr_shared)
+        print ('__cinit__ end')
+        # self.me = new pcl_ftr.IntegralImageNormalEstimation_t()
+        # self.me.setInputCloud(pc.thisptr_shared)
+        # pass
+
+    def set_NormalEstimation_Method_AVERAGE_3D_GRADIENT (self):
+       mpcl_features_NormalEstimationMethod_AVERAGE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_COVARIANCE_MATRIX (self):
+       mpcl_features_NormalEstimationMethod_COVARIANCE_MATRIX(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_AVERAGE_DEPTH_CHANGE (self):
+       mpcl_features_NormalEstimationMethod_AVERAGE_DEPTH_CHANGE(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    def set_NormalEstimation_Method_SIMPLE_3D_GRADIENT (self):
+       mpcl_features_NormalEstimationMethod_SIMPLE_3D_GRADIENT(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()))
+
+    # enum Set NG
+    # def set_NormalEstimation_Method (self):
+    #    self.thisptr().setNormalEstimationMethod(pcl_ftr.NormalEstimationMethod2.ESTIMATIONMETHOD_COVARIANCE_MATRIX)
+
+    def set_MaxDepthChange_Factor(self, double param):
+        self.thisptr().setMaxDepthChangeFactor(param)
+
+    def set_NormalSmoothingSize(self, double param):
+        self.thisptr().setNormalSmoothingSize(param)
+
+    def compute(self, PointCloud pc not None):
+        # cdef PointCloud_PointNormal normal = PointCloud_PointNormal()
+        # normal = PointCloud_PointNormal()
+        normal = PointCloud_Normal()
+        # NG : No Python object
+        # normal = PointCloud_Normal(pc)
+        cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        print ('3')
+        # print (str(self.thisptr().size))
+        
+        # compute function based Features class
+        # NG 
+        # self.thisptr().compute (cPointCloudNormal.makeShared())
+        # self.thisptr().compute (cPointCloudNormal.makeShared().get())
+        # from cython cimport address
+        # self.thisptr().compute (cython.address(cPointCloudNormal.makeShared().get()))
+        # self.thisptr().compute (<cpp.PointCloud[Normal]> deref(cPointCloudNormal.makeShared().get()))
+        # NG : (Exception)
+        # self.thisptr().compute (deref(cPointCloudNormal.makeShared().get()))
+        self.thisptr().compute (deref(cPointCloudNormal))
+        print ('4')
+        return normal
+
+    def compute2(self, PointCloud pc not None):
+        normal = PointCloud_Normal()
+        cdef cpp.PointCloud_Normal_t *cPointCloudNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        print ('3')
+        # OK
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), normals)
+        print ('3a')
+        # Copy?
+        cPointCloudNormal = normals.makeShared().get()
+        print ('3b')
+        
+        # NG : Normal Pointer Nothing?
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal.makeShared().get()))
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), cPointCloudNormal.makeShared().get())
+        # NG : Normal Pointer Nothing?
+        # mpcl_features_NormalEstimationMethod_compute(<pcl_ftr.IntegralImageNormalEstimation_t> deref(self.thisptr()), deref(cPointCloudNormal))
+        print ('4')
+        return normal
+
diff --git a/pcl/pxi/Features/MomentOfInertiaEstimation_172.pxi b/pcl/pxi/Features/MomentOfInertiaEstimation_172.pxi
new file mode 100644
index 0000000..f6087b7
--- /dev/null
+++ b/pcl/pxi/Features/MomentOfInertiaEstimation_172.pxi
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_172 as pclftr
+
+
+cdef class MomentOfInertiaEstimation:
+    """
+    MomentOfInertiaEstimation class for 
+    """
+    cdef pclftr.MomentOfInertiaEstimation_t *me
+    # std::vector <float> moment_of_inertia;
+    # std::vector <float> eccentricity;
+    # pcl::PointXYZ min_point_AABB;
+    # pcl::PointXYZ max_point_AABB;
+    # pcl::PointXYZ min_point_OBB;
+    # pcl::PointXYZ max_point_OBB;
+    # pcl::PointXYZ position_OBB;
+    # Eigen::Matrix3f rotational_matrix_OBB;
+    # float major_value, middle_value, minor_value;
+    # Eigen::Vector3f major_vector, middle_vector, minor_vector;
+    # Eigen::Vector3f mass_center;
+
+    def __cinit__(self):
+        self.me = new pclftr.MomentOfInertiaEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # feature_extractor.getMomentOfInertia (moment_of_inertia);
+    # feature_extractor.getEccentricity (eccentricity);
+    # feature_extractor.getAABB (min_point_AABB, max_point_AABB);
+    # feature_extractor.getOBB (min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB);
+    # feature_extractor.getEigenValues (major_value, middle_value, minor_value);
+    # feature_extractor.getEigenVectors (major_vector, middle_vector, minor_vector);
+    # feature_extractor.getMassCenter (mass_center);
+    def get_MomentOfInertia (self):
+        cdef vector[float] moment_of_inertia
+        self.me.getMomentOfInertia(moment_of_inertia)
+        return moment_of_inertia
+
+    def get_Eccentricity (self):
+        cdef vector[float] eccentricity
+        self.me.getEccentricity(eccentricity)
+        return eccentricity
+
+    @cython.boundscheck(False)
+    def get_AABB (self):
+        cdef cpp.PointXYZ min_point_AABB
+        cdef cpp.PointXYZ max_point_AABB
+        self.me.getAABB (min_point_AABB, max_point_AABB)
+        # return min_point_AABB, max_point_AABB
+        
+        cdef cnp.npy_intp n = 1
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        
+        result1 = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            result1[i, 0] = min_point_AABB.x
+            result1[i, 1] = min_point_AABB.y
+            result1[i, 2] = min_point_AABB.z
+        
+        result2 = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            result2[i, 0] = max_point_AABB.x
+            result2[i, 1] = max_point_AABB.y
+            result2[i, 2] = max_point_AABB.z
+        
+        return result1, result2
+
+    @cython.boundscheck(False)
+    # def get_OBB (self):
+    #   cdef cpp.PointXYZ min_point_OBB
+    #   cdef cpp.PointXYZ max_point_OBB
+    #   cdef cpp.PointXYZ position_OBB
+    #   cdef eigen3.Matrix3f rotational_matrix_OBB
+    #   self.me.getOBB (min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB)
+    #   return min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB
+
+    def get_EigenValues (self):
+        cdef float major_value = 0.0
+        cdef float middle_value = 0.0
+        cdef float minor_value = 0.0
+        self.me.getEigenValues (major_value, middle_value, minor_value)
+        return major_value, middle_value, minor_value
+
+    # def get_EigenVectors (self):
+    #   # cdef eigen3.Vector3f major_vector
+    #   # cdef eigen3.Vector3f middle_vector
+    #   # cdef eigen3.Vector3f minor_vector
+    #     self.me.getEigenVectors (major_vector, middle_vector, minor_vector)
+    #     return major_vector, middle_vector, minor_vector
+
+    # def get_MassCenter (self):
+    #       # cdef eigen3.Vector3f mass_center
+    #     self.me.getMassCenter (mass_center)
+    #     return mass_center
+
diff --git a/pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi b/pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi
new file mode 100644
index 0000000..1dbd8bf
--- /dev/null
+++ b/pcl/pxi/Features/MomentOfInertiaEstimation_180.pxi
@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_180 as pclftr
+
+
+cdef class MomentOfInertiaEstimation:
+    """
+    MomentOfInertiaEstimation class for 
+    """
+    cdef pclftr.MomentOfInertiaEstimation_t *me
+    # std::vector <float> moment_of_inertia;
+    # std::vector <float> eccentricity;
+    # pcl::PointXYZ min_point_AABB;
+    # pcl::PointXYZ max_point_AABB;
+    # pcl::PointXYZ min_point_OBB;
+    # pcl::PointXYZ max_point_OBB;
+    # pcl::PointXYZ position_OBB;
+    # Eigen::Matrix3f rotational_matrix_OBB;
+    # float major_value, middle_value, minor_value;
+    # Eigen::Vector3f major_vector, middle_vector, minor_vector;
+    # Eigen::Vector3f mass_center;
+
+    def __cinit__(self):
+        self.me = new pclftr.MomentOfInertiaEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # feature_extractor.getMomentOfInertia (moment_of_inertia);
+    # feature_extractor.getEccentricity (eccentricity);
+    # feature_extractor.getAABB (min_point_AABB, max_point_AABB);
+    # feature_extractor.getOBB (min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB);
+    # feature_extractor.getEigenValues (major_value, middle_value, minor_value);
+    # feature_extractor.getEigenVectors (major_vector, middle_vector, minor_vector);
+    # feature_extractor.getMassCenter (mass_center);
+    def get_MomentOfInertia (self):
+        cdef vector[float] moment_of_inertia
+        self.me.getMomentOfInertia(moment_of_inertia)
+        return moment_of_inertia
+
+    def get_Eccentricity (self):
+        cdef vector[float] eccentricity
+        self.me.getEccentricity(eccentricity)
+        return eccentricity
+
+    @cython.boundscheck(False)
+    def get_AABB (self):
+        cdef cpp.PointXYZ min_point_AABB
+        cdef cpp.PointXYZ max_point_AABB
+        self.me.getAABB (min_point_AABB, max_point_AABB)
+        # return min_point_AABB, max_point_AABB
+        
+        cdef cnp.npy_intp n = 1
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        
+        result1 = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            result1[i, 0] = min_point_AABB.x
+            result1[i, 1] = min_point_AABB.y
+            result1[i, 2] = min_point_AABB.z
+        
+        result2 = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            result2[i, 0] = max_point_AABB.x
+            result2[i, 1] = max_point_AABB.y
+            result2[i, 2] = max_point_AABB.z
+        
+        return result1, result2
+
+    @cython.boundscheck(False)
+    # def get_OBB (self):
+    #   cdef cpp.PointXYZ min_point_OBB
+    #   cdef cpp.PointXYZ max_point_OBB
+    #   cdef cpp.PointXYZ position_OBB
+    #   cdef eigen3.Matrix3f rotational_matrix_OBB
+    #   self.me.getOBB (min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB)
+    #   return min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB
+
+    def get_EigenValues (self):
+        cdef float major_value = 0.0
+        cdef float middle_value = 0.0
+        cdef float minor_value = 0.0
+        self.me.getEigenValues (major_value, middle_value, minor_value)
+        return major_value, middle_value, minor_value
+
+    # def get_EigenVectors (self):
+    #   # cdef eigen3.Vector3f major_vector
+    #   # cdef eigen3.Vector3f middle_vector
+    #   # cdef eigen3.Vector3f minor_vector
+    #     self.me.getEigenVectors (major_vector, middle_vector, minor_vector)
+    #     return major_vector, middle_vector, minor_vector
+
+    # def get_MassCenter (self):
+    #       # cdef eigen3.Vector3f mass_center
+    #     self.me.getMassCenter (mass_center)
+    #     return mass_center
+
diff --git a/pcl/pxi/Features/NormalEstimation.pxi b/pcl/pxi/Features/NormalEstimation.pxi
new file mode 100644
index 0000000..ea3b19d
--- /dev/null
+++ b/pcl/pxi/Features/NormalEstimation.pxi
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features as pclftr
+
+
+cdef class NormalEstimation:
+    """
+    NormalEstimation class for 
+    """
+    cdef pclftr.NormalEstimation_t *me
+
+    def __cinit__(self):
+        self.me = new pclftr.NormalEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_SearchMethod(self, _pcl.KdTree kdtree):
+        self.me.setSearchMethod(kdtree.thisptr_shared)
+
+    def set_RadiusSearch(self, double param):
+        self.me.setRadiusSearch(param)
+
+    def set_KSearch (self, int param):
+        self.me.setKSearch (param)
+
+    def compute(self):
+        normal = PointCloud_Normal()
+        cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        self.me.compute (deref(cNormal))
+        return normal
+
diff --git a/pcl/pxi/Features/NormalEstimation_172.pxi b/pcl/pxi/Features/NormalEstimation_172.pxi
new file mode 100644
index 0000000..a00c044
--- /dev/null
+++ b/pcl/pxi/Features/NormalEstimation_172.pxi
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_172 as pclftr
+
+
+cdef class NormalEstimation:
+    """
+    NormalEstimation class for 
+    """
+    cdef pclftr.NormalEstimation_t *me
+
+    def __cinit__(self):
+        self.me = new pclftr.NormalEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_SearchMethod(self, _pcl.KdTree kdtree):
+        self.me.setSearchMethod(kdtree.thisptr_shared)
+
+    def set_RadiusSearch(self, double param):
+        self.me.setRadiusSearch(param)
+
+    def set_KSearch (self, int param):
+        self.me.setKSearch (param)
+
+    def compute(self):
+        normal = PointCloud_Normal()
+        cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        self.me.compute (deref(cNormal))
+        return normal
+
diff --git a/pcl/pxi/Features/NormalEstimation_180.pxi b/pcl/pxi/Features/NormalEstimation_180.pxi
new file mode 100644
index 0000000..6ef5cf1
--- /dev/null
+++ b/pcl/pxi/Features/NormalEstimation_180.pxi
@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_180 as pclftr
+
+
+cdef class NormalEstimation:
+    """
+    NormalEstimation class for 
+    """
+    cdef pclftr.NormalEstimation_t *me
+
+    def __cinit__(self):
+        self.me = new pclftr.NormalEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_SearchMethod(self, _pcl.KdTree kdtree):
+        self.me.setSearchMethod(kdtree.thisptr_shared)
+
+    def set_RadiusSearch(self, double param):
+        self.me.setRadiusSearch(param)
+
+    def set_KSearch (self, int param):
+        self.me.setKSearch (param)
+
+    def compute(self):
+        normal = PointCloud_Normal()
+        cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+        self.me.compute (deref(cNormal))
+        return normal
+
diff --git a/pcl/pxi/Features/RangeImageBorderExtractor.pxi b/pcl/pxi/Features/RangeImageBorderExtractor.pxi
new file mode 100644
index 0000000..72f7634
--- /dev/null
+++ b/pcl/pxi/Features/RangeImageBorderExtractor.pxi
@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-

+from libcpp.vector cimport vector

+from libcpp cimport bool

+

+cimport pcl_defs as cpp

+cimport pcl_features as pclftr

+

+

+cdef class RangeImageBorderExtractor:

+    """

+    RangeImageBorderExtractor class for 

+    """

+    cdef pclftr.RangeImageBorderExtractor_t *me

+    

+    def __cinit__(self):

+        self.me = new pclftr.RangeImageBorderExtractor_t()

+    

+    def __dealloc__(self):

+        del self.me

+    

+    def set_RangeImage(self, RangeImage rangeImage):

+        self.me.setRangeImage(range_image)

+    

+    def ClearData (self):

+        clearData ()

+    

+    # def GetAnglesImageForBorderDirections ()

+    #   data = self.me.getAnglesImageForBorderDirections()

+    #   return data

+    

+    # def GetAnglesImageForSurfaceChangeDirections ()

+    #   data = self.me.getAnglesImageForSurfaceChangeDirections ()

+    #   return data

+    
+    # def Compute ()

+    #   output = pcl.PointCloudOut()

+    #   self.me.compute (output)

+    #   return output

+    

+    

+    # Parameters& getParameters ()

+    # def GetParameters ()

+    #     return self.me.getParameters ()
+
    # 
+    # def HasRangeImage ()

+    #     # cdef param = self.me.hasRangeImage ()

+    #     return self.me.hasRangeImage ()

+    # 
+    # # 

+    # def GetRangeImage()

+    #     const pcl_r_img.RangeImage 

+    #     self.me.getRangeImage ()

+    # 

+    # def GetBorderScoresLeft ()

+    #     float[] data = self.me.getBorderScoresLeft ()   

+    #     return data

+    # 

+    # def GetBorderScoresRight ()
+    #     float[] data = self.me.getBorderScoresRight ()  

+    #     return data
+    # 

+    # def GetBorderScoresTop ()
+    #     float[] data = self.me.getBorderScoresTop ()  

+    #     return data
+    # 

+    # def GetBorderScoresBottom ()

+    #     float[] data = self.me.getBorderScoresBottom ()  

+    #     return data
+


+

+###

+

diff --git a/pcl/pxi/Features/RangeImageBorderExtractor_172.pxi b/pcl/pxi/Features/RangeImageBorderExtractor_172.pxi
new file mode 100644
index 0000000..ea08688
--- /dev/null
+++ b/pcl/pxi/Features/RangeImageBorderExtractor_172.pxi
@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-

+from libcpp.vector cimport vector

+from libcpp cimport bool

+

+cimport pcl_defs as cpp

+cimport pcl_features_172 as pclftr

+

+

+cdef class RangeImageBorderExtractor:

+    """

+    RangeImageBorderExtractor class for 

+    """

+    cdef pclftr.RangeImageBorderExtractor_t *me

+    

+    def __cinit__(self):

+        self.me = new pclftr.RangeImageBorderExtractor_t()

+    

+    def __dealloc__(self):

+        del self.me

+    

+    def set_RangeImage(self, RangeImage rangeImage):

+        self.me.setRangeImage(range_image)

+    

+    def ClearData (self):

+        clearData ()

+    

+    # def GetAnglesImageForBorderDirections ()

+    #   data = self.me.getAnglesImageForBorderDirections()

+    #   return data

+    

+    # def GetAnglesImageForSurfaceChangeDirections ()

+    #   data = self.me.getAnglesImageForSurfaceChangeDirections ()

+    #   return data

+    
+    # def Compute ()

+    #   output = pcl.PointCloudOut()

+    #   self.me.compute (output)

+    #   return output

+    

+    

+    # Parameters& getParameters ()

+    # def GetParameters ()

+    #     return self.me.getParameters ()
+
    # 
+    # def HasRangeImage ()

+    #     # cdef param = self.me.hasRangeImage ()

+    #     return self.me.hasRangeImage ()

+    # 
+    # # 

+    # def GetRangeImage()

+    #     const pcl_r_img.RangeImage 

+    #     self.me.getRangeImage ()

+    # 

+    # def GetBorderScoresLeft ()

+    #     float[] data = self.me.getBorderScoresLeft ()   

+    #     return data

+    # 

+    # def GetBorderScoresRight ()
+    #     float[] data = self.me.getBorderScoresRight ()  

+    #     return data
+    # 

+    # def GetBorderScoresTop ()
+    #     float[] data = self.me.getBorderScoresTop ()  

+    #     return data
+    # 

+    # def GetBorderScoresBottom ()

+    #     float[] data = self.me.getBorderScoresBottom ()  

+    #     return data
+


+

+###

+

diff --git a/pcl/pxi/Features/RangeImageBorderExtractor_180.pxi b/pcl/pxi/Features/RangeImageBorderExtractor_180.pxi
new file mode 100644
index 0000000..0df99b5
--- /dev/null
+++ b/pcl/pxi/Features/RangeImageBorderExtractor_180.pxi
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_180 as pclftr
+
+
+cdef class RangeImageBorderExtractor:
+    """
+    RangeImageBorderExtractor class for 
+    """
+    cdef pclftr.RangeImageBorderExtractor_t *me
+    
+    def __cinit__(self):
+        self.me = new pclftr.RangeImageBorderExtractor_t()
+    
+    def __dealloc__(self):
+        del self.me
+    
+    def set_RangeImage(self, RangeImage rangeImage):
+        self.me.setRangeImage(range_image)
+    
+    def ClearData (self):
+        clearData ()
+    
+    # def GetAnglesImageForBorderDirections ()
+    #   data = self.me.getAnglesImageForBorderDirections()
+    #   return data
+    
+    # def GetAnglesImageForSurfaceChangeDirections ()
+    #   data = self.me.getAnglesImageForSurfaceChangeDirections ()
+    #   return data
+    
+    # def Compute ()
+    #   output = pcl.PointCloudOut()
+    #   self.me.compute (output)
+    #   return output
+    
+    
+    # Parameters& getParameters ()
+    # def GetParameters ()
+    #     return self.me.getParameters ()
+
+    # 
+    # def HasRangeImage ()
+    #     # cdef param = self.me.hasRangeImage ()
+    #     return self.me.hasRangeImage ()
+    # 
+    # # 
+    # def GetRangeImage()
+    #     const pcl_r_img.RangeImage 
+    #     self.me.getRangeImage ()
+    # 
+    # def GetBorderScoresLeft ()
+    #     float[] data = self.me.getBorderScoresLeft ()   
+    #     return data
+    # 
+    # def GetBorderScoresRight ()
+    #     float[] data = self.me.getBorderScoresRight ()  
+    #     return data
+    # 
+    # def GetBorderScoresTop ()
+    #     float[] data = self.me.getBorderScoresTop ()  
+    #     return data
+    # 
+    # def GetBorderScoresBottom ()
+    #     float[] data = self.me.getBorderScoresBottom ()  
+    #     return data
+
+
+
+###
+
diff --git a/pcl/pxi/Features/VFHEstimation.pxi b/pcl/pxi/Features/VFHEstimation.pxi
new file mode 100644
index 0000000..e5fc737
--- /dev/null
+++ b/pcl/pxi/Features/VFHEstimation.pxi
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features as pclftr
+
+
+cdef class VFHEstimation:
+    """
+    VFHEstimation class for 
+    """
+    cdef pclftr.VFHEstimation_t *me
+
+    def __cinit__(self):
+        self.me = new pclftr.VFHEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_SearchMethod(self, _pcl.KdTree kdtree):
+        self.me.setSearchMethod(kdtree.thisptr_shared)
+
+    def set_KSearch (self, int param):
+        self.me.setKSearch (param)
+
+    # use PointCloud[VFHSignature308]
+    # def compute(self):
+    #     normal = PointCloud_Normal()
+    #     cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+    #     self.me.compute (deref(cNormal))
+    #     return normal
+
diff --git a/pcl/pxi/Features/VFHEstimation_172.pxi b/pcl/pxi/Features/VFHEstimation_172.pxi
new file mode 100644
index 0000000..aa4b7c5
--- /dev/null
+++ b/pcl/pxi/Features/VFHEstimation_172.pxi
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_172 as pclftr
+
+
+cdef class VFHEstimation:
+    """
+    VFHEstimation class for 
+    """
+    cdef pclftr.VFHEstimation_t *me
+
+    def __cinit__(self):
+        self.me = new pclftr.VFHEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_SearchMethod(self, _pcl.KdTree kdtree):
+        self.me.setSearchMethod(kdtree.thisptr_shared)
+
+    def set_KSearch (self, int param):
+        self.me.setKSearch (param)
+
+    # use PointCloud[VFHSignature308]
+    # def compute(self):
+    #     normal = PointCloud_Normal()
+    #     cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+    #     self.me.compute (deref(cNormal))
+    #     return normal
+
diff --git a/pcl/pxi/Features/VFHEstimation_180.pxi b/pcl/pxi/Features/VFHEstimation_180.pxi
new file mode 100644
index 0000000..5bbaa91
--- /dev/null
+++ b/pcl/pxi/Features/VFHEstimation_180.pxi
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_features_180 as pclftr
+
+
+cdef class VFHEstimation:
+    """
+    VFHEstimation class for 
+    """
+    cdef pclftr.VFHEstimation_t *me
+
+    def __cinit__(self):
+        self.me = new pclftr.VFHEstimation_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_SearchMethod(self, _pcl.KdTree kdtree):
+        self.me.setSearchMethod(kdtree.thisptr_shared)
+
+    def set_KSearch (self, int param):
+        self.me.setKSearch (param)
+
+    # use PointCloud[VFHSignature308]
+    # def compute(self):
+    #     normal = PointCloud_Normal()
+    #     cdef cpp.PointCloud_Normal_t *cNormal = <cpp.PointCloud_Normal_t*>normal.thisptr()
+    #     self.me.compute (deref(cNormal))
+    #     return normal
+
diff --git a/pcl/pxi/Filters/AddList.txt b/pcl/pxi/Filters/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/Filters/AddList.txt
diff --git a/pcl/pxi/Filters/ApproximateVoxelGrid.pxi b/pcl/pxi/Filters/ApproximateVoxelGrid.pxi
new file mode 100644
index 0000000..29df41f
--- /dev/null
+++ b/pcl/pxi/Filters/ApproximateVoxelGrid.pxi
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+cdef class ApproximateVoxelGrid:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_t *me
+
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZI:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZI_t *me
+
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZRGB:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZRGBA:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/ApproximateVoxelGrid_172.pxi b/pcl/pxi/Filters/ApproximateVoxelGrid_172.pxi
new file mode 100644
index 0000000..8fbf328
--- /dev/null
+++ b/pcl/pxi/Filters/ApproximateVoxelGrid_172.pxi
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_172 as pclfil
+
+cdef class ApproximateVoxelGrid:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_t *me
+
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZI:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZI_t *me
+
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZRGB:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZRGBA:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/ApproximateVoxelGrid_180.pxi b/pcl/pxi/Filters/ApproximateVoxelGrid_180.pxi
new file mode 100644
index 0000000..3489f0d
--- /dev/null
+++ b/pcl/pxi/Filters/ApproximateVoxelGrid_180.pxi
@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_180 as pclfil
+
+cdef class ApproximateVoxelGrid:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_t *me
+
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZI:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZI_t *me
+
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZRGB:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class ApproximateVoxelGrid_PointXYZRGBA:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.ApproximateVoxelGrid_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.ApproximateVoxelGrid_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/ConditionAnd.pxi b/pcl/pxi/Filters/ConditionAnd.pxi
new file mode 100644
index 0000000..e82894a
--- /dev/null
+++ b/pcl/pxi/Filters/ConditionAnd.pxi
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+# from libcpp.string cimport string
+
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+from pcl_filters cimport CompareOp2
+from boost_shared_ptr cimport shared_ptr
+from boost_shared_ptr cimport sp_assign
+
+# cdef class ConditionAnd(ConditionBase):
+cdef class ConditionAnd:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in ConditionAnd(pc).
+    """
+    cdef pclfil.ConditionAnd_t *me
+
+    def __cinit__(self):
+        self.me = new pclfil.ConditionAnd_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # def add_Comparison(self, comparison):
+    #     self.me.addComparison(comparison.this_ptr())
+
+    def add_Comparison2(self, field_name, CompareOp2 compOp, double thresh):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r" % field_name)
+        else:
+            fname_ascii = field_name
+        
+        cdef pclfil.FieldComparisonConstPtr_t fieldComp = <pclfil.FieldComparisonConstPtr_t> new pclfil.FieldComparison_t(string(fname_ascii), compOp, thresh)
+        
+        # Cython 0.25.2 NG
+        # self.me.addComparison(<shared_ptr[const pclfil.ComparisonBase[cpp.PointXYZ]]> fieldComp)
+        self.me.addComparison(<shared_ptr[const pclfil.ComparisonBase[cpp.PointXYZ]]> fieldComp)
+        
+        # NG
+        # sp_assign( self.fieldCompPtr, new pclfil.FieldComparison_t(string(fname_ascii), compOp, thresh) )
+        # self.me.addComparison(<shared_ptr[const pclfil.ComparisonBase[cpp.PointXYZ]]> self.fieldCompPtr)
+
diff --git a/pcl/pxi/Filters/ConditionalRemoval.pxi b/pcl/pxi/Filters/ConditionalRemoval.pxi
new file mode 100644
index 0000000..0476c27
--- /dev/null
+++ b/pcl/pxi/Filters/ConditionalRemoval.pxi
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+cimport eigen as eigen3
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef class ConditionalRemoval:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in ConditionalRemoval(pc).
+    """
+    cdef pclfil.ConditionalRemoval_t *me
+
+    def __cinit__(self, ConditionAnd cond):
+        # self.me = new pclfil.ConditionalRemoval_t(<pclfil.ConditionBase_t*>cond.me)
+        # direct - NG
+        self.me = new pclfil.ConditionalRemoval_t(<pclfil.ConditionBasePtr_t>cond.me)
+
+    # def __dealloc__(self):
+    #    # MemoryAccessError
+    #    # del self.me
+    #    self.me
+
+    def set_KeepOrganized(self, flag):
+        self.me.setKeepOrganized(flag)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/CropBox.pxi b/pcl/pxi/Filters/CropBox.pxi
new file mode 100644
index 0000000..2bd3b92
--- /dev/null
+++ b/pcl/pxi/Filters/CropBox.pxi
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+cimport eigen as eigen3
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef class CropBox:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in CropBox(pc).
+    """
+    cdef pclfil.CropBox_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.CropBox_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_Translation(self, tx, ty, tz):
+        # Convert Eigen::Vector3f
+        cdef eigen3.Vector3f origin
+        cdef float *data = origin.data()
+        data[0] = tx
+        data[1] = ty
+        data[2] = tz
+        self.me.setTranslation(origin)
+
+    # def set_Rotation(self, cnp.ndarray[ndim=3, dtype=int, mode='c'] ind):
+    def set_Rotation(self, rx, ry, rz):
+        # Convert Eigen::Vector3f
+        cdef eigen3.Vector3f origin
+        cdef float *data = origin.data()
+        data[0] = rx
+        data[1] = ry
+        data[2] = rz
+        self.me.setRotation(origin)
+
+    def set_Min(self, minx, miny, minz, mins):
+        # Convert Eigen::Vector4f
+        cdef eigen3.Vector4f originMin
+        cdef float *dataMin = originMin.data()
+        dataMin[0] = minx
+        dataMin[1] = miny
+        dataMin[2] = minz
+        dataMin[3] = mins
+        self.me.setMin(originMin)
+
+    def set_Max(self, maxx, maxy, maxz, maxs):
+        cdef eigen3.Vector4f originMax;
+        cdef float *dataMax = originMax.data()
+        dataMax[0] = maxx
+        dataMax[1] = maxy
+        dataMax[2] = maxz
+        dataMax[3] = maxs
+        self.me.setMax(originMax)
+
+    def set_MinMax(self, minx, miny, minz, mins, maxx, maxy, maxz, maxs):
+        # Convert Eigen::Vector4f
+        cdef eigen3.Vector4f originMin
+        cdef float *dataMin = originMin.data()
+        dataMin[0] = minx
+        dataMin[1] = miny
+        dataMin[2] = minz
+        dataMin[3] = mins
+        self.me.setMin(originMin)
+        
+        cdef eigen3.Vector4f originMax;
+        cdef float *dataMax = originMax.data()
+        dataMax[0] = maxx
+        dataMax[1] = maxy
+        dataMax[2] = maxz
+        dataMax[3] = maxs
+        self.me.setMax(originMax)
+
+    def set_Negative(self, bool flag):
+        self.me.setNegative(flag)
+
+    # bool
+    def get_Negative (self):
+        self.me.getNegative ()
+
+    def get_RemovedIndices(self):
+        self.me.getRemovedIndices()
+
+    def filter(self):
+        cdef PointCloud pc = PointCloud()
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(deref(pc.thisptr()))
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> pc.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 OK)
+        # self.me.filter(<vector[int]&> pc)
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
diff --git a/pcl/pxi/Filters/CropBox_172.pxi b/pcl/pxi/Filters/CropBox_172.pxi
new file mode 100644
index 0000000..d5c568c
--- /dev/null
+++ b/pcl/pxi/Filters/CropBox_172.pxi
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters_172 as pclfil
+
+cimport eigen as eigen3
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef class CropBox:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in CropBox(pc).
+    """
+    cdef pclfil.CropBox_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.CropBox_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_Translation(self, tx, ty, tz):
+        # Convert Eigen::Vector3f
+        cdef eigen3.Vector3f origin
+        cdef float *data = origin.data()
+        data[0] = tx
+        data[1] = ty
+        data[2] = tz
+        self.me.setTranslation(origin)
+
+    # def set_Rotation(self, cnp.ndarray[ndim=3, dtype=int, mode='c'] ind):
+    def set_Rotation(self, rx, ry, rz):
+        # Convert Eigen::Vector3f
+        cdef eigen3.Vector3f origin
+        cdef float *data = origin.data()
+        data[0] = rx
+        data[1] = ry
+        data[2] = rz
+        self.me.setRotation(origin)
+
+    def set_Min(self, minx, miny, minz, mins):
+        # Convert Eigen::Vector4f
+        cdef eigen3.Vector4f originMin
+        cdef float *dataMin = originMin.data()
+        dataMin[0] = minx
+        dataMin[1] = miny
+        dataMin[2] = minz
+        dataMin[3] = mins
+        self.me.setMin(originMin)
+
+    def set_Max(self, maxx, maxy, maxz, maxs):
+        cdef eigen3.Vector4f originMax;
+        cdef float *dataMax = originMax.data()
+        dataMax[0] = maxx
+        dataMax[1] = maxy
+        dataMax[2] = maxz
+        dataMax[3] = maxs
+        self.me.setMax(originMax)
+
+    def set_MinMax(self, minx, miny, minz, mins, maxx, maxy, maxz, maxs):
+        # Convert Eigen::Vector4f
+        cdef eigen3.Vector4f originMin
+        cdef float *dataMin = originMin.data()
+        dataMin[0] = minx
+        dataMin[1] = miny
+        dataMin[2] = minz
+        dataMin[3] = mins
+        self.me.setMin(originMin)
+        
+        cdef eigen3.Vector4f originMax;
+        cdef float *dataMax = originMax.data()
+        dataMax[0] = maxx
+        dataMax[1] = maxy
+        dataMax[2] = maxz
+        dataMax[3] = maxs
+        self.me.setMax(originMax)
+
+    def set_Negative(self, bool flag):
+        self.me.setNegative(flag)
+
+    # bool
+    def get_Negative (self):
+        self.me.getNegative ()
+
+    def get_RemovedIndices(self):
+        self.me.getRemovedIndices()
+
+    def filter(self):
+        cdef PointCloud pc = PointCloud()
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(deref(pc.thisptr()))
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> pc.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 OK)
+        # self.me.filter(<vector[int]&> pc)
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
diff --git a/pcl/pxi/Filters/CropBox_180.pxi b/pcl/pxi/Filters/CropBox_180.pxi
new file mode 100644
index 0000000..3ec7914
--- /dev/null
+++ b/pcl/pxi/Filters/CropBox_180.pxi
@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters_180 as pclfil
+
+cimport eigen as eigen3
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef class CropBox:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in CropBox(pc).
+    """
+    cdef pclfil.CropBox_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.CropBox_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_Translation(self, tx, ty, tz):
+        # Convert Eigen::Vector3f
+        cdef eigen3.Vector3f origin
+        cdef float *data = origin.data()
+        data[0] = tx
+        data[1] = ty
+        data[2] = tz
+        self.me.setTranslation(origin)
+
+    # def set_Rotation(self, cnp.ndarray[ndim=3, dtype=int, mode='c'] ind):
+    def set_Rotation(self, rx, ry, rz):
+        # Convert Eigen::Vector3f
+        cdef eigen3.Vector3f origin
+        cdef float *data = origin.data()
+        data[0] = rx
+        data[1] = ry
+        data[2] = rz
+        self.me.setRotation(origin)
+
+    def set_Min(self, minx, miny, minz, mins):
+        # Convert Eigen::Vector4f
+        cdef eigen3.Vector4f originMin
+        cdef float *dataMin = originMin.data()
+        dataMin[0] = minx
+        dataMin[1] = miny
+        dataMin[2] = minz
+        dataMin[3] = mins
+        self.me.setMin(originMin)
+
+    def set_Max(self, maxx, maxy, maxz, maxs):
+        cdef eigen3.Vector4f originMax;
+        cdef float *dataMax = originMax.data()
+        dataMax[0] = maxx
+        dataMax[1] = maxy
+        dataMax[2] = maxz
+        dataMax[3] = maxs
+        self.me.setMax(originMax)
+
+    def set_MinMax(self, minx, miny, minz, mins, maxx, maxy, maxz, maxs):
+        # Convert Eigen::Vector4f
+        cdef eigen3.Vector4f originMin
+        cdef float *dataMin = originMin.data()
+        dataMin[0] = minx
+        dataMin[1] = miny
+        dataMin[2] = minz
+        dataMin[3] = mins
+        self.me.setMin(originMin)
+        
+        cdef eigen3.Vector4f originMax;
+        cdef float *dataMax = originMax.data()
+        dataMax[0] = maxx
+        dataMax[1] = maxy
+        dataMax[2] = maxz
+        dataMax[3] = maxs
+        self.me.setMax(originMax)
+
+    def set_Negative(self, bool flag):
+        self.me.setNegative(flag)
+
+    # bool
+    def get_Negative (self):
+        self.me.getNegative ()
+
+    def get_RemovedIndices(self):
+        self.me.getRemovedIndices()
+
+    def filter(self):
+        cdef PointCloud pc = PointCloud()
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(deref(pc.thisptr()))
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> pc.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 OK)
+        # self.me.filter(<vector[int]&> pc)
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
diff --git a/pcl/pxi/Filters/CropHull.pxi b/pcl/pxi/Filters/CropHull.pxi
new file mode 100644
index 0000000..65db3f8
--- /dev/null
+++ b/pcl/pxi/Filters/CropHull.pxi
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef class CropHull:
+    """
+    Must be constructed from the reference point cloud, which is copied, 
+    so changed to pc are not reflected in CropHull(pc).
+    """
+    cdef pclfil.CropHull_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.CropHull_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    # def SetParameter(self, shared_ptr[cpp.PointCloud[cpp.PointXYZ]] points, cpp.Vertices vt):
+    def SetParameter(self, PointCloud points, Vertices vt):
+        cdef const vector[cpp.Vertices] tmp_vertices
+        # NG
+        # tmp_vertices.push_back(deref(vt))
+        # tmp_vertices.push_back<cpp.Vertices>(vt)
+        # tmp_vertices.push_back[cpp.Vertices](vt)
+        # tmp_vertices.push_back(vt)
+        # tmp_vertices.push_back(deref(vt.thisptr()))
+        self.me.setHullIndices(tmp_vertices)
+        # self.me.setHullCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> points)
+        # convert <PointCloud> to <shared_ptr[cpp.PointCloud[cpp.PointXYZ]]>
+        self.me.setHullCloud(points.thisptr_shared)
+        self.me.setDim(<int> 2)
+        self.me.setCropOutside(<bool> False)
+
+    def Filtering(self, PointCloud outputCloud):
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(deref(outputCloud.thisptr()))
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> outputCloud.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 OK)
+        # self.me.filter(<vector[int]> outputCloud)
+        # self.me.filter(<vector[int]&> outputCloud)
+        self.me.c_filter(outputCloud.thisptr()[0])
+        print("filter: outputCloud size = " + str(outputCloud.size))
+        return outputCloud
+
+    def filter(self):
+        cdef PointCloud pc = PointCloud()
+        self.me.c_filter(pc.thisptr()[0])
+        print("filter: pc size = " + str(pc.size))
+        return pc
+
+
diff --git a/pcl/pxi/Filters/CropHull_172.pxi b/pcl/pxi/Filters/CropHull_172.pxi
new file mode 100644
index 0000000..cd5b3a4
--- /dev/null
+++ b/pcl/pxi/Filters/CropHull_172.pxi
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters_172 as pclfil
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef class CropHull:
+    """
+    Must be constructed from the reference point cloud, which is copied, 
+    so changed to pc are not reflected in CropHull(pc).
+    """
+    cdef pclfil.CropHull_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.CropHull_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    # def SetParameter(self, shared_ptr[cpp.PointCloud[cpp.PointXYZ]] points, cpp.Vertices vt):
+    def SetParameter(self, PointCloud points, Vertices vt):
+        cdef const vector[cpp.Vertices] tmp_vertices
+        # NG
+        # tmp_vertices.push_back(deref(vt))
+        # tmp_vertices.push_back<cpp.Vertices>(vt)
+        # tmp_vertices.push_back[cpp.Vertices](vt)
+        # tmp_vertices.push_back(vt)
+        # tmp_vertices.push_back(deref(vt.thisptr()))
+        self.me.setHullIndices(tmp_vertices)
+        # self.me.setHullCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> points)
+        # convert <PointCloud> to <shared_ptr[cpp.PointCloud[cpp.PointXYZ]]>
+        self.me.setHullCloud(points.thisptr_shared)
+        self.me.setDim(<int> 2)
+        self.me.setCropOutside(<bool> False)
+
+    def Filtering(self, PointCloud outputCloud):
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(deref(outputCloud.thisptr()))
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> outputCloud.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 OK)
+        # self.me.filter(<vector[int]> outputCloud)
+        # self.me.filter(<vector[int]&> outputCloud)
+        self.me.c_filter(outputCloud.thisptr()[0])
+        print("filter: outputCloud size = " + str(outputCloud.size))
+        return outputCloud
+
+    def filter(self):
+        cdef PointCloud pc = PointCloud()
+        self.me.c_filter(pc.thisptr()[0])
+        print("filter: pc size = " + str(pc.size))
+        return pc
+
+
diff --git a/pcl/pxi/Filters/CropHull_180.pxi b/pcl/pxi/Filters/CropHull_180.pxi
new file mode 100644
index 0000000..daed068
--- /dev/null
+++ b/pcl/pxi/Filters/CropHull_180.pxi
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters_180 as pclfil
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef class CropHull:
+    """
+    Must be constructed from the reference point cloud, which is copied, 
+    so changed to pc are not reflected in CropHull(pc).
+    """
+    cdef pclfil.CropHull_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.CropHull_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    # def SetParameter(self, shared_ptr[cpp.PointCloud[cpp.PointXYZ]] points, cpp.Vertices vt):
+    def SetParameter(self, PointCloud points, Vertices vt):
+        cdef const vector[cpp.Vertices] tmp_vertices
+        # NG
+        # tmp_vertices.push_back(deref(vt))
+        # tmp_vertices.push_back<cpp.Vertices>(vt)
+        # tmp_vertices.push_back[cpp.Vertices](vt)
+        # tmp_vertices.push_back(vt)
+        # tmp_vertices.push_back(deref(vt.thisptr()))
+        self.me.setHullIndices(tmp_vertices)
+        # self.me.setHullCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> points)
+        # convert <PointCloud> to <shared_ptr[cpp.PointCloud[cpp.PointXYZ]]>
+        self.me.setHullCloud(points.thisptr_shared)
+        self.me.setDim(<int> 2)
+        self.me.setCropOutside(<bool> False)
+
+    def Filtering(self, PointCloud outputCloud):
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(deref(outputCloud.thisptr()))
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> outputCloud.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 OK)
+        # self.me.filter(<vector[int]> outputCloud)
+        # self.me.filter(<vector[int]&> outputCloud)
+        self.me.c_filter(outputCloud.thisptr()[0])
+        print("filter: outputCloud size = " + str(outputCloud.size))
+        return outputCloud
+
+    def filter(self):
+        cdef PointCloud pc = PointCloud()
+        self.me.c_filter(pc.thisptr()[0])
+        print("filter: pc size = " + str(pc.size))
+        return pc
+
+
diff --git a/pcl/pxi/Filters/FieldComparison.pxi b/pcl/pxi/Filters/FieldComparison.pxi
new file mode 100644
index 0000000..371944f
--- /dev/null
+++ b/pcl/pxi/Filters/FieldComparison.pxi
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+from libcpp.string cimport string
+
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+from pcl_filters cimport CompareOp2
+from boost_shared_ptr cimport shared_ptr
+
+cdef class FieldComparison:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in ConditionAnd(pc).
+    """
+    cdef pclfil.FieldComparison_t *me
+
+    def __cinit__(self, field_name, CompareOp2 op, double thresh):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+
+        self.me = new pclfil.FieldComparison_t(field_name, op, thresh)
+
+    def __dealloc__(self):
+        del self.me
+
+
+
diff --git a/pcl/pxi/Filters/PassThroughFilter.pxi b/pcl/pxi/Filters/PassThroughFilter.pxi
new file mode 100644
index 0000000..fe9972a
--- /dev/null
+++ b/pcl/pxi/Filters/PassThroughFilter.pxi
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+cdef class PassThroughFilter:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        # cdef cpp.PointCloud_t *cCondAnd = <cpp.PointCloud_t *>pc.thisptr()[0]
+        # self.me.filter(<cpp.PointCloud_t*> pc.thisptr()[0])
+        # self.me.filter (<cpp.PointCloud_t*> pc.thisptr())
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZI:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZI
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZRGB:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZRGB
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZRGBA:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZRGBA
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/PassThroughFilter_172.pxi b/pcl/pxi/Filters/PassThroughFilter_172.pxi
new file mode 100644
index 0000000..fa6f6f8
--- /dev/null
+++ b/pcl/pxi/Filters/PassThroughFilter_172.pxi
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_172 as pclfil
+
+cdef class PassThroughFilter:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        # cdef cpp.PointCloud_t *cCondAnd = <cpp.PointCloud_t *>pc.thisptr()[0]
+        # self.me.filter(<cpp.PointCloud_t*> pc.thisptr()[0])
+        # self.me.filter (<cpp.PointCloud_t*> pc.thisptr())
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZI:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZI
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZRGB:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZRGB
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZRGBA:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZRGBA
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/PassThroughFilter_180.pxi b/pcl/pxi/Filters/PassThroughFilter_180.pxi
new file mode 100644
index 0000000..e530145
--- /dev/null
+++ b/pcl/pxi/Filters/PassThroughFilter_180.pxi
@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_180 as pclfil
+
+cdef class PassThroughFilter:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        # cdef cpp.PointCloud_t *cCondAnd = <cpp.PointCloud_t *>pc.thisptr()[0]
+        # self.me.filter(<cpp.PointCloud_t*> pc.thisptr()[0])
+        # self.me.filter (<cpp.PointCloud_t*> pc.thisptr())
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZI:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZI
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZRGB:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZRGB
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class PassThroughFilter_PointXYZRGBA:
+    """
+    Passes points in a cloud based on constraints for one particular field of the point type
+    """
+    cdef pclfil.PassThrough_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.PassThrough_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_filter_field_name(self, field_name):
+        cdef bytes fname_ascii
+        if isinstance(field_name, unicode):
+            fname_ascii = field_name.encode("ascii")
+        elif not isinstance(field_name, bytes):
+            raise TypeError("field_name should be a string, got %r"
+                            % field_name)
+        else:
+            fname_ascii = field_name
+        self.me.setFilterFieldName(string(fname_ascii))
+
+    def set_filter_limits(self, float filter_min, float filter_max):
+        self.me.setFilterLimits (filter_min, filter_max)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new PointCloud_PointXYZRGBA
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.c_filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/ProjectInliers.pxi b/pcl/pxi/Filters/ProjectInliers.pxi
new file mode 100644
index 0000000..d7543d9
--- /dev/null
+++ b/pcl/pxi/Filters/ProjectInliers.pxi
@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+cimport pcl_filters as pclfil
+cimport pcl_segmentation as pclseg
+cimport pcl_defs as cpp
+
+cdef class ProjectInliers:
+    """
+    ProjectInliers class for ...
+    """
+    cdef pclfil.ProjectInliers_t *me
+    def __cinit__(self):
+        self.me = new pclfil.ProjectInliers_t()
+    def __dealloc__(self):
+        del self.me
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+    # def set_Model_Coefficients(self):
+    #     cdef cpp.ModelCoefficients *coeffs
+    #     coeffs.values.resize(4)
+    #     coeffs.values[0] = 0
+    #     coeffs.values[1] = 0
+    #     coeffs.values[2] = 1.0
+    #     coeffs.values[3] = 0
+    #     self.me.setModelCoefficients(coeffs)
+    #     
+    # def get_Model_Coefficients(self):
+    #     self.me.getModelCoefficients()
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def get_model_type(self):
+        return self.me.getModelType()
+    def set_copy_all_data(self, bool m):
+        self.me.setCopyAllData (m)
+    def get_copy_all_data(self):
+        return self.me.getCopyAllData ()
+
diff --git a/pcl/pxi/Filters/RadiusOutlierRemoval.pxi b/pcl/pxi/Filters/RadiusOutlierRemoval.pxi
new file mode 100644
index 0000000..658a31a
--- /dev/null
+++ b/pcl/pxi/Filters/RadiusOutlierRemoval.pxi
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_filters as pclfil
+cimport pcl_segmentation as pclseg
+cimport pcl_defs as cpp
+
+cdef class RadiusOutlierRemoval:
+    """
+    RadiusOutlierRemoval class for ...
+    """
+    cdef pclfil.RadiusOutlierRemoval_t *me
+    def __cinit__(self):
+        self.me = new pclfil.RadiusOutlierRemoval_t()
+    def __dealloc__(self):
+        del self.me
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(pc.thisptr()[0])
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> pc.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 NG)
+        # self.me.filter(<vector[int]> pc)
+        # pcl 1.7.2
+        self.me.filter(<vector[int]&> pc)
+        return pc
+
+    def set_radius_search(self, double radius):
+        self.me.setRadiusSearch(radius)
+    def get_radius_search(self):
+        return self.me.getRadiusSearch()
+    def set_MinNeighborsInRadius(self, int min_pts):
+        self.me.setMinNeighborsInRadius (min_pts)
+    def get_MinNeighborsInRadius(self):
+        return self.me.getMinNeighborsInRadius ()
+
diff --git a/pcl/pxi/Filters/RadiusOutlierRemoval_172.pxi b/pcl/pxi/Filters/RadiusOutlierRemoval_172.pxi
new file mode 100644
index 0000000..de16f7c
--- /dev/null
+++ b/pcl/pxi/Filters/RadiusOutlierRemoval_172.pxi
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters_172 as pclfil
+cimport pcl_segmentation_172 as pclseg
+
+cdef class RadiusOutlierRemoval:
+    """
+    RadiusOutlierRemoval class for ...
+    """
+    cdef pclfil.RadiusOutlierRemoval_t *me
+    def __cinit__(self):
+        self.me = new pclfil.RadiusOutlierRemoval_t()
+    def __dealloc__(self):
+        del self.me
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(pc.thisptr()[0])
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> pc.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 NG)
+        # self.me.filter(<vector[int]> pc)
+        # pcl 1.7.2
+        self.me.filter(<vector[int]&> pc)
+        return pc
+
+    def set_radius_search(self, double radius):
+        self.me.setRadiusSearch(radius)
+    def get_radius_search(self):
+        return self.me.getRadiusSearch()
+    def set_MinNeighborsInRadius(self, int min_pts):
+        self.me.setMinNeighborsInRadius (min_pts)
+    def get_MinNeighborsInRadius(self):
+        return self.me.getMinNeighborsInRadius ()
+
diff --git a/pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi b/pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi
new file mode 100644
index 0000000..7f72afc
--- /dev/null
+++ b/pcl/pxi/Filters/RadiusOutlierRemoval_180.pxi
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_filters_180 as pclfil
+cimport pcl_segmentation_180 as pclseg
+
+cdef class RadiusOutlierRemoval:
+    """
+    RadiusOutlierRemoval class for ...
+    """
+    cdef pclfil.RadiusOutlierRemoval_t *me
+    def __cinit__(self):
+        self.me = new pclfil.RadiusOutlierRemoval_t()
+    def __dealloc__(self):
+        del self.me
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        # Cython 0.25.2 NG(0.24.1 OK)
+        # self.me.filter(pc.thisptr()[0])
+        # self.me.filter(<cpp.PointCloud[cpp.PointXYZ]> pc.thisptr()[0])
+        # Cython 0.24.1 NG(0.25.2 NG)
+        # self.me.filter(<vector[int]> pc)
+        # pcl 1.7.2
+        self.me.filter(<vector[int]&> pc)
+        return pc
+
+    def set_radius_search(self, double radius):
+        self.me.setRadiusSearch(radius)
+    def get_radius_search(self):
+        return self.me.getRadiusSearch()
+    def set_MinNeighborsInRadius(self, int min_pts):
+        self.me.setMinNeighborsInRadius (min_pts)
+    def get_MinNeighborsInRadius(self):
+        return self.me.getMinNeighborsInRadius ()
+
diff --git a/pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi b/pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi
new file mode 100644
index 0000000..2e27595
--- /dev/null
+++ b/pcl/pxi/Filters/StatisticalOutlierRemovalFilter.pxi
@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+cdef class StatisticalOutlierRemovalFilter:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZI:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *me
+
+    def __cinit__(self, PointCloud_PointXYZI pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZI_t()
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZRGB:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGB_t()
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZRGBA:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t()
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        self.me.setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
diff --git a/pcl/pxi/Filters/StatisticalOutlierRemovalFilter_172.pxi b/pcl/pxi/Filters/StatisticalOutlierRemovalFilter_172.pxi
new file mode 100644
index 0000000..9767a0a
--- /dev/null
+++ b/pcl/pxi/Filters/StatisticalOutlierRemovalFilter_172.pxi
@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_172 as pclfil
+
+cdef class StatisticalOutlierRemovalFilter:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZI:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *me
+
+    def __cinit__(self, PointCloud_PointXYZI pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZI_t()
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZRGB:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGB_t()
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZRGBA:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t()
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        self.me.setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
diff --git a/pcl/pxi/Filters/StatisticalOutlierRemovalFilter_180.pxi b/pcl/pxi/Filters/StatisticalOutlierRemovalFilter_180.pxi
new file mode 100644
index 0000000..7b90420
--- /dev/null
+++ b/pcl/pxi/Filters/StatisticalOutlierRemovalFilter_180.pxi
@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_180 as pclfil
+
+cdef class StatisticalOutlierRemovalFilter:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_t()
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud pc not None):
+        (<cpp.PCLBase_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZI:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *me
+
+    def __cinit__(self, PointCloud_PointXYZI pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZI_t()
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZI]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZI pc not None):
+        (<cpp.PCLBase_PointXYZI_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZ]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZRGB:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGB_t()
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZRGB pc not None):
+        (<cpp.PCLBase_PointXYZRGB_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        (<pclfil.FilterIndices[cpp.PointXYZRGB]*>self.me).setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class StatisticalOutlierRemovalFilter_PointXYZRGBA:
+    """
+    Filter class uses point neighborhood statistics to filter outlier data.
+    """
+    cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+        self.me = new pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t()
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    property mean_k:
+        def __get__(self):
+            return self.me.getMeanK()
+        def __set__(self, int k):
+            self.me.setMeanK(k)
+
+    property negative:
+        def __get__(self):
+            return (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).getNegative()
+        def __set__(self, bool neg):
+            (<pclfil.FilterIndices[cpp.PointXYZRGBA]*>self.me).setNegative(neg)
+
+    property stddev_mul_thresh:
+        def __get__(self):
+            return self.me.getStddevMulThresh()
+        def __set__(self, double thresh):
+            self.me.setStddevMulThresh(thresh)
+
+    def set_InputCloud(self, PointCloud_PointXYZRGBA pc not None):
+        (<cpp.PCLBase_PointXYZRGBA_t*>self.me).setInputCloud (pc.thisptr_shared)
+
+    def set_mean_k(self, int k):
+        """
+        Set the number of points (k) to use for mean distance estimation. 
+        """
+        self.me.setMeanK(k)
+
+    def set_std_dev_mul_thresh(self, double std_mul):
+        """
+        Set the standard deviation multiplier threshold.
+        """
+        self.me.setStddevMulThresh(std_mul)
+
+    def set_negative(self, bool negative):
+        """
+        Set whether the indices should be returned, or all points except the indices. 
+        """
+        self.me.setNegative(negative)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
diff --git a/pcl/pxi/Filters/VoxelGridFilter.pxi b/pcl/pxi/Filters/VoxelGridFilter.pxi
new file mode 100644
index 0000000..b24826e
--- /dev/null
+++ b/pcl/pxi/Filters/VoxelGridFilter.pxi
@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters as pclfil
+
+cdef class VoxelGridFilter:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+    def set_DownsampleAllData (self, bool downsample):
+        self.me.setDownsampleAllData (downsample)
+
+    def get_DownsampleAllData (self):
+        return self.me.getDownsampleAllData ()
+
+    def set_SaveLeafLayout (self, bool save_leaf_layout):
+        self.me.setSaveLeafLayout (save_leaf_layout)
+
+    def get_SaveLeafLayout (self):
+        return self.me.getSaveLeafLayout ()
+
+    # eigen3.Vector3i
+    # def get_MinBoxCoordinates (self):
+    #     return self.me.getMinBoxCoordinates ()
+
+    # eigen3.Vector3i
+    # def get_MaxBoxCoordinates (self):
+    #     return self.me.getMaxBoxCoordinates ()
+
+    # eigen3.Vector3i
+    # def get_NrDivisions (self):
+    #     return self.me.getNrDivisions ()
+
+    # eigen3.Vector3i
+    # def get_DivisionMultiplier (self):
+    #     return self.me.getDivisionMultiplier ()
+
+    # int
+    # def get_DivisionMultiplier (self, const T &p):
+    #     return self.me.getCentroidIndex (p)
+
+    # vector[int]
+    # def get_NeighborCentroidIndices (self, const T &reference_point, const eigen3.MatrixXi &relative_coordinates):
+    #   return self.me.getNeighborCentroidIndices (reference_point, relative_coordinates)
+
+    # vector[int]
+    def get_LeafLayout (self):
+        return self.me.getLeafLayout ()
+
+    # Eigen::Vector3i 
+    # def get_GridCoordinates (self, float x, float y, float z):
+    #     return self.me.getGridCoordinates (x, y, z) 
+
+    # int
+    # def get_CentroidIndexAt (self, const eigen3.Vector3i &ijk):
+    #     return self.me.getCentroidIndexAt (ijk)
+
+    # def set_FilterFieldName (self, const string &field_name):
+    #     self.me.setFilterFieldName (field_name)
+
+    # string
+    def get_FilterFieldName (self):
+        return self.me.getFilterFieldName ()
+
+    def set_FilterLimits (self, const double &limit_min, const double &limit_max):
+        self.me.setFilterLimits (limit_min, limit_max)
+
+    # void
+    def get_FilterLimits (self, double &limit_min, double &limit_max):
+        self.me.getFilterLimits (limit_min, limit_max)
+
+    def set_FilterLimitsNegative (self, const bool limit_negative):
+        self.me.setFilterLimitsNegative (limit_negative)
+
+    # void
+    def get_FilterLimitsNegative (self, bool &limit_negative):
+        self.me.getFilterLimitsNegative (limit_negative)
+
+    # bool
+    def get_FilterLimitsNegative (self):
+        return self.me.getFilterLimitsNegative ()
+
+
+cdef class VoxelGridFilter_PointXYZI:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class VoxelGridFilter_PointXYZRGB:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
+cdef class VoxelGridFilter_PointXYZRGBA:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+
diff --git a/pcl/pxi/Filters/VoxelGridFilter_172.pxi b/pcl/pxi/Filters/VoxelGridFilter_172.pxi
new file mode 100644
index 0000000..58d27a0
--- /dev/null
+++ b/pcl/pxi/Filters/VoxelGridFilter_172.pxi
@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_172 as pclfil
+
+cdef class VoxelGridFilter:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class VoxelGridFilter_PointXYZI:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class VoxelGridFilter_PointXYZRGB:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class VoxelGridFilter_PointXYZRGBA:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Filters/VoxelGridFilter_180.pxi b/pcl/pxi/Filters/VoxelGridFilter_180.pxi
new file mode 100644
index 0000000..5a7b386
--- /dev/null
+++ b/pcl/pxi/Filters/VoxelGridFilter_180.pxi
@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_filters_180 as pclfil
+
+cdef class VoxelGridFilter:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class VoxelGridFilter_PointXYZI:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class VoxelGridFilter_PointXYZRGB:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.filter(pc.thisptr()[0])
+        return pc
+
+cdef class VoxelGridFilter_PointXYZRGBA:
+    """
+    Assembles a local 3D grid over a given PointCloud, and downsamples + filters the data.
+    """
+    cdef pclfil.VoxelGrid_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclfil.VoxelGrid_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def set_leaf_size (self, float x, float y, float z):
+        """
+        Set the voxel grid leaf size.
+        """
+        self.me.setLeafSize(x,y,z)
+
+    def filter(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.filter(pc.thisptr()[0])
+        return pc
diff --git a/pcl/pxi/Grabber/AddList.txt b/pcl/pxi/Grabber/AddList.txt
new file mode 100644
index 0000000..58516d3
--- /dev/null
+++ b/pcl/pxi/Grabber/AddList.txt
@@ -0,0 +1,199 @@
+cdef class Common:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s" type(init))
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZ *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.PointXYZ* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
+###
+# 
+# include "Segmentation.pxi"
+# include "SegmentationNormal.pxi"
+# include "StatisticalOutlierRemovalFilter.pxi"
+# include "VoxelGridFilter.pxi"
+# include "PassThroughFilter.pxi"
+# include "MovingLeastSquares.pxi"
+# include "KdTree_FLANN.pxi"
+# include "OctreePointCloud.pxi"
+# include "Vertices.pxi"
+# include "CropHull.pxi"
+# include "CropBox.pxi"
+# include "ProjectInliers.pxi"
+# include "RadiusOutlierRemoval.pxi"
+# include "ConditionAnd.pxi"
+# include "ConditionalRemoval.pxi"
+# # Ubuntu/Mac NG(1.7? 1.8?)
+# # include "UniformSampling.pxi"
+# # include "IntegralImageNormalEstimation.pxi"
+
diff --git a/pcl/pxi/Grabber/ONIGrabber.pxi b/pcl/pxi/Grabber/ONIGrabber.pxi
new file mode 100644
index 0000000..d1ac93f
--- /dev/null
+++ b/pcl/pxi/Grabber/ONIGrabber.pxi
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# http://ros-robot.blogspot.jp/2011/08/point-cloud-librarykinect.html
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_grabber as pcl_grb
+
+cimport eigen as eigen3
+cimport _bind_defs as _bind
+
+from boost_shared_ptr cimport shared_ptr
+
+
+cdef class ONIGrabber_:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in ONIGrabber(pc).
+    """
+    cdef pcl_grb.ONIGrabber *me
+
+    def __cinit__(self, string file_name, bool repeat, bool stream):
+        self.me = new pcl_grb.ONIGrabber(file_name, repeat, stream)
+
+    def __dealloc__(self):
+        del self.me
+
+    # def RegisterCallback (self, func):
+    #     cdef _bind.arg _1
+    #     cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](<_bind.callback_t> func, _1)
+    #     self.me.register_callback(<_bind.function[callback_t]> callback)
+
+    def Start(self):
+        self.me.start ()
+
+    def Stop(self):
+        self.me.stop ()
+
+    # string 
+    # def getName ():
+    #     return self.me.getName ()
+
+    # bool 
+    # def isRunning ():
+    #     return self.me.isRunning ()
+
+    # return float 
+    # def getFramesPerSecond ():
+    #     return self.me.getFramesPerSecond ()
+
diff --git a/pcl/pxi/Grabber/OpenNIGrabber.pxi b/pcl/pxi/Grabber/OpenNIGrabber.pxi
new file mode 100644
index 0000000..5368d6c
--- /dev/null
+++ b/pcl/pxi/Grabber/OpenNIGrabber.pxi
@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# http://ros-robot.blogspot.jp/2011/08/point-cloud-librarykinect.html
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_grabber as pcl_grb
+
+cimport eigen as eigen3
+cimport _bind_defs as _bind
+
+from boost_shared_ptr cimport shared_ptr
+
+cdef void some_callback(void* some_ptr):
+    print('Hello from some_callback (Cython) !')
+    # print 'some_ptr: ' + some_ptr
+
+cdef class OpenNIGrabber_:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in OpenNIGrabber().
+    """
+    cdef pcl_grb.OpenNIGrabber *me
+
+    # cdef void some_callback(self, void* some_ptr):
+    #     print('Hello from some_callback (Cython) !')
+    #     # print 'some_ptr: ' + some_ptr
+
+    def __cinit__(self, device_id, depth_mode, image_mode):
+        self.me = new pcl_grb.OpenNIGrabber(device_id, depth_mode, image_mode)
+
+    def __dealloc__(self):
+        del self.me
+
+    def RegisterCallback (self, func):
+        cdef _bind.arg _1
+        # cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](<_bind.callback_t> func, _1)
+        # NG(Cannot assign type 'void (OpenNIGrabber_, void *)' to 'callback_t')
+        # cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](self.some_callback, _1)
+        cdef _bind.function[_bind.callback_t] callback = _bind.bind[_bind.callback_t](some_callback, _1)
+        # self.me.register_callback(callback)
+        self.me.registerCallback[_bind.callback_t](callback)
+        # (<pcl_grb.Grabber*>self.me).registerCallback[_bind.callback_t](callback)
+
+    def Start(self):
+        self.me.start ()
+
+    def Stop(self):
+        self.me.stop ()
+
+    # string 
+    # def getName ():
+    #     return self.me.getName ()
+
+    # bool 
+    # def isRunning ():
+    #     return self.me.isRunning ()
+
+    # return float 
+    # def getFramesPerSecond ():
+    #     return self.me.getFramesPerSecond ()
+
diff --git a/pcl/pxi/Grabber/PyGrabberCallback.pxi b/pcl/pxi/Grabber/PyGrabberCallback.pxi
new file mode 100644
index 0000000..fc02c62
--- /dev/null
+++ b/pcl/pxi/Grabber/PyGrabberCallback.pxi
@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+cimport pcl_grabber as pcl_grb
+from ../../grabber_callback cimport PyLibCallBack
+from ../../grabber_callback cimport callback
+
+cdef class PyGrabberCallback:
+    cdef PyLibCallBack* thisptr
+
+    def __cinit__(self, method):
+        # 'callback' :: The pattern/converter method to fire a Python 
+        #               object method from C typed infos
+        # 'method'   :: The effective method passed by the Python user 
+        self.thisptr = new PyLibCallBack(callback, <void*>method)
+
+    def __dealloc__(self):
+       if self.thisptr:
+           del self.thisptr
+
+    cpdef double execute(self, parameter):
+        # 'parameter' :: The parameter to be passed to the 'method'
+        return self.thisptr.cy_execute(<void*>parameter)
\ No newline at end of file
diff --git a/pcl/pxi/Grabber/PyGrabberNode.pxi b/pcl/pxi/Grabber/PyGrabberNode.pxi
new file mode 100644
index 0000000..a446151
--- /dev/null
+++ b/pcl/pxi/Grabber/PyGrabberNode.pxi
@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_grabber as pcl_grb
+
+cdef class PyGrabberNode:
+    cdef double d_prop
+
+    # def __cinit__(self):
+    #     self.thisptr = new PyLibCallBack(callback, <void*>method)
+
+    # def __dealloc__(self):
+    #    if self.thisptr:
+    #        del self.thisptr
+
+    def Test(self):
+        print('PyGrabberNode - Test')
+        d_prop = 10.0
+
+
diff --git a/pcl/pxi/Grabber/SimpleNIGrabber.pxi b/pcl/pxi/Grabber/SimpleNIGrabber.pxi
new file mode 100644
index 0000000..11d6f17
--- /dev/null
+++ b/pcl/pxi/Grabber/SimpleNIGrabber.pxi
@@ -0,0 +1,60 @@
+
+# -*- coding: utf-8 -*-
+# 
+# http://ros-robot.blogspot.jp/2011/08/point-cloud-librarykinect.html
+from libcpp.vector cimport vector
+from libcpp cimport bool
+
+cimport pcl_defs as cpp
+cimport pcl_grabber as pclgrb
+
+cimport eigen as eigen3
+
+from boost_shared_ptr cimport shared_ptr
+
+# callback
+from cython.operator cimport dereference as deref
+import sys
+# referenced from
+# http://stackoverflow.com/questions/5242051/cython-implementing-callbacks
+
+ctypedef double (*method_type)(void *param, void *user_data)
+
+cdef extern from "grabber_callback.hpp":
+    cdef cppclass cpp_backend:
+        cpp_backend(method_type method, void *callback_func)
+        double callback_python(void *parameter)
+
+cdef double scaffold(void *parameter, void *callback_func):
+    return (<object>callback_func)(<object>parameter)
+
+
+cdef class SimpleNIGrabber:
+    """
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in SimpleNIGrabber(pc).
+    """
+    cdef cpp_backend *thisptr
+
+    def __cinit__(self, pycallback_func):
+        self.thisptr = new cpp_backend(scaffold, <void*>pycallback_func)
+
+    def __dealloc__(self):
+        if self.thisptr:
+            del self.thisptr
+
+    cpdef double callback(self, parameter):
+        return self.thisptr.callback_python(<void*>parameter)
+
+    def run():
+        cdef pclgrb.Grabber interface = pclgrb.OpenNIGrabber()
+        # boost::function<void (const PointCloud_PointXYZRGB_t)> f = 
+        #     boost::bind (&SimpleOpenNIViewer::cloud_cb_, this, _1)
+        # interface.registerCallback (f)
+        interface.start ()
+
+        while (!viewer.wasStopped())
+            sleep (1)
+        end
+        interface.stop ()
+
diff --git a/pcl/pxi/IO/AddList.txt b/pcl/pxi/IO/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/IO/AddList.txt
diff --git a/pcl/pxi/KdTree/AddList.txt b/pcl/pxi/KdTree/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/KdTree/AddList.txt
diff --git a/pcl/pxi/KdTree/KdTree.pxi b/pcl/pxi/KdTree/KdTree.pxi
new file mode 100644
index 0000000..7e0b735
--- /dev/null
+++ b/pcl/pxi/KdTree/KdTree.pxi
@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_kdtree as pclkdt
+
+cdef class KdTree:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTree(pc).
+    """
+    cdef cpp.KdTree_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclkdt.KdTree_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+
+cdef class KdTree_PointXYZI:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTree(pc).
+    """
+    cdef cpp.KdTree_PointXYZI_t *me
+
+    def __cinit__(self, PointCloud_PointXYZI pc not None):
+        self.me = new cpp.KdTree_PointXYZI_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+cdef class KdTree_PointXYZRGB:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTree(pc).
+    """
+    cdef cpp.KdTree_PointXYZRGB_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+        self.me = new cpp.KdTree_PointXYZRGB_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+cdef class KdTree_PointXYZRGBA:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTree(pc).
+    """
+    cdef cpp.KdTree_PointXYZRGBA_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+        self.me = new cpp.KdTree_PointXYZRGBA_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+
diff --git a/pcl/pxi/KdTree/KdTree_FLANN.pxi b/pcl/pxi/KdTree/KdTree_FLANN.pxi
new file mode 100644
index 0000000..0a3922c
--- /dev/null
+++ b/pcl/pxi/KdTree/KdTree_FLANN.pxi
@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_kdtree as pclkdt
+
+cdef class KdTreeFLANN:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTreeFLANN(pc).
+    """
+    cdef pclkdt.KdTreeFLANN_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclkdt.KdTreeFLANN_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._nearest_k(pc, i, k, ind[i], sqdist[i])
+        return ind, sqdist
+
+    def nearest_k_search_for_point(self, PointCloud pc not None, int index,
+                                   int k=1):
+        """
+        Find the k nearest neighbours and squared distances for the point
+        at pc[index]. Results are in ndarrays, size (k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+
+        self._nearest_k(pc, index, k, ind, sqdist)
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _nearest_k(self, PointCloud pc, int index, int k,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # k nearest neighbors query for a single point.
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        k_indices.resize(k)
+        k_sqr_distances.resize(k)
+        self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+                               k_sqr_distances)
+
+        for i in range(k):
+            sqdist[i] = k_sqr_distances[i]
+            ind[i] = k_indices[i]
+
+    def radius_search_for_cloud(self, PointCloud pc not None, double radius, unsigned int max_nn = 0):
+        """
+        Find the radius and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (radius_indices, radius_distances)
+        """
+        k = max_nn
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._search_radius(pc, i, k, radius, ind[i], sqdist[i])
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _search_radius(self, PointCloud pc, int index, int k, double radius,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # radius query for a single point.
+        cdef vector[int] radius_indices
+        cdef vector[float] radius_distances
+        radius_indices.resize(k)
+        radius_distances.resize(k)
+        self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)
+
+        for i in range(k):
+            sqdist[i] = radius_distances[i]
+            ind[i] = radius_indices[i]
+
+cdef class KdTreeFLANN_PointXYZI:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTreeFLANN(pc).
+    """
+    cdef pclkdt.KdTreeFLANN_PointXYZI_t *me
+
+    def __cinit__(self, PointCloud_PointXYZI pc not None):
+        self.me = new pclkdt.KdTreeFLANN_PointXYZI_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def nearest_k_search_for_cloud(self, PointCloud_PointXYZI pc not None, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._nearest_k(pc, i, k, ind[i], sqdist[i])
+        return ind, sqdist
+
+    def nearest_k_search_for_point(self, PointCloud_PointXYZI pc not None, int index,
+                                   int k=1):
+        """
+        Find the k nearest neighbours and squared distances for the point
+        at pc[index]. Results are in ndarrays, size (k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+
+        self._nearest_k(pc, index, k, ind, sqdist)
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _nearest_k(self, PointCloud_PointXYZI pc, int index, int k,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # k nearest neighbors query for a single point.
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        k_indices.resize(k)
+        k_sqr_distances.resize(k)
+        self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+                               k_sqr_distances)
+
+        for i in range(k):
+            sqdist[i] = k_sqr_distances[i]
+            ind[i] = k_indices[i]
+
+
+cdef class KdTreeFLANN_PointXYZRGB:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTreeFLANN(pc).
+    """
+    cdef pclkdt.KdTreeFLANN_PointXYZRGB_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+        self.me = new pclkdt.KdTreeFLANN_PointXYZRGB_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGB pc not None, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._nearest_k(pc, i, k, ind[i], sqdist[i])
+        return ind, sqdist
+
+    def nearest_k_search_for_point(self, PointCloud_PointXYZRGB pc not None, int index,
+                                   int k=1):
+        """
+        Find the k nearest neighbours and squared distances for the point
+        at pc[index]. Results are in ndarrays, size (k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+
+        self._nearest_k(pc, index, k, ind, sqdist)
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _nearest_k(self, PointCloud_PointXYZRGB pc, int index, int k,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # k nearest neighbors query for a single point.
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        k_indices.resize(k)
+        k_sqr_distances.resize(k)
+        self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+                               k_sqr_distances)
+
+        for i in range(k):
+            sqdist[i] = k_sqr_distances[i]
+            ind[i] = k_indices[i]
+
+
+cdef class KdTreeFLANN_PointXYZRGBA:
+    """
+    Finds k nearest neighbours from points in another pointcloud to points in
+    a reference pointcloud.
+
+    Must be constructed from the reference point cloud, which is copied, so
+    changed to pc are not reflected in KdTreeFLANN(pc).
+    """
+    cdef pclkdt.KdTreeFLANN_PointXYZRGBA_t *me
+
+    def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+        self.me = new pclkdt.KdTreeFLANN_PointXYZRGBA_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+    def nearest_k_search_for_cloud(self, PointCloud_PointXYZRGBA pc not None, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._nearest_k(pc, i, k, ind[i], sqdist[i])
+        return ind, sqdist
+
+    def nearest_k_search_for_point(self, PointCloud_PointXYZRGBA pc not None, int index,
+                                   int k=1):
+        """
+        Find the k nearest neighbours and squared distances for the point
+        at pc[index]. Results are in ndarrays, size (k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+
+        self._nearest_k(pc, index, k, ind, sqdist)
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _nearest_k(self, PointCloud_PointXYZRGBA pc, int index, int k,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # k nearest neighbors query for a single point.
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        k_indices.resize(k)
+        k_sqr_distances.resize(k)
+        self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices,
+                               k_sqr_distances)
+
+        for i in range(k):
+            sqdist[i] = k_sqr_distances[i]
+            ind[i] = k_indices[i]
+
diff --git a/pcl/pxi/KeyPoint/AddList.txt b/pcl/pxi/KeyPoint/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/KeyPoint/AddList.txt
diff --git a/pcl/pxi/KeyPoint/HarrisKeypoint3D.pxi b/pcl/pxi/KeyPoint/HarrisKeypoint3D.pxi
new file mode 100644
index 0000000..c0bd892
--- /dev/null
+++ b/pcl/pxi/KeyPoint/HarrisKeypoint3D.pxi
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_keypoints as keypt
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+cdef class HarrisKeypoint3D:
+    """
+    HarrisKeypoint3D class for 
+    """
+    cdef keypt.HarrisKeypoint3D_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new keypt.HarrisKeypoint3D_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+        # sp_assign(self.thisptr_shared, new keypt.HarrisKeypoint3D_t())
+        # self.thisptr().setInputCloud(pc.thisptr_shared)
+        # pass
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_NonMaxSupression(self, bool param):
+        self.me.setNonMaxSupression (param)
+
+    def set_Radius(self, float param):
+        self.me.setRadius (param)
+
+    def set_RadiusSearch(self, double param):
+        self.me.setRadiusSearch (param)
+
+    def compute(self):
+        # compute function based KeyPoint class
+        # self.thisptr().compute (deref(cPointCloudPointXYZI.makeShared().get()))
+        ###
+        # OK : data 0
+        keypoints = PointCloud_PointXYZI()
+        cdef cpp.PointCloud_PointXYZI_t *ckeypoints = <cpp.PointCloud_PointXYZI_t*>keypoints.thisptr()
+        self.me.compute (<cpp.PointCloud[cpp.PointXYZI]> deref(ckeypoints.makeShared().get()))
+        # self.me.compute (ckeypoints.makeShared().get())
+        print('keypoints.count : ' + str(keypoints.size))
+        return keypoints
+
diff --git a/pcl/pxi/KeyPoint/HarrisKeypoint3D_172.pxi b/pcl/pxi/KeyPoint/HarrisKeypoint3D_172.pxi
new file mode 100644
index 0000000..e72796e
--- /dev/null
+++ b/pcl/pxi/KeyPoint/HarrisKeypoint3D_172.pxi
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_keypoints_172 as keypt
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+cdef class HarrisKeypoint3D:
+    """
+    HarrisKeypoint3D class for 
+    """
+    cdef keypt.HarrisKeypoint3D_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new keypt.HarrisKeypoint3D_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+        # pass
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_NonMaxSupression(self, bool param):
+        self.me.setNonMaxSupression (param)
+
+    def set_Radius(self, float param):
+        self.me.setRadius (param)
+
+    def set_RadiusSearch(self, double param):
+        self.me.setRadiusSearch (param)
+
+    def compute(self):
+        # compute function based KeyPoint class
+        # self.thisptr().compute (deref(cPointCloudPointXYZI.makeShared().get()))
+        ###
+        # OK : data 0
+        keypoints = PointCloud_PointXYZI()
+        cdef cpp.PointCloud_PointXYZI_t *ckeypoints = <cpp.PointCloud_PointXYZI_t*>keypoints.thisptr()
+        # self.me.compute (<cpp.PointCloud[cpp.PointXYZI]> deref(ckeypoints.makeShared().get()))
+        # pcl.1.7.2
+        self.me.compute (<cpp.PointCloud[cpp.PointXYZI]&> deref(ckeypoints.makeShared().get()))
+        # self.me.compute (ckeypoints.makeShared().get())
+        print('keypoints.count : ' + str(keypoints.size))
+        return keypoints
+
diff --git a/pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi b/pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi
new file mode 100644
index 0000000..bfec624
--- /dev/null
+++ b/pcl/pxi/KeyPoint/HarrisKeypoint3D_180.pxi
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+from libc.stddef cimport size_t
+
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool
+
+# main
+cimport pcl_defs as cpp
+cimport pcl_keypoints_180 as keypt
+
+# boost
+from boost_shared_ptr cimport shared_ptr
+
+
+###############################################################################
+# Types
+###############################################################################
+
+### base class ###
+
+cdef class HarrisKeypoint3D:
+    """
+    HarrisKeypoint3D class for 
+    """
+    cdef keypt.HarrisKeypoint3D_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new keypt.HarrisKeypoint3D_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+        # pass
+
+    def __dealloc__(self):
+        del self.me
+
+    def set_NonMaxSupression(self, bool param):
+        self.me.setNonMaxSupression (param)
+
+    def set_Radius(self, float param):
+        self.me.setRadius (param)
+
+    def set_RadiusSearch(self, double param):
+        self.me.setRadiusSearch (param)
+
+    def compute(self):
+        # compute function based KeyPoint class
+        # self.thisptr().compute (deref(cPointCloudPointXYZI.makeShared().get()))
+        ###
+        # OK : data 0
+        keypoints = PointCloud_PointXYZI()
+        cdef cpp.PointCloud_PointXYZI_t *ckeypoints = <cpp.PointCloud_PointXYZI_t*>keypoints.thisptr()
+        # self.me.compute (<cpp.PointCloud[cpp.PointXYZI]> deref(ckeypoints.makeShared().get()))
+        # pcl.1.7.2
+        self.me.compute (<cpp.PointCloud[cpp.PointXYZI]&> deref(ckeypoints.makeShared().get()))
+        # self.me.compute (ckeypoints.makeShared().get())
+        print('keypoints.count : ' + str(keypoints.size))
+        return keypoints
+
diff --git a/pcl/pxi/KeyPoint/NarfKeypoint.pxi b/pcl/pxi/KeyPoint/NarfKeypoint.pxi
new file mode 100644
index 0000000..d712bb6
--- /dev/null
+++ b/pcl/pxi/KeyPoint/NarfKeypoint.pxi
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_keypoints as pclkp
+
+cdef class NarfKeypoint:
+    """
+    """
+    cdef pclkp.NarfKeypoint_t *me
+
+    def __cinit__(self, RangeImageBorderExtractor pc not None):
+        self.me = <pclkp.NarfKeypoint>new pclkp.NarfKeypoint(pc, -1.0)
+
+    def __dealloc__(self):
+        del self.me
+
diff --git a/pcl/pxi/KeyPoint/NarfKeypoint_172.pxi b/pcl/pxi/KeyPoint/NarfKeypoint_172.pxi
new file mode 100644
index 0000000..7bdf0fc
--- /dev/null
+++ b/pcl/pxi/KeyPoint/NarfKeypoint_172.pxi
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_keypoints_172 as pclkp
+
+cdef class NarfKeypoint:
+    """
+    """
+    cdef pclkp.NarfKeypoint_t *me
+
+    def __cinit__(self, RangeImageBorderExtractor pc not None):
+        self.me = <pclkp.NarfKeypoint>new pclkp.NarfKeypoint(pc, -1.0)
+
+    def __dealloc__(self):
+        del self.me
+
diff --git a/pcl/pxi/KeyPoint/NarfKeypoint_180.pxi b/pcl/pxi/KeyPoint/NarfKeypoint_180.pxi
new file mode 100644
index 0000000..c7703ab
--- /dev/null
+++ b/pcl/pxi/KeyPoint/NarfKeypoint_180.pxi
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_keypoints_180 as pclkp
+
+cdef class NarfKeypoint:
+    """
+    """
+    cdef pclkp.NarfKeypoint_t *me
+
+    def __cinit__(self, RangeImageBorderExtractor pc not None):
+        self.me = <pclkp.NarfKeypoint>new pclkp.NarfKeypoint(pc, -1.0)
+
+    def __dealloc__(self):
+        del self.me
+
diff --git a/pcl/pxi/KeyPoint/UniformSampling.pxi b/pcl/pxi/KeyPoint/UniformSampling.pxi
new file mode 100644
index 0000000..f3ebb69
--- /dev/null
+++ b/pcl/pxi/KeyPoint/UniformSampling.pxi
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_keypoints as pclkp
+
+cdef class UniformSampling:
+    """
+    """
+    cdef pclkp.UniformSampling_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclkp.UniformSampling_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+
+# cdef class UniformSampling_PointXYZI:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZI_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZI pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZI_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
+
+# cdef class UniformSampling_PointXYZRGB:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZRGB_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZRGB_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
+
+# cdef class UniformSampling_PointXYZRGBA:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZRGBA_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZRGBA_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
diff --git a/pcl/pxi/KeyPoint/UniformSampling_172.pxi b/pcl/pxi/KeyPoint/UniformSampling_172.pxi
new file mode 100644
index 0000000..85abc81
--- /dev/null
+++ b/pcl/pxi/KeyPoint/UniformSampling_172.pxi
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_keypoints_172 as pclkp
+
+cdef class UniformSampling:
+    """
+    """
+    cdef pclkp.UniformSampling_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclkp.UniformSampling_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+
+# cdef class UniformSampling_PointXYZI:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZI_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZI pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZI_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
+
+# cdef class UniformSampling_PointXYZRGB:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZRGB_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZRGB_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
+
+# cdef class UniformSampling_PointXYZRGBA:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZRGBA_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZRGBA_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
diff --git a/pcl/pxi/KeyPoint/UniformSampling_180.pxi b/pcl/pxi/KeyPoint/UniformSampling_180.pxi
new file mode 100644
index 0000000..24b2719
--- /dev/null
+++ b/pcl/pxi/KeyPoint/UniformSampling_180.pxi
@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_keypoints_180 as pclkp
+
+cdef class UniformSampling:
+    """
+    """
+    cdef pclkp.UniformSampling_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        self.me = new pclkp.UniformSampling_t()
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    def __dealloc__(self):
+        del self.me
+
+
+# cdef class UniformSampling_PointXYZI:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZI_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZI pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZI_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
+
+# cdef class UniformSampling_PointXYZRGB:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZRGB_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZRGB pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZRGB_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
+
+# cdef class UniformSampling_PointXYZRGBA:
+#     """
+#     """
+#     cdef pclkp.UniformSampling_PointXYZRGBA_t *me
+# 
+#     def __cinit__(self, PointCloud_PointXYZRGBA pc not None):
+#         self.me = new pclkp.UniformSampling_PointXYZRGBA_t()
+#         # self.me.setInputCloud(<shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> pc.thisptr_shared)
+#         self.me.setInputCloud(pc.thisptr_shared)
+# 
+#     def __dealloc__(self):
+#         del self.me
+###
diff --git a/pcl/pxi/Octree/AddList.txt b/pcl/pxi/Octree/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/Octree/AddList.txt
diff --git a/pcl/pxi/Octree/Octree2BufBase.pxi b/pcl/pxi/Octree/Octree2BufBase.pxi
new file mode 100644
index 0000000..35c7496
--- /dev/null
+++ b/pcl/pxi/Octree/Octree2BufBase.pxi
@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-

+cimport pcl_defs as cpp

+cimport pcl_octree as pcloct

+

+cimport eigen as eig

+

+include "../PointXYZtoPointXYZ.pxi"

+

+cdef class Octree2BufBase:

+    """

+    Octree2BufBase

+    """

+    cdef pcloct.Octree2BufBase_t *me

+

+    # def __cinit__(self, double resolution):

+    #     self.me = NULL

+

+    def __cinit__(self, double resolution):

+        """

+        Constructs octree pointcloud with given resolution at lowest octree level

+        """ 

+        self.me = new pcloct.Octree2BufBase_t(resolution)

+

+    def __dealloc__(self):

+        del self.me

+        self.me = NULL      # just to be sure

+

+    def set_MaxVoxelIndex (self, unsigned int maxVoxelIndex_arg):

+        self.me.setMaxVoxelIndex (maxVoxelIndex_arg)

+

+    def set_TreeDepth (self, unsigned int depth_arg):

+        self.me.setTreeDepth (depth_arg)

+

+    def get_TreeDepth (self)
+        self.me.getTreeDepth ()
+


+    def AddData (self, unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, const DataT& data_arg):
+        self.me.addData (idxX_arg, idxY_arg, idxZ_arg, const DataT& data_arg)

+

+    # return bool

+    def get_Data (self, unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg, const DataT& data_arg):
+        return self.me.getData (idxX_arg, idxY_arg, idxZ_arg, DataT& data_arg)

+

+    # return bool
+    def existLeaf (self, unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg):

+        return self.me.existLeaf (unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg) const

+

+    def removeLeaf (self, unsigned int idxX_arg, unsigned int idxY_arg, unsigned int idxZ_arg):

+        self.me.removeLeaf (idxX_arg, idxY_arg, idxZ_arg)

+

+    def getLeafCount (self):

+        self.me.getLeafCount()

+

+    def getBranchCount (self):

+        self.me.getBranchCount()

+

+    def deleteTree (bool freeMemory_arg)

+        self.me.deleteTree (freeMemory_arg)

+

+    def deletePreviousBuffer ()

+        self.me.deletePreviousBuffer ()

+

+    def deleteCurrentBuffer ()

+        self.me.deleteCurrentBuffer ()

+

+    def switchBuffers ()

+        self.me.switchBuffers ()

+

+#     def serializeTree (vector[char]& binaryTreeOut_arg, bool doXOREncoding_arg)

+#         self.me.serializeTree (binaryTreeOut_arg, doXOREncoding_arg)

+# 

+#     def serializeTree (vector[char]& binaryTreeOut_arg, vector[DataT]& dataVector_arg, bool doXOREncoding_arg)

+#         self.me.serializeTree (binaryTreeOut_arg, dataVector_arg, doXOREncoding_arg)
+# 

+#     def serializeLeafs (vector[DataT]& dataVector_arg)

+#         self.me.serializeLeafs (dataVector_arg)
+# 

+#     def serializeNewLeafs (vector[DataT]& dataVector_arg, const int minPointsPerLeaf_arg)

+#         self.me.serializeNewLeafs (dataVector_arg, minPointsPerLeaf_arg)

+# 

+#     def deserializeTree (vector[char]& binaryTreeIn_arg, bool doXORDecoding_arg)

+#         self.me.deserializeTree (binaryTreeIn_arg, doXORDecoding_arg)
+# 

+#     def deserializeTree (vector[char]& binaryTreeIn_arg, vector[DataT]& dataVector_arg, bool doXORDecoding_arg)

+#         self.me.deserializeTree (binaryTreeIn_arg, dataVector_arg, doXORDecoding_arg)

+

+

diff --git a/pcl/pxi/Octree/OctreePointCloud.pxi b/pcl/pxi/Octree/OctreePointCloud.pxi
new file mode 100644
index 0000000..4c0f00f
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloud.pxi
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree as pcloct
+
+cimport eigen as eig
+
+cdef class OctreePointCloud:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_t(0)
+    #     # self.me = new pcloct.OctreePointCloud_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+        
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     self.me.deleteVoxelAtPoint(to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(deref(self.me), to_point_t(point))
+
+
+cdef class OctreePointCloud_PointXYZI:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZI_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZI pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZI_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_PointXYZI_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters_PointXYZI(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (use minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint_PointXYZI(deref(self.me), to_point2_t(point))
+
+
+cdef class OctreePointCloud_PointXYZRGB:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZRGB_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_PointXYZRGB_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGB_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGB_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGB pc not None):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloud_PointXYZRGBA:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZRGBA_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGBA pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # use NG
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloud2Buf.pxi b/pcl/pxi/Octree/OctreePointCloud2Buf.pxi
new file mode 100644
index 0000000..f25f082
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloud2Buf.pxi
@@ -0,0 +1,314 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree as pcloct
+
+cimport eigen as eig
+
+cdef class OctreePointCloud2Buf:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(Build Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+        
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     self.me.deleteVoxelAtPoint(to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(deref(self.me), to_point_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZI:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZI_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZI_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZI pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZI_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_PointXYZI_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters_PointXYZI(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (use minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint_PointXYZI(deref(self.me), to_point2_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZRGB:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZRGB_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZRGB_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGB pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZRGBA:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZRGBA_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(Build Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZRGBA_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGBA pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # use NG
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloud2Buf_172.pxi b/pcl/pxi/Octree/OctreePointCloud2Buf_172.pxi
new file mode 100644
index 0000000..38e517b
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloud2Buf_172.pxi
@@ -0,0 +1,314 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_172 as pcloct
+
+cimport eigen as eig
+
+cdef class OctreePointCloud2Buf:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(Build Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+        
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     self.me.deleteVoxelAtPoint(to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(deref(self.me), to_point_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZI:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZI_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZI_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZI pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZI_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_PointXYZI_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters_PointXYZI(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (use minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint_PointXYZI(deref(self.me), to_point2_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZRGB:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZRGB_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZRGB_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGB pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZRGBA:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZRGBA_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(Build Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZRGBA_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGBA pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # use NG
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi b/pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi
new file mode 100644
index 0000000..c6f27ca
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloud2Buf_180.pxi
@@ -0,0 +1,314 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_180 as pcloct
+
+cimport eigen as eig
+
+cdef class OctreePointCloud2Buf:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(Build Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+        
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     self.me.deleteVoxelAtPoint(to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(deref(self.me), to_point_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZI:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZI_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZI_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZI pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZI_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_PointXYZI_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters_PointXYZI(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (use minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint_PointXYZI(deref(self.me), to_point2_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZRGB:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZRGB_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZRGB_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGB pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloud2Buf_PointXYZRGBA:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud2Buf_PointXYZRGBA_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(Build Error)
+    # def __cinit__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     self.me = new pcloct.OctreePointCloud2Buf_PointXYZRGBA_t(resolution)
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGBA pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # use NG
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloudChangeDetector.pxi b/pcl/pxi/Octree/OctreePointCloudChangeDetector.pxi
new file mode 100644
index 0000000..6ad9a75
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloudChangeDetector.pxi
@@ -0,0 +1,292 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree as pcloct
+
+cdef class OctreePointCloudChangeDetector(OctreePointCloud2Buf):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud(OctreePointCloud_t)
+    # cdef pcloct.OctreePointCloudChangeDetector_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_t*> new pcloct.OctreePointCloudChangeDetector_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        # for i, l in enumerate(newPointIdxVector):
+        #      p = idx.getptr(self.thisptr(), <int> i)
+        #      p.x, p.y, p.z = l
+        # 
+        # for i in pyindices:
+        #     ind.indices.push_back(i)
+        # 
+        # cdef cpp.PointIndices ind
+        # self.me.segment (ind, coeffs)
+        # return [ind.indices[i] for i in range(ind.indices.size())]
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    def switchBuffers (self):
+        cdef pcloct.Octree2BufBase_t* buf
+        buf = <pcloct.Octree2BufBase_t*>self.me2
+        buf.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZI(OctreePointCloud2Buf_PointXYZI):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZI
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZI_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZI_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZI_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZI_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point2_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZRGB(OctreePointCloud2Buf_PointXYZRGB):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZRGB
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGB_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me2.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZRGBA(OctreePointCloud2Buf_PointXYZRGBA):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZRGBA
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGBA_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloudChangeDetector_172.pxi b/pcl/pxi/Octree/OctreePointCloudChangeDetector_172.pxi
new file mode 100644
index 0000000..85425a0
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloudChangeDetector_172.pxi
@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_172 as pcloct
+
+cdef class OctreePointCloudChangeDetector(OctreePointCloud2Buf):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud(OctreePointCloud_t)
+    # cdef pcloct.OctreePointCloudChangeDetector_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_t*> new pcloct.OctreePointCloudChangeDetector_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    def switchBuffers (self):
+        cdef pcloct.Octree2BufBase_t* buf
+        buf = <pcloct.Octree2BufBase_t*>self.me2
+        buf.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZI(OctreePointCloud2Buf_PointXYZI):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZI
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZI_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZI_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZI_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZI_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point2_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZRGB(OctreePointCloud2Buf_PointXYZRGB):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZRGB
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGB_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me2.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZRGBA(OctreePointCloud2Buf_PointXYZRGBA):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZRGBA
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGBA_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi b/pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi
new file mode 100644
index 0000000..b426bd5
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloudChangeDetector_180.pxi
@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_180 as pcloct
+
+cdef class OctreePointCloudChangeDetector(OctreePointCloud2Buf):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud(OctreePointCloud_t)
+    # cdef pcloct.OctreePointCloudChangeDetector_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_t*> new pcloct.OctreePointCloudChangeDetector_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    def switchBuffers (self):
+        cdef pcloct.Octree2BufBase_t* buf
+        buf = <pcloct.Octree2BufBase_t*>self.me2
+        buf.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZI(OctreePointCloud2Buf_PointXYZI):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZI
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZI_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZI_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZI_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZI_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZI_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point2_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZRGB(OctreePointCloud2Buf_PointXYZRGB):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZRGB
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGB_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGB_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me2.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloudChangeDetector_PointXYZRGBA(OctreePointCloud2Buf_PointXYZRGBA):
+    """
+    Octree pointcloud ChangeDetector
+    """
+    # override OctreePointCloud_PointXYZRGBA
+    # cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me
+    cdef pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t*> new pcloct.OctreePointCloudChangeDetector_PointXYZRGBA_t(resolution)
+        self.me = <pcloct.OctreePointCloud2Buf_PointXYZRGBA_t*> self.me2
+
+    def get_PointIndicesFromNewVoxels (self):
+        cdef vector[int] newPointIdxVector
+        self.me2.getPointIndicesFromNewVoxels (newPointIdxVector, 0)
+        return newPointIdxVector
+
+    # use Octree2BufBase class function
+    # def switchBuffers (self):
+    #     self.me.switchBuffers()
+
+    # base OctreePointCloud2Buf
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloudSearch.pxi b/pcl/pxi/Octree/OctreePointCloudSearch.pxi
new file mode 100644
index 0000000..6c4e5ff
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloudSearch.pxi
@@ -0,0 +1,470 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree as pcloct
+
+# include "PointXYZtoPointXYZ.pxi" --> multiple define ng
+# include "OctreePointCloud.pxi"
+
+cdef class OctreePointCloudSearch(OctreePointCloud):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_t*> new pcloct.OctreePointCloudSearch_t(resolution)
+        self.me = <pcloct.OctreePointCloud_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    # nearestKSearch
+    ###
+    def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._nearest_k(pc, i, k, ind[i], sqdist[i])
+        return ind, sqdist
+
+    def nearest_k_search_for_point(self, PointCloud pc not None, int index, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for the point
+        at pc[index]. Results are in ndarrays, size (k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+
+        self._nearest_k(pc, index, k, ind, sqdist)
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _nearest_k(self, PointCloud pc, int index, int k,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # k nearest neighbors query for a single point.
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        k_indices.resize(k)
+        k_sqr_distances.resize(k)
+        # self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+        (<pcloct.OctreePointCloudSearch_t*>self.me).nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+
+        for i in range(k):
+            sqdist[i] = k_sqr_distances[i]
+            ind[i] = k_indices[i]
+
+    ###
+
+    # radius Search
+    ###
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+        
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        
+        cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    ###
+
+    # Voxel Search
+    ### 
+    def VoxelSearch (self, PointCloud pc):
+        """
+        Search for all neighbors of query point that are within a given voxel.
+        
+        Returns: (v_indices)
+        """
+        cdef vector[int] v_indices
+        # cdef bool isVexelSearch = (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(pc.thisptr()[0], v_indices)
+        # self._VoxelSearch(pc, v_indices)
+        result = pc.to_array()
+        cdef cpp.PointXYZ point
+        point.x = result[0, 0]
+        point.y = result[0, 1]
+        point.z = result[0, 2]
+        
+        print ('VoxelSearch at (' + str(point.x) + ' ' + str(point.y) + ' ' + str(point.z) + ')')
+        
+        # print('before v_indices count = ' + str(v_indices.size()))
+        self._VoxelSearch(point, v_indices)
+        v = v_indices.size()
+        # print('after v_indices count = ' + str(v))
+        
+        cdef cnp.ndarray[int] np_v_indices = np.zeros(v, dtype=np.int32)
+        for i in range(v):
+            np_v_indices[i] = v_indices[i]
+        
+        return np_v_indices
+
+    @cython.boundscheck(False)
+    cdef void _VoxelSearch(self, cpp.PointXYZ point, vector[int] &v_indices) except +:
+        cdef vector[int] voxel_indices
+        # k = 10
+        # voxel_indices.resize(k)
+        (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(point, voxel_indices)
+        
+        # print('_VoxelSearch k = ' + str(k))
+        # print('_VoxelSearch voxel_indices = ' + str(voxel_indices.size()))
+        k = voxel_indices.size()
+        
+        for i in range(k):
+            v_indices.push_back(voxel_indices[i])
+
+    ### 
+
+
+#     def radius_search_for_cloud(self, PointCloud pc not None, double radius):
+#         """
+#         Find the radius and squared distances for all points
+#         in the pointcloud. Results are in ndarrays, size (pc.size, k)
+#         Returns: (radius_indices, radius_distances)
+#         """
+#         k = 10
+#         cdef cnp.npy_intp n_points = pc.size
+#         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+#                                                           dtype=np.float32)
+#         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+#                                                      dtype=np.int32)
+# 
+#         for i in range(n_points):
+#             self._search_radius(pc, i, k, radius, ind[i], sqdist[i])
+#         return ind, sqdist
+# 
+#     @cython.boundscheck(False)
+#     cdef void _search_radius(self, PointCloud pc, int index, int k, double radius,
+#                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+#                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+#                         ) except +:
+#         # radius query for a single point.
+#         cdef vector[int] radius_indices
+#         cdef vector[float] radius_distances
+#         radius_indices.resize(k)
+#         radius_distances.resize(k)
+#         # self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)
+#         k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances, 10)
+# 
+#         for i in range(k):
+#             sqdist[i] = radius_distances[i]
+#             ind[i] = radius_indices[i]
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point_t(point))
+
+
+cdef class OctreePointCloudSearch_PointXYZI(OctreePointCloud_PointXYZI):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZI_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZI_t*> new pcloct.OctreePointCloudSearch_PointXYZI_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZI_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZI_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point2_t(point))
+
+
+cdef class OctreePointCloudSearch_PointXYZRGB(OctreePointCloud_PointXYZRGB):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZRGB_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGB_t*> new pcloct.OctreePointCloudSearch_PointXYZRGB_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZRGB_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloudSearch_PointXYZRGBA(OctreePointCloud_PointXYZRGBA):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZRGBA_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGBA_t*> new pcloct.OctreePointCloudSearch_PointXYZRGBA_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZRGBA_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloudSearch_172.pxi b/pcl/pxi/Octree/OctreePointCloudSearch_172.pxi
new file mode 100644
index 0000000..5dd5231
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloudSearch_172.pxi
@@ -0,0 +1,468 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_172 as pcloct
+
+# include "PointXYZtoPointXYZ.pxi" --> multiple define ng
+# include "OctreePointCloud.pxi"
+
+cdef class OctreePointCloudSearch(OctreePointCloud):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_t*> new pcloct.OctreePointCloudSearch_t(resolution)
+        self.me = <pcloct.OctreePointCloud_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    # nearestKSearch
+    ###
+    def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._nearest_k(pc, i, k, ind[i], sqdist[i])
+        return ind, sqdist
+
+    def nearest_k_search_for_point(self, PointCloud pc not None, int index, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for the point
+        at pc[index]. Results are in ndarrays, size (k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+
+        self._nearest_k(pc, index, k, ind, sqdist)
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _nearest_k(self, PointCloud pc, int index, int k,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # k nearest neighbors query for a single point.
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        k_indices.resize(k)
+        k_sqr_distances.resize(k)
+        # self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+        (<pcloct.OctreePointCloudSearch_t*>self.me).nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+
+        for i in range(k):
+            sqdist[i] = k_sqr_distances[i]
+            ind[i] = k_indices[i]
+
+    ###
+
+    # radius Search
+    ###
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+        
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    ###
+
+    # Voxel Search
+    ### 
+    def VoxelSearch (self, PointCloud pc):
+        """
+        Search for all neighbors of query point that are within a given voxel.
+        
+        Returns: (v_indices)
+        """
+        cdef vector[int] v_indices
+        # cdef bool isVexelSearch = (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(pc.thisptr()[0], v_indices)
+        # self._VoxelSearch(pc, v_indices)
+        result = pc.to_array()
+        cdef cpp.PointXYZ point
+        point.x = result[0, 0]
+        point.y = result[0, 1]
+        point.z = result[0, 2]
+        
+        print ('VoxelSearch at (' + str(point.x) + ' ' + str(point.y) + ' ' + str(point.z) + ')')
+        
+        # print('before v_indices count = ' + str(v_indices.size()))
+        self._VoxelSearch(point, v_indices)
+        v = v_indices.size()
+        # print('after v_indices count = ' + str(v))
+        
+        cdef cnp.ndarray[int] np_v_indices = np.zeros(v, dtype=np.int32)
+        for i in range(v):
+            np_v_indices[i] = v_indices[i]
+        
+        return np_v_indices
+
+    @cython.boundscheck(False)
+    cdef void _VoxelSearch(self, cpp.PointXYZ point, vector[int] &v_indices) except +:
+        cdef vector[int] voxel_indices
+        # k = 10
+        # voxel_indices.resize(k)
+        (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(point, voxel_indices)
+        
+        # print('_VoxelSearch k = ' + str(k))
+        # print('_VoxelSearch voxel_indices = ' + str(voxel_indices.size()))
+        k = voxel_indices.size()
+        
+        for i in range(k):
+            v_indices.push_back(voxel_indices[i])
+
+    ### 
+
+
+#     def radius_search_for_cloud(self, PointCloud pc not None, double radius):
+#         """
+#         Find the radius and squared distances for all points
+#         in the pointcloud. Results are in ndarrays, size (pc.size, k)
+#         Returns: (radius_indices, radius_distances)
+#         """
+#         k = 10
+#         cdef cnp.npy_intp n_points = pc.size
+#         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+#                                                           dtype=np.float32)
+#         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+#                                                      dtype=np.int32)
+# 
+#         for i in range(n_points):
+#             self._search_radius(pc, i, k, radius, ind[i], sqdist[i])
+#         return ind, sqdist
+# 
+#     @cython.boundscheck(False)
+#     cdef void _search_radius(self, PointCloud pc, int index, int k, double radius,
+#                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+#                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+#                         ) except +:
+#         # radius query for a single point.
+#         cdef vector[int] radius_indices
+#         cdef vector[float] radius_distances
+#         radius_indices.resize(k)
+#         radius_distances.resize(k)
+#         # self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)
+#         k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances, 10)
+# 
+#         for i in range(k):
+#             sqdist[i] = radius_distances[i]
+#             ind[i] = radius_indices[i]
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point_t(point))
+
+
+cdef class OctreePointCloudSearch_PointXYZI(OctreePointCloud_PointXYZI):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZI_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZI_t*> new pcloct.OctreePointCloudSearch_PointXYZI_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZI_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZI_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point2_t(point))
+
+cdef class OctreePointCloudSearch_PointXYZRGB(OctreePointCloud_PointXYZRGB):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZRGB_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGB_t*> new pcloct.OctreePointCloudSearch_PointXYZRGB_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZRGB_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloudSearch_PointXYZRGBA(OctreePointCloud_PointXYZRGBA):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZRGBA_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGBA_t*> new pcloct.OctreePointCloudSearch_PointXYZRGBA_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZRGBA_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloudSearch_180.pxi b/pcl/pxi/Octree/OctreePointCloudSearch_180.pxi
new file mode 100644
index 0000000..13f1941
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloudSearch_180.pxi
@@ -0,0 +1,468 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_180 as pcloct
+
+# include "PointXYZtoPointXYZ.pxi" --> multiple define ng
+# include "OctreePointCloud.pxi"
+
+cdef class OctreePointCloudSearch(OctreePointCloud):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_t*> new pcloct.OctreePointCloudSearch_t(resolution)
+        self.me = <pcloct.OctreePointCloud_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    # nearestKSearch
+    ###
+    def nearest_k_search_for_cloud(self, PointCloud pc not None, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for all points
+        in the pointcloud. Results are in ndarrays, size (pc.size, k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.npy_intp n_points = pc.size
+        cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+                                                          dtype=np.float32)
+        cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+                                                     dtype=np.int32)
+
+        for i in range(n_points):
+            self._nearest_k(pc, i, k, ind[i], sqdist[i])
+        return ind, sqdist
+
+    def nearest_k_search_for_point(self, PointCloud pc not None, int index, int k=1):
+        """
+        Find the k nearest neighbours and squared distances for the point
+        at pc[index]. Results are in ndarrays, size (k)
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef cnp.ndarray[float] sqdist = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] ind = np.zeros(k, dtype=np.int32)
+
+        self._nearest_k(pc, index, k, ind, sqdist)
+        return ind, sqdist
+
+    @cython.boundscheck(False)
+    cdef void _nearest_k(self, PointCloud pc, int index, int k,
+                         cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+                         cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+                        ) except +:
+        # k nearest neighbors query for a single point.
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        k_indices.resize(k)
+        k_sqr_distances.resize(k)
+        # self.me.nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+        (<pcloct.OctreePointCloudSearch_t*>self.me).nearestKSearch(pc.thisptr()[0], index, k, k_indices, k_sqr_distances)
+
+        for i in range(k):
+            sqdist[i] = k_sqr_distances[i]
+            ind[i] = k_indices[i]
+
+    ###
+
+    # radius Search
+    ###
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+        
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(to_point_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    ###
+
+    # Voxel Search
+    ### 
+    def VoxelSearch (self, PointCloud pc):
+        """
+        Search for all neighbors of query point that are within a given voxel.
+        
+        Returns: (v_indices)
+        """
+        cdef vector[int] v_indices
+        # cdef bool isVexelSearch = (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(pc.thisptr()[0], v_indices)
+        # self._VoxelSearch(pc, v_indices)
+        result = pc.to_array()
+        cdef cpp.PointXYZ point
+        point.x = result[0, 0]
+        point.y = result[0, 1]
+        point.z = result[0, 2]
+        
+        print ('VoxelSearch at (' + str(point.x) + ' ' + str(point.y) + ' ' + str(point.z) + ')')
+        
+        # print('before v_indices count = ' + str(v_indices.size()))
+        self._VoxelSearch(point, v_indices)
+        v = v_indices.size()
+        # print('after v_indices count = ' + str(v))
+        
+        cdef cnp.ndarray[int] np_v_indices = np.zeros(v, dtype=np.int32)
+        for i in range(v):
+            np_v_indices[i] = v_indices[i]
+        
+        return np_v_indices
+
+    @cython.boundscheck(False)
+    cdef void _VoxelSearch(self, cpp.PointXYZ point, vector[int] &v_indices) except +:
+        cdef vector[int] voxel_indices
+        # k = 10
+        # voxel_indices.resize(k)
+        (<pcloct.OctreePointCloudSearch_t*>self.me).voxelSearch(point, voxel_indices)
+        
+        # print('_VoxelSearch k = ' + str(k))
+        # print('_VoxelSearch voxel_indices = ' + str(voxel_indices.size()))
+        k = voxel_indices.size()
+        
+        for i in range(k):
+            v_indices.push_back(voxel_indices[i])
+
+    ### 
+
+
+#     def radius_search_for_cloud(self, PointCloud pc not None, double radius):
+#         """
+#         Find the radius and squared distances for all points
+#         in the pointcloud. Results are in ndarrays, size (pc.size, k)
+#         Returns: (radius_indices, radius_distances)
+#         """
+#         k = 10
+#         cdef cnp.npy_intp n_points = pc.size
+#         cdef cnp.ndarray[float, ndim=2] sqdist = np.zeros((n_points, k),
+#                                                           dtype=np.float32)
+#         cdef cnp.ndarray[int, ndim=2] ind = np.zeros((n_points, k),
+#                                                      dtype=np.int32)
+# 
+#         for i in range(n_points):
+#             self._search_radius(pc, i, k, radius, ind[i], sqdist[i])
+#         return ind, sqdist
+# 
+#     @cython.boundscheck(False)
+#     cdef void _search_radius(self, PointCloud pc, int index, int k, double radius,
+#                          cnp.ndarray[ndim=1, dtype=int, mode='c'] ind,
+#                          cnp.ndarray[ndim=1, dtype=float, mode='c'] sqdist
+#                         ) except +:
+#         # radius query for a single point.
+#         cdef vector[int] radius_indices
+#         cdef vector[float] radius_distances
+#         radius_indices.resize(k)
+#         radius_distances.resize(k)
+#         # self.me.radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances)
+#         k = (<pcloct.OctreePointCloudSearch_t*>self.me).radiusSearch(pc.thisptr()[0], index, radius, radius_indices, radius_distances, 10)
+# 
+#         for i in range(k):
+#             sqdist[i] = radius_distances[i]
+#             ind[i] = radius_indices[i]
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point_t(point))
+
+
+cdef class OctreePointCloudSearch_PointXYZI(OctreePointCloud_PointXYZI):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZI_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZI_t*> new pcloct.OctreePointCloudSearch_PointXYZI_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZI_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZI_t*>self.me).radiusSearch(to_point2_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZI_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point2_t(point))
+
+cdef class OctreePointCloudSearch_PointXYZRGB(OctreePointCloud_PointXYZRGB):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZRGB_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGB_t*> new pcloct.OctreePointCloudSearch_PointXYZRGB_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZRGB_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGB_t*>self.me).radiusSearch(to_point3_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloudSearch_PointXYZRGBA(OctreePointCloud_PointXYZRGBA):
+    """
+    Octree pointcloud search
+    """
+    cdef pcloct.OctreePointCloudSearch_PointXYZRGBA_t *me2
+
+    def __cinit__(self, double resolution):
+        """
+        Constructs octree pointcloud with given resolution at lowest octree level
+        """ 
+        self.me2 = NULL
+        self.me = NULL
+        if resolution <= 0.:
+            raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+        self.me2 = <pcloct.OctreePointCloudSearch_PointXYZRGBA_t*> new pcloct.OctreePointCloudSearch_PointXYZRGBA_t(resolution)
+        self.me = <pcloct.OctreePointCloud_PointXYZRGBA_t*> self.me2
+
+    def __dealloc__(self):
+        del self.me2
+        self.me2 = NULL
+        self.me = NULL
+
+    def radius_search (self, point, double radius, unsigned int max_nn = 0):
+        """
+        Search for all neighbors of query point that are within a given radius.
+
+        Returns: (k_indices, k_sqr_distances)
+        """
+        cdef vector[int] k_indices
+        cdef vector[float] k_sqr_distances
+        if max_nn > 0:
+            k_indices.resize(max_nn)
+            k_sqr_distances.resize(max_nn)
+        cdef int k = (<pcloct.OctreePointCloudSearch_PointXYZRGBA_t*>self.me).radiusSearch(to_point4_t(point), radius, k_indices, k_sqr_distances, max_nn)
+        cdef cnp.ndarray[float] np_k_sqr_distances = np.zeros(k, dtype=np.float32)
+        cdef cnp.ndarray[int] np_k_indices = np.zeros(k, dtype=np.int32)
+        for i in range(k):
+            np_k_sqr_distances[i] = k_sqr_distances[i]
+            np_k_indices[i] = k_indices[i]
+        return np_k_indices, np_k_sqr_distances
+
+    # base OctreePointCloud
+    def define_bounding_box(self):
+        """
+        Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+        """
+        self.me2.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me2.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    def add_points_from_input_cloud(self):
+        """
+        Add points from input point cloud to octree.
+        """
+        self.me2.addPointsFromInputCloud()
+
+    def is_voxel_occupied_at_point(self, point):
+        """
+        Check if voxel at given point coordinates exist.
+        """
+        return self.me2.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    def get_occupied_voxel_centers(self):
+        """
+        Get list of centers of all occupied voxels.
+        """
+        cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+        cdef int num = self.me2.getOccupiedVoxelCenters (points_v)
+        return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    def delete_voxel_at_point(self, point):
+        """
+        Delete leaf node / voxel at given point.
+        """
+        self.me2.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloud_172.pxi b/pcl/pxi/Octree/OctreePointCloud_172.pxi
new file mode 100644
index 0000000..948dc85
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloud_172.pxi
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_172 as pcloct
+
+cimport eigen as eig
+
+cdef class OctreePointCloud:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_t(0)
+    #     # self.me = new pcloct.OctreePointCloud_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+        
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     self.me.deleteVoxelAtPoint(to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(deref(self.me), to_point_t(point))
+
+
+cdef class OctreePointCloud_PointXYZI:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZI_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZI pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZI_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_PointXYZI_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters_PointXYZI(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (use minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint_PointXYZI(deref(self.me), to_point2_t(point))
+
+
+cdef class OctreePointCloud_PointXYZRGB:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZRGB_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_PointXYZRGB_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGB_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGB_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGB pc not None):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloud_PointXYZRGBA:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZRGBA_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGBA pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # use NG
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/Octree/OctreePointCloud_180.pxi b/pcl/pxi/Octree/OctreePointCloud_180.pxi
new file mode 100644
index 0000000..fb4dbeb
--- /dev/null
+++ b/pcl/pxi/Octree/OctreePointCloud_180.pxi
@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_octree_180 as pcloct
+
+cimport eigen as eig
+
+cdef class OctreePointCloud:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_t(0)
+    #     # self.me = new pcloct.OctreePointCloud_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+        
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     self.me.deleteVoxelAtPoint(to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point_t(point))
+    #     # mpcl_deleteVoxelAtPoint(deref(self.me), to_point_t(point))
+
+
+cdef class OctreePointCloud_PointXYZI:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZI_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZI_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZI pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZI_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = self.me.getOccupiedVoxelCenters (<eig.AlignedPointTVector_PointXYZI_t> points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters_PointXYZI(deref(self.me), points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (use minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint(self.me, to_point2_t(point))
+    #     # mpcl_deleteVoxelAtPoint_PointXYZI(deref(self.me), to_point2_t(point))
+
+
+cdef class OctreePointCloud_PointXYZRGB:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZRGB_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_PointXYZRGB_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGB_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGB_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGB pc not None):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGB_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point3_t(point))
+
+
+cdef class OctreePointCloud_PointXYZRGBA:
+    """
+    Octree pointcloud
+    """
+    cdef pcloct.OctreePointCloud_PointXYZRGBA_t *me
+
+    # def __cinit__(self, double resolution):
+    #     self.me = NULL
+    #     if resolution <= 0.:
+    #         raise ValueError("Expected resolution > 0., got %r" % resolution)
+
+    # NG(BUild Error)
+    # def __init__(self, double resolution):
+    #     """
+    #     Constructs octree pointcloud with given resolution at lowest octree level
+    #     """ 
+    #     cdef double param = 0
+    #     self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t(param)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t(resolution)
+    #     # self.me = new pcloct.OctreePointCloud_PointXYZRGBA_t()
+
+    # def __dealloc__(self):
+    #     del self.me
+    #     self.me = NULL      # just to be sure
+
+    def set_input_cloud(self, PointCloud_PointXYZRGBA pc):
+        """
+        Provide a pointer to the input data set.
+        """
+        self.me.setInputCloud(pc.thisptr_shared)
+
+    # def define_bounding_box(self):
+    #     """
+    #     Investigate dimensions of pointcloud data set and define corresponding bounding box for octree. 
+    #     """
+    #     self.me.defineBoundingBox()
+
+    # def define_bounding_box(self, double min_x, double min_y, double min_z, double max_x, double max_y, double max_z):
+    #     """
+    #     Define bounding box for octree. Bounding box cannot be changed once the octree contains elements.
+    #     """
+    #     self.me.defineBoundingBox(min_x, min_y, min_z, max_x, max_y, max_z)
+
+    # use NG
+    # def add_points_from_input_cloud(self):
+    #     """
+    #     Add points from input point cloud to octree.
+    #     """
+    #     self.me.addPointsFromInputCloud()
+
+    def delete_tree(self):
+        """
+        Delete the octree structure and its leaf nodes.
+        """
+        self.me.deleteTree()
+
+    # def is_voxel_occupied_at_point(self, point):
+    #     """
+    #     Check if voxel at given point coordinates exist.
+    #     """
+    #     return self.me.isVoxelOccupiedAtPoint(point[0], point[1], point[2])
+
+    # def get_occupied_voxel_centers(self):
+    #     """
+    #     Get list of centers of all occupied voxels.
+    #     """
+    #     cdef eig.AlignedPointTVector_PointXYZRGBA_t points_v
+    #     cdef int num = self.me.getOccupiedVoxelCenters (points_v)
+    #     # cdef int num = mpcl_getOccupiedVoxelCenters(self.me, points_v)
+    #     return [(points_v[i].x, points_v[i].y, points_v[i].z) for i in range(num)]
+
+    # def delete_voxel_at_point(self, point):
+    #     """
+    #     Delete leaf node / voxel at given point.
+    #     """
+    #     # NG (minipcl?)
+    #     self.me.deleteVoxelAtPoint(to_point4_t(point))
+
+
diff --git a/pcl/pxi/PointCloud_FPFHSignature33.pxi b/pcl/pxi/PointCloud_FPFHSignature33.pxi
new file mode 100644
index 0000000..58e98df
--- /dev/null
+++ b/pcl/pxi/PointCloud_FPFHSignature33.pxi
@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+# main
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+cimport pcl_kdtree as pclkdt
+cimport pcl_octree as pcloct
+cimport pcl_sample_consensus as pcl_sc
+# cimport pcl_search as pcl_sch
+cimport pcl_segmentation as pclseg
+cimport pcl_surface as pclsf
+cimport pcl_range_image as pcl_r_img
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef class PointCloud_FPFHSignature33:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 3
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZ *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZ *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.PointXYZ* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
diff --git a/pcl/pxi/PointCloud_Normal.pxi b/pcl/pxi/PointCloud_Normal.pxi
new file mode 100644
index 0000000..ee73c79
--- /dev/null
+++ b/pcl/pxi/PointCloud_Normal.pxi
@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_Normal
+
+cdef class PointCloud_Normal:
+    """
+    Represents a cloud of points in 4-d space.
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 4), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_Normal other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.Normal]]> self.thisptr_shared, new cpp.PointCloud[cpp.Normal]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.Normal]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.Normal *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.normal_x, p.normal_y, p.normal_z, p.curvature = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.Normal *p
+        
+        result = np.empty((n, 4), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.normal_x
+            result[i, 1] = p.normal_y
+            result[i, 2] = p.normal_z
+            result[i, 3] = p.curvature
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.Normal* p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.normal_x, p.normal_y, p.normal_z, p.curvature = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.Normal *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.normal_x, p.normal_y, p.normal_z, p.curvature
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.Normal *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.normal_x, p.normal_y, p.normal_z, p.curvature
+
+    # def extract(self, pyindices, bool negative=False):
+    #     """
+    #     Given a list of indices of points in the pointcloud, return a 
+    #     new pointcloud containing only those points.
+    #     """
+    #     cdef PointCloud_Normal result
+    #     cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+    #     
+    #     for i in pyindices:
+    #         ind.indices.push_back(i)
+    #     
+    #     result = PointCloud_Normal()
+    #     # (<cpp.PointCloud[cpp.Normal]> deref(self.thisptr())
+    #     mpcl_extract_Normal(self.thisptr_shared, result.thisptr(), ind, negative)
+    #     # XXX are we leaking memory here? del ind causes a double free...
+    #     
+    #     return result
+
+###
+
diff --git a/pcl/pxi/PointCloud_PCLPointCloud2.pxi b/pcl/pxi/PointCloud_PCLPointCloud2.pxi
new file mode 100644
index 0000000..a2a3bbb
--- /dev/null
+++ b/pcl/pxi/PointCloud_PCLPointCloud2.pxi
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# 
+cimport pcl_PCLPointCloud2_172 as pcl_pc2
+
+# parts
+cimport pcl_common_172 as pcl_cmn
+cimport pcl_features_172 as pclftr
+cimport pcl_filters_172 as pclfil
+cimport pcl_io_172 as pclio
+cimport pcl_kdtree_172 as pclkdt
+cimport pcl_octree_172 as pcloct
+cimport pcl_sample_consensus_172 as pcl_sc
+# cimport pcl_search_172 as pcl_sch
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_surface_172 as pclsf
+cimport pcl_range_image_172 as pcl_r_img
+cimport pcl_registration_172 as pcl_reg
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "ProjectInliers.h":
+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+# cdef Py_ssize_t _strides_pointcloud2[2]
+# cdef PointCloud2 _pc_tmp_pointcloud2 = PointCloud2(np.array([[1, 2, 3],
+#                                                [4, 5, 6]], dtype=np.float32))
+# 
+# cdef cpp.PointCloud[pcl_pc2.PCLPointCloud2] *p_pointcloud2 = _pc_tmp_pointcloud2.thisptr()
+# _strides_pointcloud2[0] = (  <Py_ssize_t><void *>idx.getptr(p_pointcloud2, 1)
+#                - <Py_ssize_t><void *>idx.getptr(p_pointcloud2, 0))
+# _strides_pointcloud2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_pointcloud2, 0).y)
+#                - <Py_ssize_t><void *>&(idx.getptr(p_pointcloud2, 0).x))
+# _pc_tmp_pointcloud2 = None
+
+cdef class PCLPointCloud2:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    cdef pcl_pc2.PointCloud_PCLPointCloud2Ptr_t thisptr_shared     # XYZ
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[pcl_pc2.PCLPointCloud2] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PCLPointCloud2>.
+        return self.thisptr_shared.get()
+
+    def __cinit__(self, init=None):
+        cdef PCLPointCloud2 other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[pcl_pc2.PCLPointCloud2]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        # buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        # buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 3
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef pcl_pc2.PCLPointCloud2 *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            # p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+            # bit shift(4byte separate 1byte)
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef pcl_pc2.PCLPointCloud2 *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            pass
+            # p = idx.getptr(self.thisptr(), i)
+            # bit shift
+            result[i, 0] = p.data[i * 12 + 0 * 4 + 0] + p.data[i * 12 + 0 * 4 + 1] + p.data[i * 12 + 0 * 4 + 2] + p.data[i * 12 + 0 * 4 + 3]
+            result[i, 1] = p.data[i * 12 + 1 * 4 + 0] + p.data[i * 12 + 1 * 4 + 1] + p.data[i * 12 + 1 * 4 + 2] + p.data[i * 12 + 1 * 4 + 3]
+            result[i, 2] = p.data[i * 12 + 2 * 4 + 0] + p.data[i * 12 + 2 * 4 + 1] + p.data[i * 12 + 2 * 4 + 2] + p.data[i * 12 + 2 * 4 + 3]
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef pcl_pc2.PCLPointCloud2* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+            pass
+            # p = idx.getptr(self.thisptr(), <int> i)
+            # p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        # cdef pcl_pc2.PCLPointCloud2 *p = idx.getptr_at2(self.thisptr(), row, col)
+        # return p.x, p.y, p.z
+        return 0.0, 0.0, 0.0
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        # cdef pcl_pc2.PCLPointCloud2 *p = idx.getptr_at(self.thisptr(), nmidx)
+        # return p.x, p.y, p.z
+        return 0.0, 0.0, 0.0
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[pcl_pc2.PCLPointCloud2]> deref(self.thisptr()))
+            # error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            pass
+        
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[pcl_pc2.PCLPointCloud2]> deref(self.thisptr()))
+            # ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            pass
+        
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # OK
+            # error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            pass
+        
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            pass
+        
+        return error
+
+    # def copyPointCloud(self, vector[int] indices):
+    #     cloud_out = PointCloud()
+    #     # NG : Function Override Error
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](self.thisptr_shared, <vector[int]> indices, <cpp.shared_ptr[cpp.PointCloud[pcl_pc2.PCLPointCloud2]]> cloud_out.thisptr_shared)
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](self.thisptr_shared.get(), <vector[int]> indices, cloud_out.thisptr_shared.get())
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](self.thisptr_shared.get(), <const vector[int]> &indices, deref(cloud_out.thisptr_shared.get()))
+    #     pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](<const shared_ptr[PointCloud[PointCloud2]]> self.thisptr_shared, <const vector[int]> &indices, deref(cloud_out.thisptr_shared))
+    #     
+    #     return cloud_out
+
+
+###
+
diff --git a/pcl/pxi/PointCloud_PCLPointCloud2_180.pxi b/pcl/pxi/PointCloud_PCLPointCloud2_180.pxi
new file mode 100644
index 0000000..6c3dd29
--- /dev/null
+++ b/pcl/pxi/PointCloud_PCLPointCloud2_180.pxi
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# 
+cimport pcl_PCLPointCloud2_180 as pcl_pc2
+
+# parts
+cimport pcl_common_180 as pcl_cmn
+cimport pcl_features_180 as pclftr
+cimport pcl_filters_180 as pclfil
+cimport pcl_io_180 as pclio
+cimport pcl_kdtree_180 as pclkdt
+cimport pcl_octree_180 as pcloct
+cimport pcl_sample_consensus_180 as pcl_sc
+# cimport pcl_search_180 as pcl_sch
+cimport pcl_segmentation_180 as pclseg
+cimport pcl_surface_180 as pclsf
+cimport pcl_range_image_180 as pcl_r_img
+cimport pcl_registration_180 as pcl_reg
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "ProjectInliers.h":
+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+# cdef Py_ssize_t _strides_pointcloud2[2]
+# cdef PointCloud2 _pc_tmp_pointcloud2 = PointCloud2(np.array([[1, 2, 3],
+#                                                [4, 5, 6]], dtype=np.float32))
+# 
+# cdef cpp.PointCloud[pcl_pc2.PCLPointCloud2] *p_pointcloud2 = _pc_tmp_pointcloud2.thisptr()
+# _strides_pointcloud2[0] = (  <Py_ssize_t><void *>idx.getptr(p_pointcloud2, 1)
+#                - <Py_ssize_t><void *>idx.getptr(p_pointcloud2, 0))
+# _strides_pointcloud2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_pointcloud2, 0).y)
+#                - <Py_ssize_t><void *>&(idx.getptr(p_pointcloud2, 0).x))
+# _pc_tmp_pointcloud2 = None
+
+cdef class PCLPointCloud2:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    cdef pcl_pc2.PointCloud_PCLPointCloud2Ptr_t thisptr_shared     # XYZ
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[pcl_pc2.PCLPointCloud2] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PCLPointCloud2>.
+        return self.thisptr_shared.get()
+
+    def __cinit__(self, init=None):
+        cdef PCLPointCloud2 other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[pcl_pc2.PCLPointCloud2]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        # buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        # buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 3
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef pcl_pc2.PCLPointCloud2 *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            # p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+            # bit shift(4byte separate 1byte)
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef pcl_pc2.PCLPointCloud2 *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            pass
+            # p = idx.getptr(self.thisptr(), i)
+            # bit shift
+            result[i, 0] = p.data[i * 12 + 0 * 4 + 0] + p.data[i * 12 + 0 * 4 + 1] + p.data[i * 12 + 0 * 4 + 2] + p.data[i * 12 + 0 * 4 + 3]
+            result[i, 1] = p.data[i * 12 + 1 * 4 + 0] + p.data[i * 12 + 1 * 4 + 1] + p.data[i * 12 + 1 * 4 + 2] + p.data[i * 12 + 1 * 4 + 3]
+            result[i, 2] = p.data[i * 12 + 2 * 4 + 0] + p.data[i * 12 + 2 * 4 + 1] + p.data[i * 12 + 2 * 4 + 2] + p.data[i * 12 + 2 * 4 + 3]
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef pcl_pc2.PCLPointCloud2* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+            pass
+            # p = idx.getptr(self.thisptr(), <int> i)
+            # p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        # cdef pcl_pc2.PCLPointCloud2 *p = idx.getptr_at2(self.thisptr(), row, col)
+        # return p.x, p.y, p.z
+        return 0.0, 0.0, 0.0
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        # cdef pcl_pc2.PCLPointCloud2 *p = idx.getptr_at(self.thisptr(), nmidx)
+        # return p.x, p.y, p.z
+        return 0.0, 0.0, 0.0
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[pcl_pc2.PCLPointCloud2]> deref(self.thisptr()))
+            # error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            pass
+        
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[pcl_pc2.PCLPointCloud2]> deref(self.thisptr()))
+            # ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            pass
+        
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # OK
+            # error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            pass
+        
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            pass
+        
+        return error
+
+    # def copyPointCloud(self, vector[int] indices):
+    #     cloud_out = PointCloud()
+    #     # NG : Function Override Error
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](self.thisptr_shared, <vector[int]> indices, <cpp.shared_ptr[cpp.PointCloud[pcl_pc2.PCLPointCloud2]]> cloud_out.thisptr_shared)
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](self.thisptr_shared.get(), <vector[int]> indices, cloud_out.thisptr_shared.get())
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](self.thisptr_shared.get(), <const vector[int]> &indices, deref(cloud_out.thisptr_shared.get()))
+    #     pcl_cmn.copyPointCloud_Indices [pcl_pc2.PCLPointCloud2](<const shared_ptr[PointCloud[PointCloud2]]> self.thisptr_shared, <const vector[int]> &indices, deref(cloud_out.thisptr_shared))
+    #     
+    #     return cloud_out
+
+
+###
+
diff --git a/pcl/pxi/PointCloud_PointCloud2.pxi b/pcl/pxi/PointCloud_PointCloud2.pxi
new file mode 100644
index 0000000..d10daf3
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointCloud2.pxi
@@ -0,0 +1,321 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# 
+cimport pcl_PointCloud2_160 as pcl_pc2
+
+# parts
+cimport pcl_common as pcl_cmn
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+cimport pcl_kdtree as pclkdt
+cimport pcl_octree as pcloct
+cimport pcl_sample_consensus as pcl_sc
+# cimport pcl_search as pcl_sch
+cimport pcl_segmentation as pclseg
+cimport pcl_surface as pclsf
+cimport pcl_range_image as pcl_r_img
+cimport pcl_registration_160 as pcl_reg
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "ProjectInliers.h":
+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+# cdef Py_ssize_t _strides_pointcloud2[2]
+# cdef PointCloud2 _pc_tmp_pointcloud2 = PointCloud2(np.array([[1, 2, 3],
+#                                                [4, 5, 6]], dtype=np.float32))
+# 
+# cdef cpp.PointCloud[pcl_pc2.PointCloud2] *p_pointcloud2 = _pc_tmp_pointcloud2.thisptr()
+# _strides_pointcloud2[0] = (  <Py_ssize_t><void *>idx.getptr(p_pointcloud2, 1)
+#                - <Py_ssize_t><void *>idx.getptr(p_pointcloud2, 0))
+# _strides_pointcloud2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_pointcloud2, 0).y)
+#                - <Py_ssize_t><void *>&(idx.getptr(p_pointcloud2, 0).x))
+# _pc_tmp_pointcloud2 = None
+
+cdef class PointCloud2:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    cdef pcl_pc2.PointCloud_PointCloud2Ptr_t thisptr_shared     # XYZ
+    
+    # Buffer protocol support.
+    cdef Py_ssize_t _shape[2]
+    cdef Py_ssize_t _view_count
+    
+    cdef inline cpp.PointCloud[pcl_pc2.PointCloud2] *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PointCloud<PointCloud2>.
+        return self.thisptr_shared.get()
+
+    def __cinit__(self, init=None):
+        cdef PointCloud2 other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[pcl_pc2.PointCloud2]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud2 from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        # buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        # buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 3
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef pcl_pc2.PointCloud2 *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            # p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+            # bit shift(4byte separate 1byte)
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 0]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 1]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+            # = arr[i, 2]
+            # p.data.push_back()
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef pcl_pc2.PointCloud2 *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            pass
+            # p = idx.getptr(self.thisptr(), i)
+            # bit shift
+            result[i, 0] = p.data[i * 12 + 0 * 4 + 0] + p.data[i * 12 + 0 * 4 + 1] + p.data[i * 12 + 0 * 4 + 2] + p.data[i * 12 + 0 * 4 + 3]
+            result[i, 1] = p.data[i * 12 + 1 * 4 + 0] + p.data[i * 12 + 1 * 4 + 1] + p.data[i * 12 + 1 * 4 + 2] + p.data[i * 12 + 1 * 4 + 3]
+            result[i, 2] = p.data[i * 12 + 2 * 4 + 0] + p.data[i * 12 + 2 * 4 + 1] + p.data[i * 12 + 2 * 4 + 2] + p.data[i * 12 + 2 * 4 + 3]
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef pcl_pc2.PointCloud2* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+            pass
+            # p = idx.getptr(self.thisptr(), <int> i)
+            # p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        # cdef pcl_pc2.PointCloud2 *p = idx.getptr_at2(self.thisptr(), row, col)
+        # return p.x, p.y, p.z
+        return 0.0, 0.0, 0.0
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        # cdef pcl_pc2.PointCloud2 *p = idx.getptr_at(self.thisptr(), nmidx)
+        # return p.x, p.y, p.z
+        return 0.0, 0.0, 0.0
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[pcl_pc2.PointCloud2]> deref(self.thisptr()))
+            # error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            pass
+        
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[pcl_pc2.PointCloud2]> deref(self.thisptr()))
+            # ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            pass
+        
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # OK
+            # error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            pass
+        
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            pass
+        
+        return error
+
+    # def copyPointCloud(self, vector[int] indices):
+    #     cloud_out = PointCloud()
+    #     # NG : Function Override Error
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PointCloud2](self.thisptr_shared, <vector[int]> indices, <cpp.shared_ptr[cpp.PointCloud[pcl_pc2.PointCloud2]]> cloud_out.thisptr_shared)
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PointCloud2](self.thisptr_shared.get(), <vector[int]> indices, cloud_out.thisptr_shared.get())
+    #     # pcl_cmn.copyPointCloud_Indices [pcl_pc2.PointCloud2](self.thisptr_shared.get(), <const vector[int]> &indices, deref(cloud_out.thisptr_shared.get()))
+    #     pcl_cmn.copyPointCloud_Indices [pcl_pc2.PointCloud2](<const shared_ptr[PointCloud[PointCloud2]]> self.thisptr_shared, <const vector[int]> &indices, deref(cloud_out.thisptr_shared))
+    #     
+    #     return cloud_out
+
+
+###
+
diff --git a/pcl/pxi/PointCloud_PointNormal.pxi b/pcl/pxi/PointCloud_PointNormal.pxi
new file mode 100644
index 0000000..4a31cca
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointNormal.pxi
@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointNormal
+
+cdef class PointCloud_PointNormal:
+    """
+    Represents a cloud of points in 4-d space.
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 4), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointNormal other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointNormal]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointNormal]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointNormal]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 7
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointNormal *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5], arr[i, 6]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointNormal *p
+        
+        result = np.empty((n, 7), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.normal_x
+            result[i, 4] = p.normal_y
+            result[i, 5] = p.normal_z
+            result[i, 6] = p.curvature
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointNormal* p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointNormal *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointNormal *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.normal_x, p.normal_y, p.normal_z, p.curvature
+
+    # def extract(self, pyindices, bool negative=False):
+    #     """
+    #     Given a list of indices of points in the pointcloud, return a 
+    #     new pointcloud containing only those points.
+    #     """
+    #     cdef PointCloud_PointNormal result
+    #     cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+    #     
+    #     for i in pyindices:
+    #         ind.indices.push_back(i)
+    #     
+    #     result = PointCloud_PointNormal()
+    #     # (<cpp.PointCloud[cpp.PointNormal]> deref(self.thisptr())
+    #     mpcl_extract_Normal(self.thisptr_shared, result.thisptr(), ind, negative)
+    #     # XXX are we leaking memory here? del ind causes a double free...
+    #     
+    #     return result
+
+###
+
diff --git a/pcl/pxi/PointCloud_PointWithViewpoint.pxi b/pcl/pxi/PointCloud_PointWithViewpoint.pxi
new file mode 100644
index 0000000..25f4ff3
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointWithViewpoint.pxi
@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_io as pclio
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+
+cdef class PointCloud_PointWithViewpoint:
+    """
+    Represents a cloud of points in 6-d space.
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 6), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointWithViewpoint other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointWithViewpoint]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointWithViewpoint]())
+        # sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointWithViewpoint]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 6
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointWithViewpoint *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z = arr[i, 0], arr[i, 1], arr[i, 2], arr[i, 3], arr[i, 4], arr[i, 5]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointWithViewpoint *p
+        
+        result = np.empty((n, 6), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.vp_x
+            result[i, 3] = p.vp_y
+            result[i, 3] = p.vp_z
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 6-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointWithViewpoint* p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+
+    def to_list(self):
+        """
+        Return this object as a list of 6-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (6-tuple) at the given row/column
+        """
+        cdef cpp.PointWithViewpoint *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointWithViewpoint *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.vp_x, p.vp_y, p.vp_z
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """
+        Save pointcloud to a file in PCD format.
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+###
+
diff --git a/pcl/pxi/PointCloud_PointXYZ.pxi b/pcl/pxi/PointCloud_PointXYZ.pxi
new file mode 100644
index 0000000..45b6527
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZ.pxi
@@ -0,0 +1,556 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_common as pcl_cmn
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+cimport pcl_kdtree as pclkdt
+cimport pcl_octree as pcloct
+cimport pcl_sample_consensus as pcl_sc
+# cimport pcl_search as pcl_sch
+cimport pcl_segmentation as pclseg
+cimport pcl_surface as pclsf
+cimport pcl_range_image as pcl_r_img
+cimport pcl_registration_160 as pcl_reg
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,
+                              cpp.PointIndices_t *, bool) except +
+    ## void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_PointXYZ *) except +
+    # void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_t *) except +
+
+
+cdef extern from "ProjectInliers.h":
+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides[2]
+cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],
+                                               [4, 5, 6]], dtype=np.float32))
+
+cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()
+_strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)
+               - <Py_ssize_t><void *>idx.getptr(p, 0))
+_strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p, 0).x))
+_pc_tmp = None
+
+cdef class PointCloud:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 3
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZ *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZ *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.PointXYZ* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZ *p = idx.getptr_at2 [cpp.PointXYZ](self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
+    # def copyPointCloud(self, vector[int] indices):
+    #     cloud_out = PointCloud()
+    #     # NG : Function Override Error
+    #     # pcl_cmn.copyPointCloud_Indices [cpp.PointXYZ](self.thisptr_shared, <vector[int]> indices, <cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> cloud_out.thisptr_shared)
+    #     # pcl_cmn.copyPointCloud_Indices [cpp.PointXYZ](self.thisptr_shared.get(), <vector[int]> indices, cloud_out.thisptr_shared.get())
+    #     # pcl_cmn.copyPointCloud_Indices [cpp.PointXYZ](self.thisptr_shared.get(), <const vector[int]> &indices, deref(cloud_out.thisptr_shared.get()))
+    #     pcl_cmn.copyPointCloud_Indices [cpp.PointXYZ](<const shared_ptr[PointCloud[PointXYZ]]> self.thisptr_shared, <const vector[int]> &indices, deref(cloud_out.thisptr_shared))
+    #     
+    #     return cloud_out
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation()
+        cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_compute_normals(<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        seg = SegmentationNormal()
+        cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        # fil = StatisticalOutlierRemovalFilter()
+        # cdef pclfil.StatisticalOutlierRemoval_t *cfil = <pclfil.StatisticalOutlierRemoval_t *>fil.me
+        # cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return StatisticalOutlierRemovalFilter(self)
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter()
+        cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_ApproximateVoxelGrid(self):
+        """
+        Return a pcl.ApproximateVoxelGrid object with this object set as the input-cloud
+        """
+        fil = ApproximateVoxelGrid()
+        cdef pclfil.ApproximateVoxelGrid_t *cfil = <pclfil.ApproximateVoxelGrid_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter()
+        cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares()
+        cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree(self):
+        """
+        Return a pcl.kdTree object with this object set as the input-cloud
+        
+        Deprecated: use the pcl.KdTree constructor on this cloud.
+        """
+        return KdTree(self)
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN(self)
+
+    def make_octree(self, double resolution):
+        """
+        Return a pcl.octree object with this object set as the input-cloud
+        """
+        octree = OctreePointCloud(resolution)
+        octree.set_input_cloud(self)
+        return octree
+
+    def make_octreeSearch(self, double resolution):
+        """
+        Return a pcl.make_octreeSearch object with this object set as the input-cloud
+        """
+        octreeSearch = OctreePointCloudSearch(resolution)
+        octreeSearch.set_input_cloud(self)
+        return octreeSearch
+
+    # pcl 1.6.0 use ok
+    # cpl 1.7.2, 1.8.0 use ng(octree_pointcloud_changedetector.h(->octree_pointcloud.h) include headerfile comment octree2buf_base.h)
+    def make_octreeChangeDetector(self, double resolution):
+        """
+        Return a pcl.make_octreeSearch object with this object set as the input-cloud
+        """
+        octreeChangeDetector = OctreePointCloudChangeDetector(resolution)
+        octreeChangeDetector.set_input_cloud(self)
+        return octreeChangeDetector
+
+    def make_crophull(self):
+        """
+        Return a pcl.CropHull object with this object set as the input-cloud
+
+        Deprecated: use the pcl.Vertices constructor on this cloud.
+        """
+        return CropHull(self)
+
+    def make_cropbox(self):
+        """
+        Return a pcl.CropBox object with this object set as the input-cloud
+        Deprecated: use the pcl.Vertices constructor on this cloud.
+        """
+        return CropBox(self)
+
+    def make_IntegralImageNormalEstimation(self):
+        """
+        Return a pcl.IntegralImageNormalEstimation object with this object set as the input-cloud
+        Deprecated: use the pcl.Vertices constructor on this cloud.
+        """
+        return IntegralImageNormalEstimation(self)
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud()
+        # result = ExtractIndices()
+        # (<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr())
+        mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+
+    def make_ProjectInliers(self):
+        """
+        Return a pclfil.ProjectInliers object with this object set as the input-cloud
+        """
+        # proj = ProjectInliers()
+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me
+        # cproj.setInputCloud(self.thisptr_shared)
+        # return proj
+        # # cdef pclfil.ProjectInliers_t* projInliers
+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)
+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))
+        # # proj = ProjectInliers()
+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>projInliers
+        # cproj.setInputCloud(self.thisptr_shared)
+        # return proj
+        # # NG
+        # cdef pclfil.ProjectInliers_t* projInliers
+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)
+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))
+        # projInliers.setInputCloud(self.thisptr_shared)
+        # proj = ProjectInliers()
+        # proj.me = projInliers
+        # return proj
+        proj = ProjectInliers()
+        cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me
+        # mpcl_ProjectInliers_setModelCoefficients(cproj)
+        mpcl_ProjectInliers_setModelCoefficients(deref(cproj))
+        cproj.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return proj
+
+    def make_RadiusOutlierRemoval(self):
+        """
+        Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud
+        """
+        fil = RadiusOutlierRemoval()
+        cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_ConditionAnd(self):
+        """
+        Return a pcl.ConditionAnd object with this object set as the input-cloud
+        """
+        condAnd = ConditionAnd()
+        cdef pclfil.ConditionAnd_t *cCondAnd = <pclfil.ConditionAnd_t *>condAnd.me
+        return condAnd
+
+    def make_ConditionalRemoval(self, ConditionAnd range_conf):
+        """
+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+        """
+        condRemoval = ConditionalRemoval(range_conf)
+        cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me
+        cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return condRemoval
+
+    def make_ConcaveHull(self):
+        """
+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+        """
+        concaveHull = ConcaveHull()
+        cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me
+        cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return concaveHull
+
+    def make_HarrisKeypoint3D(self):
+        """
+        Return a pcl.PointCloud object with this object set as the input-cloud
+        """
+        harris = HarrisKeypoint3D(self)
+        # harris = HarrisKeypoint3D()
+        # cdef keypt.HarrisKeypoint3D_t *charris = <keypt.HarrisKeypoint3D_t *>harris.me
+        # charris.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return harris
+
+    def make_NormalEstimation(self):
+        normalEstimation = NormalEstimation()
+        cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me
+        cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return normalEstimation
+
+    def make_VFHEstimation(self):
+        vfhEstimation = VFHEstimation()
+        normalEstimation = self.make_NormalEstimation()
+        cloud_normals = normalEstimation.Compute()
+        # features
+        cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me
+        cVFHEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return vfhEstimation
+
+    def make_RangeImage(self):
+        rangeImages = RangeImages(self)
+        # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me
+        return rangeImages
+
+    def make_EuclideanClusterExtraction(self):
+        euclideanclusterextraction = EuclideanClusterExtraction(self)
+        cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me
+        cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return euclideanclusterextraction
+
+    def make_GeneralizedIterativeClosestPoint(self):
+        generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)
+        cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me
+        cGeneralizedIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return generalizedIterativeClosestPoint
+
+    def make_IterativeClosestPointNonLinear(self):
+        iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)
+        cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me
+        cIterativeClosestPointNonLinear.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return iterativeClosestPointNonLinear
+
+    def make_IterativeClosestPoint(self):
+        iterativeClosestPoint = IterativeClosestPoint(self)
+        cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me
+        cIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return iterativeClosestPoint
+
+
+###
+
diff --git a/pcl/pxi/PointCloud_PointXYZI.pxi b/pcl/pxi/PointCloud_PointXYZI.pxi
new file mode 100644
index 0000000..0d7496c
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZI.pxi
@@ -0,0 +1,382 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_common as pcl_cmn
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+cimport pcl_kdtree as pclkdt
+cimport pcl_octree as pcloct
+cimport pcl_sample_consensus as pcl_sc
+# cimport pcl_search as pcl_sch
+cimport pcl_segmentation as pclseg
+cimport pcl_surface as pclsf
+cimport pcl_range_image as pcl_r_img
+cimport pcl_registration_160 as pcl_reg
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZI
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZI(cpp.PointCloud_PointXYZI_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZI(pclseg.SACSegmentationNormal_PointXYZI_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZI(cpp.PointCloud_PointXYZI_Ptr_t, cpp.PointCloud_PointXYZI_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzi_4[2]
+cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],
+                                                                    [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+_strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 0))
+_strides_xyzi_4[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).x))
+_pc_xyzi_tmp4 = None
+
+cdef class PointCloud_PointXYZI:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 4), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZI other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides_xyzi_4
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZI *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.intensity = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZI *p
+        
+        result = np.empty((n, 4), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.intensity
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointXYZI* p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z, p.intensity = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZI *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.intensity
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZI *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.intensity
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZI] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZI()
+        cdef pclseg.SACSegmentation_PointXYZI_t *cseg = <pclseg.SACSegmentation_PointXYZI_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_compute_normals_PointXYZI(<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # p = self.thisptr()
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZI_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZI_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        fil = StatisticalOutlierRemovalFilter_PointXYZI()
+        cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter_PointXYZI()
+        cdef pclfil.VoxelGrid_PointXYZI_t *cfil = <pclfil.VoxelGrid_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter_PointXYZI()
+        cdef pclfil.PassThrough_PointXYZI_t *cfil = <pclfil.PassThrough_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+# Error(PointXYZI use?)
+#     def make_moving_least_squares(self):
+#         """
+#         Return a pcl.MovingLeastSquares object with this object as input cloud.
+#         """
+#         mls = MovingLeastSquares_PointXYZI()
+#         cdef pclsf.MovingLeastSquares_PointXYZI_t *cmls = <pclsf.MovingLeastSquares_PointXYZI_t *>mls.me
+#         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+#         return mls
+# 
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZI(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZI(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+# 
+#     def make_crophull(self):
+#         """
+#         Return a pcl.CropHull object with this object set as the input-cloud
+# 
+#         Deprecated: use the pcl.Vertices constructor on this cloud.
+#         """
+#         return CropHull(self)
+#         
+#     def make_cropbox(self):
+#         """
+#         Return a pcl.CropBox object with this object set as the input-cloud
+# 
+#         Deprecated: use the pcl.Vertices constructor on this cloud.
+#         """
+#         return CropBox(self)
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZI result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud_PointXYZI()
+        # (<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr())
+        mpcl_extract_PointXYZI(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
+
diff --git a/pcl/pxi/PointCloud_PointXYZI_172.pxi b/pcl/pxi/PointCloud_PointXYZI_172.pxi
new file mode 100644
index 0000000..89d829f
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZI_172.pxi
@@ -0,0 +1,378 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features_172 as pclftr
+cimport pcl_filters_172 as pclfil
+cimport pcl_io_172 as pclio
+cimport pcl_kdtree_172 as pclkdt
+cimport pcl_octree_172 as pcloct
+cimport pcl_sample_consensus_172 as pcl_sc
+# cimport pcl_search_172 as pcl_sch
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_surface_172 as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZI
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZI(cpp.PointCloud_PointXYZI_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZI(pclseg.SACSegmentationNormal_PointXYZI_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZI(cpp.PointCloud_PointXYZI_Ptr_t, cpp.PointCloud_PointXYZI_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzi_4[2]
+cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],
+                                                                    [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+_strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 0))
+_strides_xyzi_4[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).x))
+_pc_xyzi_tmp4 = None
+
+cdef class PointCloud_PointXYZI:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 4), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZI other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides_xyzi_4
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZI *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.intensity = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZI *p
+        
+        result = np.empty((n, 4), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.intensity
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointXYZI* p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z, p.intensity = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZI *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.intensity
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZI *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.intensity
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZI] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZI()
+        cdef pclseg.SACSegmentation_PointXYZI_t *cseg = <pclseg.SACSegmentation_PointXYZI_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_compute_normals_PointXYZI(<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # p = self.thisptr()
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZI_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZI_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        fil = StatisticalOutlierRemovalFilter_PointXYZI()
+        cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter_PointXYZI()
+        cdef pclfil.VoxelGrid_PointXYZI_t *cfil = <pclfil.VoxelGrid_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter_PointXYZI()
+        cdef pclfil.PassThrough_PointXYZI_t *cfil = <pclfil.PassThrough_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+# Error(PointXYZI use?)
+#     def make_moving_least_squares(self):
+#         """
+#         Return a pcl.MovingLeastSquares object with this object as input cloud.
+#         """
+#         mls = MovingLeastSquares_PointXYZI()
+#         cdef pclsf.MovingLeastSquares_PointXYZI_t *cmls = <pclsf.MovingLeastSquares_PointXYZI_t *>mls.me
+#         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+#         return mls
+# 
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZI(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZI(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+# 
+#     def make_crophull(self):
+#         """
+#         Return a pcl.CropHull object with this object set as the input-cloud
+# 
+#         Deprecated: use the pcl.Vertices constructor on this cloud.
+#         """
+#         return CropHull(self)
+#         
+#     def make_cropbox(self):
+#         """
+#         Return a pcl.CropBox object with this object set as the input-cloud
+# 
+#         Deprecated: use the pcl.Vertices constructor on this cloud.
+#         """
+#         return CropBox(self)
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZI result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud_PointXYZI()
+        # (<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr())
+        mpcl_extract_PointXYZI(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
+
diff --git a/pcl/pxi/PointCloud_PointXYZI_180.pxi b/pcl/pxi/PointCloud_PointXYZI_180.pxi
new file mode 100644
index 0000000..1f07c16
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZI_180.pxi
@@ -0,0 +1,378 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features_180 as pclftr
+cimport pcl_filters_180 as pclfil
+cimport pcl_io_180 as pclio
+cimport pcl_kdtree_180 as pclkdt
+# cimport pcl_octree_180 as pcloct
+# cimport pcl_sample_consensus_180 as pcl_sc
+# cimport pcl_search_180 as pcl_sch
+cimport pcl_segmentation_180 as pclseg
+cimport pcl_surface_180 as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZI
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZI(cpp.PointCloud_PointXYZI_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZI(pclseg.SACSegmentationNormal_PointXYZI_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZI(cpp.PointCloud_PointXYZI_Ptr_t, cpp.PointCloud_PointXYZI_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzi_4[2]
+cdef PointCloud_PointXYZI _pc_xyzi_tmp4 = PointCloud_PointXYZI(np.array([[1, 2, 3, 0],
+                                                                    [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZI] *p_xyzi_4 = _pc_xyzi_tmp4.thisptr()
+_strides_xyzi_4[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzi_4, 0))
+_strides_xyzi_4[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzi_4, 0).x))
+_pc_xyzi_tmp4 = None
+
+cdef class PointCloud_PointXYZI:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 4), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZI other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZI]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides_xyzi_4
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZI *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.intensity = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZI *p
+        
+        result = np.empty((n, 4), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.intensity
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointXYZI* p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z, p.intensity = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZI *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.intensity
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZI *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.intensity
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZI] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZI()
+        cdef pclseg.SACSegmentation_PointXYZI_t *cseg = <pclseg.SACSegmentation_PointXYZI_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_compute_normals_PointXYZI(<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # p = self.thisptr()
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZI_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZI_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        fil = StatisticalOutlierRemovalFilter_PointXYZI()
+        cdef pclfil.StatisticalOutlierRemoval_PointXYZI_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter_PointXYZI()
+        cdef pclfil.VoxelGrid_PointXYZI_t *cfil = <pclfil.VoxelGrid_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter_PointXYZI()
+        cdef pclfil.PassThrough_PointXYZI_t *cfil = <pclfil.PassThrough_PointXYZI_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+        return fil
+
+# Error(PointXYZI use?)
+#     def make_moving_least_squares(self):
+#         """
+#         Return a pcl.MovingLeastSquares object with this object as input cloud.
+#         """
+#         mls = MovingLeastSquares_PointXYZI()
+#         cdef pclsf.MovingLeastSquares_PointXYZI_t *cmls = <pclsf.MovingLeastSquares_PointXYZI_t *>mls.me
+#         cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZI]]> self.thisptr_shared)
+#         return mls
+# 
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZI(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZI(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+# 
+#     def make_crophull(self):
+#         """
+#         Return a pcl.CropHull object with this object set as the input-cloud
+# 
+#         Deprecated: use the pcl.Vertices constructor on this cloud.
+#         """
+#         return CropHull(self)
+#         
+#     def make_cropbox(self):
+#         """
+#         Return a pcl.CropBox object with this object set as the input-cloud
+# 
+#         Deprecated: use the pcl.Vertices constructor on this cloud.
+#         """
+#         return CropBox(self)
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZI result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud_PointXYZI()
+        # (<cpp.PointCloud[cpp.PointXYZI]> deref(self.thisptr())
+        mpcl_extract_PointXYZI(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
+
diff --git a/pcl/pxi/PointCloud_PointXYZRGB.pxi b/pcl/pxi/PointCloud_PointXYZRGB.pxi
new file mode 100644
index 0000000..e25fb9e
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZRGB.pxi
@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+cimport pcl_kdtree as pclkdt
+cimport pcl_octree as pcloct
+# cimport pcl_sample_consensus as pcl_sc
+# cimport pcl_search as pcl_sch
+cimport pcl_segmentation as pclseg
+cimport pcl_surface as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZRGB
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZRGB(cpp.PointCloud_PointXYZRGB_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZRGB(pclseg.SACSegmentationNormal_PointXYZRGB_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZRGB(cpp.PointCloud_PointXYZRGB_Ptr_t, cpp.PointCloud_PointXYZRGB_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzrgb_3[2]
+cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],
+                                                                          [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+_strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 0))
+_strides_xyzrgb_3[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).x))
+_pc_xyzrgb_tmp3 = None
+
+cdef class PointCloud_PointXYZRGB:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZRGB other
+
+        self._view_count = 0
+
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides_xyzrgb_3
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+
+        cdef cpp.PointXYZRGB *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.rgb = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZRGB *p
+
+        result = np.empty((n, 4), dtype=np.float32)
+
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.rgb
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointXYZRGB *p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        for i, l in enumerate(_list):
+            p = idx.getptr(self.thisptr(), <int> i)
+            p.x, p.y, p.z, p.rgb = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZRGB *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.rgb
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZRGB *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.rgb
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # error = cpp.loadPCDFile(string(s), p)
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # ok = cpp.loadPLYFile(string(s), p)
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGB] *
+            # error = cpp.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # error = cpp.savePLYFile(s, p, binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZRGB()
+        cdef pclseg.SACSegmentation_PointXYZRGB_t *cseg = <pclseg.SACSegmentation_PointXYZRGB_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        p = self.thisptr()
+        mpcl_compute_normals_PointXYZRGB(<cpp.PointCloud[cpp.PointXYZRGB]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZRGB_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGB_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        fil = StatisticalOutlierRemovalFilter_PointXYZRGB()
+        cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter_PointXYZRGB()
+        cdef pclfil.VoxelGrid_PointXYZRGB_t *cfil = <pclfil.VoxelGrid_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter_PointXYZRGB()
+        cdef pclfil.PassThrough_PointXYZRGB_t *cfil = <pclfil.PassThrough_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares_PointXYZRGB()
+        cdef pclsf.MovingLeastSquares_PointXYZRGB_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGB_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+        
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZRGB(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZRGB(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZRGB result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud_PointXYZRGB()
+        mpcl_extract_PointXYZRGB(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
diff --git a/pcl/pxi/PointCloud_PointXYZRGBA.pxi b/pcl/pxi/PointCloud_PointXYZRGBA.pxi
new file mode 100644
index 0000000..1449ef5
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZRGBA.pxi
@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+cimport pcl_kdtree as pclkdt
+cimport pcl_octree as pcloct
+# cimport pcl_sample_consensus as pcl_sc
+# cimport pcl_search as pcl_sch
+cimport pcl_segmentation as pclseg
+cimport pcl_surface as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZRGBA
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZRGBA(cpp.PointCloud_PointXYZRGBA_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZRGBA(pclseg.SACSegmentation_PointXYZRGBA_Normal_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZRGBA(cpp.PointCloud_PointXYZRGBA_Ptr_t, cpp.PointCloud_PointXYZRGBA_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzrgba_2[2]
+cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],
+                                                                          [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+_strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 0))
+_strides_xyzrgba_2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).x))
+_pc_xyzrgba_tmp2 = None
+
+cdef class PointCloud_PointXYZRGBA:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZRGBA other
+
+        self._view_count = 0
+
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+
+        cdef cpp.PointXYZRGBA *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.rgba = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZRGBA *p
+
+        result = np.empty((n, 4), dtype=np.float32)
+
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.rgba
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+       """
+       Fill this pointcloud from a list of 4-tuples
+       """
+       cdef Py_ssize_t npts = len(_list)
+       cdef cpp.PointXYZRGBA *p
+       self.resize(npts)
+       self.thisptr().width = npts
+       self.thisptr().height = 1
+       for i, l in enumerate(_list):
+           p = idx.getptr(self.thisptr(), <int> i)
+           p.x, p.y, p.z, p.rgba = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZRGBA *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.rgba
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZRGBA *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.rgba
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # error = cpp.loadPCDFile(string(s), p)
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # ok = cpp.loadPLYFile(string(s), p)
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGBA] *
+            # error = cpp.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # error = cpp.savePLYFile(s, p, binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZRGBA()
+        cdef pclseg.SACSegmentation_PointXYZRGBA_t *cseg = <pclseg.SACSegmentation_PointXYZRGBA_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        p = self.thisptr()
+        mpcl_compute_normals_PointXYZRGBA(<cpp.PointCloud[cpp.PointXYZRGBA]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZRGBA_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+         """
+         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+         """
+         fil = StatisticalOutlierRemovalFilter_PointXYZRGBA()
+         cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *>fil.me
+         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+         return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter()
+        cdef pclfil.VoxelGrid_PointXYZRGBA_t *cfil = <pclfil.VoxelGrid_PointXYZRGBA_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter()
+        cdef pclfil.PassThrough_PointXYZRGBA_t *cfil = <pclfil.PassThrough_PointXYZRGBA_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares_PointXYZRGBA()
+        cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGBA_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZRGBA(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZRGBA(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZRGBA result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        for i in pyindices:
+            ind.indices.push_back(i)
+        result = PointCloud_PointXYZRGBA()
+        mpcl_extract_PointXYZRGBA(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        return result
+###
diff --git a/pcl/pxi/PointCloud_PointXYZRGBA_172.pxi b/pcl/pxi/PointCloud_PointXYZRGBA_172.pxi
new file mode 100644
index 0000000..7464279
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZRGBA_172.pxi
@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features_172 as pclftr
+cimport pcl_filters_172 as pclfil
+cimport pcl_io_172 as pclio
+cimport pcl_kdtree_172 as pclkdt
+cimport pcl_octree_172 as pcloct
+# cimport pcl_sample_consensus_172 as pcl_sc
+# cimport pcl_search_172 as pcl_sch
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_surface_172 as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZRGBA
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZRGBA(cpp.PointCloud_PointXYZRGBA_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZRGBA(pclseg.SACSegmentation_PointXYZRGBA_Normal_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZRGBA(cpp.PointCloud_PointXYZRGBA_Ptr_t, cpp.PointCloud_PointXYZRGBA_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzrgba_2[2]
+cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],
+                                                                          [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+_strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 0))
+_strides_xyzrgba_2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).x))
+_pc_xyzrgba_tmp2 = None
+
+cdef class PointCloud_PointXYZRGBA:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZRGBA other
+
+        self._view_count = 0
+
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+
+        cdef cpp.PointXYZRGBA *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.rgba = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZRGBA *p
+
+        result = np.empty((n, 4), dtype=np.float32)
+
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.rgba
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+       """
+       Fill this pointcloud from a list of 4-tuples
+       """
+       cdef Py_ssize_t npts = len(_list)
+       cdef cpp.PointXYZRGBA *p
+       self.resize(npts)
+       self.thisptr().width = npts
+       self.thisptr().height = 1
+       for i, l in enumerate(_list):
+           p = idx.getptr(self.thisptr(), <int> i)
+           p.x, p.y, p.z, p.rgba = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZRGBA *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.rgba
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZRGBA *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.rgba
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # error = cpp.loadPCDFile(string(s), p)
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # ok = cpp.loadPLYFile(string(s), p)
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGBA] *
+            # error = cpp.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # error = cpp.savePLYFile(s, p, binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZRGBA()
+        cdef pclseg.SACSegmentation_PointXYZRGBA_t *cseg = <pclseg.SACSegmentation_PointXYZRGBA_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        p = self.thisptr()
+        mpcl_compute_normals_PointXYZRGBA(<cpp.PointCloud[cpp.PointXYZRGBA]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZRGBA_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+         """
+         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+         """
+         fil = StatisticalOutlierRemovalFilter_PointXYZRGBA()
+         cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *>fil.me
+         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+         return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter()
+        cdef pclfil.VoxelGrid_PointXYZRGBA_t *cfil = <pclfil.VoxelGrid_PointXYZRGBA_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter()
+        cdef pclfil.PassThrough_PointXYZRGBA_t *cfil = <pclfil.PassThrough_PointXYZRGBA_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares_PointXYZRGBA()
+        cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGBA_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZRGBA(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZRGBA(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZRGBA result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        for i in pyindices:
+            ind.indices.push_back(i)
+        result = PointCloud_PointXYZRGBA()
+        mpcl_extract_PointXYZRGBA(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        return result
+###
diff --git a/pcl/pxi/PointCloud_PointXYZRGBA_180.pxi b/pcl/pxi/PointCloud_PointXYZRGBA_180.pxi
new file mode 100644
index 0000000..096a560
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZRGBA_180.pxi
@@ -0,0 +1,350 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features_180 as pclftr
+cimport pcl_filters_180 as pclfil
+cimport pcl_io_180 as pclio
+cimport pcl_kdtree_180 as pclkdt
+# cimport pcl_octree_180 as pcloct
+# cimport pcl_sample_consensus_180 as pcl_sc
+# cimport pcl_search_180 as pcl_sch
+cimport pcl_segmentation_180 as pclseg
+cimport pcl_surface_180 as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZRGBA
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZRGBA(cpp.PointCloud_PointXYZRGBA_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZRGBA(pclseg.SACSegmentation_PointXYZRGBA_Normal_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZRGBA(cpp.PointCloud_PointXYZRGBA_Ptr_t, cpp.PointCloud_PointXYZRGBA_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzrgba_2[2]
+cdef PointCloud_PointXYZRGBA _pc_xyzrgba_tmp2 = PointCloud_PointXYZRGBA(np.array([[1, 2, 3, 0],
+                                                                          [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZRGBA] *p_xyzrgba_2 = _pc_xyzrgba_tmp2.thisptr()
+_strides_xyzrgba_2[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzrgba_2, 0))
+_strides_xyzrgba_2[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgba_2, 0).x))
+_pc_xyzrgba_tmp2 = None
+
+cdef class PointCloud_PointXYZRGBA:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZRGBA other
+
+        self._view_count = 0
+
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGBA]())
+
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+
+        cdef cpp.PointXYZRGBA *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.rgba = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZRGBA *p
+
+        result = np.empty((n, 4), dtype=np.float32)
+
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.rgba
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+       """
+       Fill this pointcloud from a list of 4-tuples
+       """
+       cdef Py_ssize_t npts = len(_list)
+       cdef cpp.PointXYZRGBA *p
+       self.resize(npts)
+       self.thisptr().width = npts
+       self.thisptr().height = 1
+       for i, l in enumerate(_list):
+           p = idx.getptr(self.thisptr(), <int> i)
+           p.x, p.y, p.z, p.rgba = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZRGBA *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.rgba
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZRGBA *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.rgba
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # error = cpp.loadPCDFile(string(s), p)
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # ok = cpp.loadPLYFile(string(s), p)
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGBA] *
+            # error = cpp.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGBA] *p = self.thisptr()
+            # error = cpp.savePLYFile(s, p, binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZRGBA()
+        cdef pclseg.SACSegmentation_PointXYZRGBA_t *cseg = <pclseg.SACSegmentation_PointXYZRGBA_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        p = self.thisptr()
+        mpcl_compute_normals_PointXYZRGBA(<cpp.PointCloud[cpp.PointXYZRGBA]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZRGBA_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+         """
+         Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+         """
+         fil = StatisticalOutlierRemovalFilter_PointXYZRGBA()
+         cdef pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGBA_t *>fil.me
+         cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+         return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter()
+        cdef pclfil.VoxelGrid_PointXYZRGBA_t *cfil = <pclfil.VoxelGrid_PointXYZRGBA_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter()
+        cdef pclfil.PassThrough_PointXYZRGBA_t *cfil = <pclfil.PassThrough_PointXYZRGBA_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares_PointXYZRGBA()
+        cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGBA_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGBA]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZRGBA(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZRGBA(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZRGBA result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        for i in pyindices:
+            ind.indices.push_back(i)
+        result = PointCloud_PointXYZRGBA()
+        mpcl_extract_PointXYZRGBA(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        return result
+###
diff --git a/pcl/pxi/PointCloud_PointXYZRGB_172.pxi b/pcl/pxi/PointCloud_PointXYZRGB_172.pxi
new file mode 100644
index 0000000..be1b810
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZRGB_172.pxi
@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features_172 as pclftr
+cimport pcl_filters_172 as pclfil
+cimport pcl_io_172 as pclio
+cimport pcl_kdtree_172 as pclkdt
+cimport pcl_octree_172 as pcloct
+# cimport pcl_sample_consensus_172 as pcl_sc
+# cimport pcl_search_172 as pcl_sch
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_surface_172 as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZRGB
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZRGB(cpp.PointCloud_PointXYZRGB_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZRGB(pclseg.SACSegmentationNormal_PointXYZRGB_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZRGB(cpp.PointCloud_PointXYZRGB_Ptr_t, cpp.PointCloud_PointXYZRGB_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzrgb_3[2]
+cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],
+                                                                          [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+_strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 0))
+_strides_xyzrgb_3[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).x))
+_pc_xyzrgb_tmp3 = None
+
+cdef class PointCloud_PointXYZRGB:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZRGB other
+
+        self._view_count = 0
+
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides_xyzrgb_3
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+
+        cdef cpp.PointXYZRGB *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.rgb = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZRGB *p
+
+        result = np.empty((n, 4), dtype=np.float32)
+
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.rgb
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointXYZRGB *p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        for i, l in enumerate(_list):
+            p = idx.getptr(self.thisptr(), <int> i)
+            p.x, p.y, p.z, p.rgb = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZRGB *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.rgb
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZRGB *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.rgb
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # error = cpp.loadPCDFile(string(s), p)
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # ok = cpp.loadPLYFile(string(s), p)
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGB] *
+            # error = cpp.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # error = cpp.savePLYFile(s, p, binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZRGB()
+        cdef pclseg.SACSegmentation_PointXYZRGB_t *cseg = <pclseg.SACSegmentation_PointXYZRGB_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        p = self.thisptr()
+        mpcl_compute_normals_PointXYZRGB(<cpp.PointCloud[cpp.PointXYZRGB]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZRGB_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGB_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        fil = StatisticalOutlierRemovalFilter_PointXYZRGB()
+        cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter_PointXYZRGB()
+        cdef pclfil.VoxelGrid_PointXYZRGB_t *cfil = <pclfil.VoxelGrid_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter_PointXYZRGB()
+        cdef pclfil.PassThrough_PointXYZRGB_t *cfil = <pclfil.PassThrough_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares_PointXYZRGB()
+        cdef pclsf.MovingLeastSquares_PointXYZRGB_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGB_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+        
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZRGB(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZRGB(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZRGB result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud_PointXYZRGB()
+        mpcl_extract_PointXYZRGB(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
diff --git a/pcl/pxi/PointCloud_PointXYZRGB_180.pxi b/pcl/pxi/PointCloud_PointXYZRGB_180.pxi
new file mode 100644
index 0000000..9bdc117
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZRGB_180.pxi
@@ -0,0 +1,353 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features_180 as pclftr
+cimport pcl_filters_180 as pclfil
+cimport pcl_io_180 as pclio
+cimport pcl_kdtree_180 as pclkdt
+# cimport pcl_octree_180 as pcloct
+# cimport pcl_sample_consensus_180 as pcl_sc
+# cimport pcl_search_180 as pcl_sch
+cimport pcl_segmentation_180 as pclseg
+cimport pcl_surface_180 as pclsf
+
+from libcpp cimport bool
+cimport indexing as idx
+from boost_shared_ptr cimport sp_assign
+from _pcl cimport PointCloud_PointXYZRGB
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals_PointXYZRGB(cpp.PointCloud_PointXYZRGB_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis_PointXYZRGB(pclseg.SACSegmentationNormal_PointXYZRGB_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract_PointXYZRGB(cpp.PointCloud_PointXYZRGB_Ptr_t, cpp.PointCloud_PointXYZRGB_t *,
+                              cpp.PointIndices_t *, bool) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides_xyzrgb_3[2]
+cdef PointCloud_PointXYZRGB _pc_xyzrgb_tmp3 = PointCloud_PointXYZRGB(np.array([[1, 2, 3, 0],
+                                                                          [4, 5, 6, 0]], dtype=np.float32))
+cdef cpp.PointCloud[cpp.PointXYZRGB] *p_xyzrgb_3 = _pc_xyzrgb_tmp3.thisptr()
+_strides_xyzrgb_3[0] = (  <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 1)
+               - <Py_ssize_t><void *>idx.getptr(p_xyzrgb_3, 0))
+_strides_xyzrgb_3[1] = (  <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p_xyzrgb_3, 0).x))
+_pc_xyzrgb_tmp3 = None
+
+cdef class PointCloud_PointXYZRGB:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud_PointXYZRGB other
+
+        self._view_count = 0
+
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZRGB]())
+
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 4
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 4 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides_xyzrgb_3
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 4
+
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+
+        cdef cpp.PointXYZRGB *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z, p.rgb = arr[i, 0], arr[i, 1], arr[i, 2], <unsigned long>arr[i, 3]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZRGB *p
+
+        result = np.empty((n, 4), dtype=np.float32)
+
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+            result[i, 3] = p.rgb
+        return result
+
+    @cython.boundscheck(False)
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 4-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        cdef cpp.PointXYZRGB *p
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        for i, l in enumerate(_list):
+            p = idx.getptr(self.thisptr(), <int> i)
+            p.x, p.y, p.z, p.rgb = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZRGB *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z, p.rgb
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZRGB *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z, p.rgb
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # error = cpp.loadPCDFile(string(s), p)
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # ok = cpp.loadPLYFile(string(s), p)
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGB] *
+            # error = cpp.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+            # cpp.PointCloud[cpp.PointXYZRGB] *p = self.thisptr()
+            # error = cpp.savePLYFile(s, p, binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation_PointXYZRGB()
+        cdef pclseg.SACSegmentation_PointXYZRGB_t *cseg = <pclseg.SACSegmentation_PointXYZRGB_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        p = self.thisptr()
+        mpcl_compute_normals_PointXYZRGB(<cpp.PointCloud[cpp.PointXYZRGB]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)
+        seg = Segmentation_PointXYZRGB_Normal()
+        cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *cseg = <pclseg.SACSegmentationFromNormals_PointXYZRGB_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        fil = StatisticalOutlierRemovalFilter_PointXYZRGB()
+        cdef pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *cfil = <pclfil.StatisticalOutlierRemoval_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter_PointXYZRGB()
+        cdef pclfil.VoxelGrid_PointXYZRGB_t *cfil = <pclfil.VoxelGrid_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter_PointXYZRGB()
+        cdef pclfil.PassThrough_PointXYZRGB_t *cfil = <pclfil.PassThrough_PointXYZRGB_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares_PointXYZRGB()
+        cdef pclsf.MovingLeastSquares_PointXYZRGB_t *cmls = <pclsf.MovingLeastSquares_PointXYZRGB_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZRGB]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+        
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN_PointXYZRGB(self)
+
+#     def make_octree(self, double resolution):
+#         """
+#         Return a pcl.octree object with this object set as the input-cloud
+#         """
+#         octree = OctreePointCloud_PointXYZRGB(resolution)
+#         octree.set_input_cloud(self)
+#         return octree
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud_PointXYZRGB result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud_PointXYZRGB()
+        mpcl_extract_PointXYZRGB(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
diff --git a/pcl/pxi/PointCloud_PointXYZ_172.pxi b/pcl/pxi/PointCloud_PointXYZ_172.pxi
new file mode 100644
index 0000000..d32ae84
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZ_172.pxi
@@ -0,0 +1,559 @@
+# -*- coding: utf-8 -*-

+# main

+cimport pcl_defs as cpp

+import numpy as np

+cimport numpy as cnp

+

+cnp.import_array()

+

+# parts

+cimport pcl_features_172 as pclftr

+cimport pcl_filters_172 as pclfil

+cimport pcl_io_172 as pclio

+cimport pcl_kdtree_172 as pclkdt

+cimport pcl_octree_172 as pcloct

+cimport pcl_sample_consensus_172 as pcl_sc

+# cimport pcl_search_172 as pcl_sch

+cimport pcl_segmentation_172 as pclseg

+cimport pcl_surface_172 as pclsf

+cimport pcl_range_image_172 as pcl_r_img

+

+from libcpp cimport bool

+cimport indexing as idx

+

+from boost_shared_ptr cimport sp_assign

+

+cdef extern from "minipcl.h":

+    void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,

+                              double searchRadius,

+                              cpp.PointCloud_Normal_t) except +

+    void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,

+                              double ax, double ay, double az) except +

+    void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,

+                              cpp.PointIndices_t *, bool) except +

+    ## void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_PointXYZ *) except +

+    # void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_t *) except +

+

+

+cdef extern from "ProjectInliers.h":

+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t) except +

+

+# Empirically determine strides, for buffer support.

+# XXX Is there a more elegant way to get these?

+cdef Py_ssize_t _strides[2]

+cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],

+                                               [4, 5, 6]], dtype=np.float32))

+

+cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()

+_strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)

+               - <Py_ssize_t><void *>idx.getptr(p, 0))

+_strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)

+               - <Py_ssize_t><void *>&(idx.getptr(p, 0).x))

+_pc_tmp = None

+

+cdef class PointCloud:

+    """Represents a cloud of points in 3-d space.

+

+    A point cloud can be initialized from either a NumPy ndarray of shape

+    (n_points, 3), from a list of triples, or from an integer n to create an

+    "empty" cloud of n points.

+

+    To load a point cloud from disk, use pcl.load.

+    """

+    def __cinit__(self, init=None):

+        cdef PointCloud other

+        

+        self._view_count = 0

+        

+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)

+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())

+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())

+        

+        if init is None:

+            return

+        elif isinstance(init, (numbers.Integral, np.integer)):

+            self.resize(init)

+        elif isinstance(init, np.ndarray):

+            self.from_array(init)

+        elif isinstance(init, Sequence):

+            self.from_list(init)

+        elif isinstance(init, type(self)):

+            other = init

+            self.thisptr()[0] = other.thisptr()[0]

+        else:

+            raise TypeError("Can't initialize a PointCloud from a %s"

+                            % type(init))

+

+    property width:

+        """ property containing the width of the point cloud """

+        def __get__(self): return self.thisptr().width

+    property height:

+        """ property containing the height of the point cloud """

+        def __get__(self): return self.thisptr().height

+    property size:

+        """ property containing the number of points in the point cloud """

+        def __get__(self): return self.thisptr().size()

+    property is_dense:

+        """ property containing whether the cloud is dense or not """

+        def __get__(self): return self.thisptr().is_dense

+

+    def __repr__(self):

+        return "<PointCloud of %d points>" % self.size

+

+    # Buffer protocol support. Taking a view locks the pointcloud for

+    # resizing, because that can move it around in memory.

+    def __getbuffer__(self, Py_buffer *buffer, int flags):

+        # TODO parse flags

+        cdef Py_ssize_t npoints = self.thisptr().size()

+        

+        if self._view_count == 0:

+            self._view_count += 1

+            self._shape[0] = npoints

+            self._shape[1] = 3

+

+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)

+        buffer.format = 'f'

+        buffer.internal = NULL

+        buffer.itemsize = sizeof(float)

+        buffer.len = npoints * 3 * sizeof(float)

+        buffer.ndim = 2

+        buffer.obj = self

+        buffer.readonly = 0

+        buffer.shape = self._shape

+        buffer.strides = _strides

+        buffer.suboffsets = NULL

+

+    def __releasebuffer__(self, Py_buffer *buffer):

+        self._view_count -= 1

+

+    # Pickle support. XXX this copies the entire pointcloud; it would be nice

+    # to have an asarray member that returns a view, or even better, implement

+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).

+    def __reduce__(self):

+        return type(self), (self.to_array(),)

+

+    property sensor_origin:

+        def __get__(self):

+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_

+            cdef float *data = origin.data()

+            return np.array([data[0], data[1], data[2], data[3]],

+                            dtype=np.float32)

+

+    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()])

+

+    @cython.boundscheck(False)

+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

+        """

+        Fill this object from a 2D numpy array (float32)

+        """

+        assert arr.shape[1] == 3

+        

+        cdef cnp.npy_intp npts = arr.shape[0]

+        self.resize(npts)

+        self.thisptr().width = npts

+        self.thisptr().height = 1

+        

+        cdef cpp.PointXYZ *p

+        for i in range(npts):

+            p = idx.getptr(self.thisptr(), i)

+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]

+

+    @cython.boundscheck(False)

+    def to_array(self):

+        """

+        Return this object as a 2D numpy array (float32)

+        """

+        cdef float x,y,z

+        cdef cnp.npy_intp n = self.thisptr().size()

+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result

+        cdef cpp.PointXYZ *p

+        

+        result = np.empty((n, 3), dtype=np.float32)

+        for i in range(n):

+            p = idx.getptr(self.thisptr(), i)

+            result[i, 0] = p.x

+            result[i, 1] = p.y

+            result[i, 2] = p.z

+        

+        return result

+

+    def from_list(self, _list):

+        """

+        Fill this pointcloud from a list of 3-tuples

+        """

+        cdef Py_ssize_t npts = len(_list)

+        self.resize(npts)

+        self.thisptr().width = npts

+        self.thisptr().height = 1

+        cdef cpp.PointXYZ* p

+        # OK

+        # p = idx.getptr(self.thisptr(), 1)

+        # enumerate ? -> i -> type unknown

+        for i, l in enumerate(_list):

+             p = idx.getptr(self.thisptr(), <int> i)

+             p.x, p.y, p.z = l

+

+    def to_list(self):

+        """

+        Return this object as a list of 3-tuples

+        """

+        return self.to_array().tolist()

+

+    def resize(self, cnp.npy_intp x):

+        if self._view_count > 0:

+            raise ValueError("can't resize PointCloud while there are"

+                             " arrays/memoryviews referencing it")

+        self.thisptr().resize(x)

+

+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):

+        """

+        Return a point (3-tuple) at the given row/column

+        """

+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)

+        return p.x, p.y, p.z

+

+    def __getitem__(self, cnp.npy_intp nmidx):

+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)

+        return p.x, p.y, p.z

+

+    def from_file(self, char *f):

+        """

+        Fill this pointcloud from a file (a local path).

+        Only pcd files supported currently.

+        

+        Deprecated; use pcl.load instead.

+        """

+        return self._from_pcd_file(f)

+

+    def _from_pcd_file(self, const char *s):

+        cdef int error = 0

+        with nogil:

+            # NG

+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))

+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))

+        return error

+

+    def _from_ply_file(self, const char *s):

+        cdef int ok = 0

+        with nogil:

+            # NG

+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))

+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))

+        return ok

+

+    def to_file(self, const char *fname, bool ascii=True):

+        """Save pointcloud to a file in PCD format.

+

+        Deprecated: use pcl.save instead.

+        """

+        return self._to_pcd_file(fname, not ascii)

+

+    def _to_pcd_file(self, const char *f, bool binary=False):

+        cdef int error = 0

+        cdef string s = string(f)

+        with nogil:

+            # NG

+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)

+            # OK

+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)

+            # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()

+            # error = pclio.savePCDFile(s, p, binary)

+        return error

+

+    def _to_ply_file(self, const char *f, bool binary=False):

+        cdef int error = 0

+        cdef string s = string(f)

+        with nogil:

+            # NG

+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)

+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)

+        return error

+

+    def make_segmenter(self):

+        """

+        Return a pcl.Segmentation object with this object set as the input-cloud

+        """

+        seg = Segmentation()

+        cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me

+        cseg.setInputCloud(self.thisptr_shared)

+        return seg

+

+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):

+        """

+        Return a pcl.SegmentationNormal object with this object set as the input-cloud

+        """

+        cdef cpp.PointCloud_Normal_t normals

+        mpcl_compute_normals(<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), ksearch, searchRadius, normals)

+        seg = SegmentationNormal()

+        cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me

+        cseg.setInputCloud(self.thisptr_shared)

+        cseg.setInputNormals (normals.makeShared());

+        return seg

+

+    def make_statistical_outlier_filter(self):

+        """

+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud

+        """

+        # fil = StatisticalOutlierRemovalFilter()

+        # cdef pclfil.StatisticalOutlierRemoval_t *cfil = <pclfil.StatisticalOutlierRemoval_t *>fil.me

+        # cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return StatisticalOutlierRemovalFilter(self)

+

+    def make_voxel_grid_filter(self):

+        """

+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud

+        """

+        fil = VoxelGridFilter()

+        cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_ApproximateVoxelGrid(self):

+        """

+        Return a pcl.ApproximateVoxelGrid object with this object set as the input-cloud

+        """

+        fil = ApproximateVoxelGrid()

+        cdef pclfil.ApproximateVoxelGrid_t *cfil = <pclfil.ApproximateVoxelGrid_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_passthrough_filter(self):

+        """

+        Return a pcl.PassThroughFilter object with this object set as the input-cloud

+        """

+        fil = PassThroughFilter()

+        cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_moving_least_squares(self):

+        """

+        Return a pcl.MovingLeastSquares object with this object as input cloud.

+        """

+        mls = MovingLeastSquares()

+        cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me

+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return mls

+

+    def make_kdtree(self):

+        """

+        Return a pcl.kdTree object with this object set as the input-cloud

+        

+        Deprecated: use the pcl.KdTree constructor on this cloud.

+        """

+        return KdTree(self)

+

+    def make_kdtree_flann(self):

+        """

+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud

+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.

+        """

+        return KdTreeFLANN(self)

+

+    def make_octree(self, double resolution):

+        """

+        Return a pcl.octree object with this object set as the input-cloud

+        """

+        octree = OctreePointCloud(resolution)

+        octree.set_input_cloud(self)

+        return octree

+

+    def make_octreeSearch(self, double resolution):

+        """

+        Return a pcl.make_octreeSearch object with this object set as the input-cloud

+        """

+        octreeSearch = OctreePointCloudSearch(resolution)

+        octreeSearch.set_input_cloud(self)

+        return octreeSearch

+

+    # pcl 1.7.2, 1.8.0 (octree_pointcloud_changedetector.h(->octree_pointcloud.h) include headerfile comment octree2buf_base.h)

+    def make_octreeChangeDetector(self, double resolution):

+        """

+        Return a pcl.make_octreeSearch object with this object set as the input-cloud

+        """

+        octreeChangeDetector = OctreePointCloudChangeDetector(resolution)

+        octreeChangeDetector.set_input_cloud(self)

+        return octreeChangeDetector

+

+    def make_crophull(self):

+        """

+        Return a pcl.CropHull object with this object set as the input-cloud

+

+        Deprecated: use the pcl.Vertices constructor on this cloud.

+        """

+        return CropHull(self)

+

+    def make_cropbox(self):

+        """

+        Return a pcl.CropBox object with this object set as the input-cloud

+        Deprecated: use the pcl.Vertices constructor on this cloud.

+        """

+        return CropBox(self)

+

+    def make_IntegralImageNormalEstimation(self):

+        """

+        Return a pcl.IntegralImageNormalEstimation object with this object set as the input-cloud

+        Deprecated: use the pcl.Vertices constructor on this cloud.

+        """

+        return IntegralImageNormalEstimation(self)

+

+    def extract(self, pyindices, bool negative=False):

+        """

+        Given a list of indices of points in the pointcloud, return a 

+        new pointcloud containing only those points.

+        """

+        cdef PointCloud result

+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()

+        

+        for i in pyindices:

+            ind.indices.push_back(i)

+        

+        result = PointCloud()

+        # result = ExtractIndices()

+        # (<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr())

+        mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)

+        # XXX are we leaking memory here? del ind causes a double free...

+        

+        return result

+

+    def make_ProjectInliers(self):

+        """

+        Return a pclfil.ProjectInliers object with this object set as the input-cloud

+        """

+        # proj = ProjectInliers()

+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me

+        # cproj.setInputCloud(self.thisptr_shared)

+        # return proj

+        # # cdef pclfil.ProjectInliers_t* projInliers

+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)

+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))

+        # # proj = ProjectInliers()

+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>projInliers

+        # cproj.setInputCloud(self.thisptr_shared)

+        # return proj

+        # # NG

+        # cdef pclfil.ProjectInliers_t* projInliers

+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)

+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))

+        # projInliers.setInputCloud(self.thisptr_shared)

+        # proj = ProjectInliers()

+        # proj.me = projInliers

+        # return proj

+        proj = ProjectInliers()

+        cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me

+        # mpcl_ProjectInliers_setModelCoefficients(cproj)

+        mpcl_ProjectInliers_setModelCoefficients(deref(cproj))

+        cproj.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return proj

+

+    def make_RadiusOutlierRemoval(self):

+        """

+        Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud

+        """

+        fil = RadiusOutlierRemoval()

+        cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_ConditionAnd(self):

+        """

+        Return a pcl.ConditionAnd object with this object set as the input-cloud

+        """

+        condAnd = ConditionAnd()

+        cdef pclfil.ConditionAnd_t *cCondAnd = <pclfil.ConditionAnd_t *>condAnd.me

+        return condAnd

+

+    def make_ConditionalRemoval(self, ConditionAnd range_conf):

+        """

+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud

+        """

+        condRemoval = ConditionalRemoval(range_conf)

+        cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me

+        cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return condRemoval

+

+    def make_ConcaveHull(self):

+        """

+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud

+        """

+        concaveHull = ConcaveHull()

+        cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me

+        cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return concaveHull

+

+    def make_HarrisKeypoint3D(self):

+        """

+        Return a pcl.PointCloud object with this object set as the input-cloud

+        """

+        harris = HarrisKeypoint3D(self)

+        # harris = HarrisKeypoint3D()

+        # cdef keypt.HarrisKeypoint3D_t *charris = <keypt.HarrisKeypoint3D_t *>harris.me

+        # charris.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return harris

+

+    def make_NormalEstimation(self):

+        normalEstimation = NormalEstimation()

+        cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me

+        cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return normalEstimation

+

+    def make_VFHEstimation(self):

+        vfhEstimation = VFHEstimation()

+        normalEstimation = self.make_NormalEstimation()

+        cloud_normals = normalEstimation.Compute()

+        # features

+        cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me

+        cVFHEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return vfhEstimation

+

+    def make_RangeImage(self):

+        rangeImages = RangeImages(self)

+        # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me

+        return rangeImages

+

+    def make_EuclideanClusterExtraction(self):

+        euclideanclusterextraction = EuclideanClusterExtraction(self)

+        cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me

+        cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return euclideanclusterextraction

+

+    def make_GeneralizedIterativeClosestPoint(self):

+        generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)

+        cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me

+        cGeneralizedIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return generalizedIterativeClosestPoint

+

+    def make_IterativeClosestPointNonLinear(self):

+        iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)

+        cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me

+        cIterativeClosestPointNonLinear.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return iterativeClosestPointNonLinear

+

+    def make_IterativeClosestPoint(self):

+        iterativeClosestPoint = IterativeClosestPoint(self)

+        cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me

+        cIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return iterativeClosestPoint

+

+    # def make_MomentOfInertiaEstimation(self):

+    #     momentofinertiaestimation = MomentOfInertiaEstimation(self)

+    #     cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me

+    #     cMomentOfInertiaEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+    #     return momentofinertiaestimation

+

+    # registration - icp?

+    # def make_IterativeClosestPoint():

+    #     iterativeClosestPoint = IterativeClosestPoint(self)

+    #     cdef pclseg.IterativeClosestPoint *cEuclideanClusterExtraction = <pclseg.IterativeClosestPoint *>euclideanclusterextraction.me

+    #     

+    #     cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+    #     # icp.setInputCloud(cloud_in);

+    #     # icp.setInputTarget(cloud_out);

+    #     return euclideanclusterextraction

+

+###

+

diff --git a/pcl/pxi/PointCloud_PointXYZ_180.pxi b/pcl/pxi/PointCloud_PointXYZ_180.pxi
new file mode 100644
index 0000000..3158c4a
--- /dev/null
+++ b/pcl/pxi/PointCloud_PointXYZ_180.pxi
@@ -0,0 +1,559 @@
+# -*- coding: utf-8 -*-
+# main
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features_180 as pclftr
+cimport pcl_filters_180 as pclfil
+cimport pcl_io_180 as pclio
+cimport pcl_kdtree_180 as pclkdt
+# cimport pcl_octree_180 as pcloct
+cimport pcl_sample_consensus_180 as pcl_sc
+# cimport pcl_search_180 as pcl_sch
+cimport pcl_segmentation_180 as pclseg
+cimport pcl_surface_180 as pclsf
+cimport pcl_range_image_180 as pcl_r_img
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,
+                              cpp.PointIndices_t *, bool) except +
+    ## void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_PointXYZ *) except +
+    # void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_t *) except +
+
+
+cdef extern from "ProjectInliers.h":
+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides[2]
+cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],
+                                               [4, 5, 6]], dtype=np.float32))
+
+cdef cpp.PointCloud[cpp.PointXYZ] *p = _pc_tmp.thisptr()
+_strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)
+               - <Py_ssize_t><void *>idx.getptr(p, 0))
+_strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p, 0).x))
+_pc_tmp = None
+
+cdef class PointCloud:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 3
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZ *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZ *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.PointXYZ* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.PointXYZ] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
+    def make_segmenter(self):
+        """
+        Return a pcl.Segmentation object with this object set as the input-cloud
+        """
+        seg = Segmentation()
+        cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        return seg
+
+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):
+        """
+        Return a pcl.SegmentationNormal object with this object set as the input-cloud
+        """
+        cdef cpp.PointCloud_Normal_t normals
+        mpcl_compute_normals(<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr()), ksearch, searchRadius, normals)
+        seg = SegmentationNormal()
+        cdef pclseg.SACSegmentationFromNormals_t *cseg = <pclseg.SACSegmentationFromNormals_t *>seg.me
+        cseg.setInputCloud(self.thisptr_shared)
+        cseg.setInputNormals (normals.makeShared());
+        return seg
+
+    def make_statistical_outlier_filter(self):
+        """
+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud
+        """
+        # fil = StatisticalOutlierRemovalFilter()
+        # cdef pclfil.StatisticalOutlierRemoval_t *cfil = <pclfil.StatisticalOutlierRemoval_t *>fil.me
+        # cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return StatisticalOutlierRemovalFilter(self)
+
+    def make_voxel_grid_filter(self):
+        """
+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud
+        """
+        fil = VoxelGridFilter()
+        cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_ApproximateVoxelGrid(self):
+        """
+        Return a pcl.ApproximateVoxelGrid object with this object set as the input-cloud
+        """
+        fil = ApproximateVoxelGrid()
+        cdef pclfil.ApproximateVoxelGrid_t *cfil = <pclfil.ApproximateVoxelGrid_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_passthrough_filter(self):
+        """
+        Return a pcl.PassThroughFilter object with this object set as the input-cloud
+        """
+        fil = PassThroughFilter()
+        cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_moving_least_squares(self):
+        """
+        Return a pcl.MovingLeastSquares object with this object as input cloud.
+        """
+        mls = MovingLeastSquares()
+        cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me
+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return mls
+
+    def make_kdtree(self):
+        """
+        Return a pcl.kdTree object with this object set as the input-cloud
+        
+        Deprecated: use the pcl.KdTree constructor on this cloud.
+        """
+        return KdTree(self)
+
+    def make_kdtree_flann(self):
+        """
+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud
+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.
+        """
+        return KdTreeFLANN(self)
+
+    def make_octree(self, double resolution):
+        """
+        Return a pcl.octree object with this object set as the input-cloud
+        """
+        octree = OctreePointCloud(resolution)
+        octree.set_input_cloud(self)
+        return octree
+
+    def make_octreeSearch(self, double resolution):
+        """
+        Return a pcl.make_octreeSearch object with this object set as the input-cloud
+        """
+        octreeSearch = OctreePointCloudSearch(resolution)
+        octreeSearch.set_input_cloud(self)
+        return octreeSearch
+
+    # pcl 1.7.2, 1.8.0 (octree_pointcloud_changedetector.h(->octree_pointcloud.h) include headerfile comment octree2buf_base.h)
+    def make_octreeChangeDetector(self, double resolution):
+        """
+        Return a pcl.make_octreeSearch object with this object set as the input-cloud
+        """
+        octreeChangeDetector = OctreePointCloudChangeDetector(resolution)
+        octreeChangeDetector.set_input_cloud(self)
+        return octreeChangeDetector
+
+    def make_crophull(self):
+        """
+        Return a pcl.CropHull object with this object set as the input-cloud
+
+        Deprecated: use the pcl.Vertices constructor on this cloud.
+        """
+        return CropHull(self)
+
+    def make_cropbox(self):
+        """
+        Return a pcl.CropBox object with this object set as the input-cloud
+        Deprecated: use the pcl.Vertices constructor on this cloud.
+        """
+        return CropBox(self)
+
+    def make_IntegralImageNormalEstimation(self):
+        """
+        Return a pcl.IntegralImageNormalEstimation object with this object set as the input-cloud
+        Deprecated: use the pcl.Vertices constructor on this cloud.
+        """
+        return IntegralImageNormalEstimation(self)
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud()
+        # result = ExtractIndices()
+        # (<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr())
+        mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+
+    def make_ProjectInliers(self):
+        """
+        Return a pclfil.ProjectInliers object with this object set as the input-cloud
+        """
+        # proj = ProjectInliers()
+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me
+        # cproj.setInputCloud(self.thisptr_shared)
+        # return proj
+        # # cdef pclfil.ProjectInliers_t* projInliers
+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)
+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))
+        # # proj = ProjectInliers()
+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>projInliers
+        # cproj.setInputCloud(self.thisptr_shared)
+        # return proj
+        # # NG
+        # cdef pclfil.ProjectInliers_t* projInliers
+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)
+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))
+        # projInliers.setInputCloud(self.thisptr_shared)
+        # proj = ProjectInliers()
+        # proj.me = projInliers
+        # return proj
+        proj = ProjectInliers()
+        cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me
+        # mpcl_ProjectInliers_setModelCoefficients(cproj)
+        mpcl_ProjectInliers_setModelCoefficients(deref(cproj))
+        cproj.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return proj
+
+    def make_RadiusOutlierRemoval(self):
+        """
+        Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud
+        """
+        fil = RadiusOutlierRemoval()
+        cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me
+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return fil
+
+    def make_ConditionAnd(self):
+        """
+        Return a pcl.ConditionAnd object with this object set as the input-cloud
+        """
+        condAnd = ConditionAnd()
+        cdef pclfil.ConditionAnd_t *cCondAnd = <pclfil.ConditionAnd_t *>condAnd.me
+        return condAnd
+
+    def make_ConditionalRemoval(self, ConditionAnd range_conf):
+        """
+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+        """
+        condRemoval = ConditionalRemoval(range_conf)
+        cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me
+        cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return condRemoval
+
+    def make_ConcaveHull(self):
+        """
+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud
+        """
+        concaveHull = ConcaveHull()
+        cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me
+        cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return concaveHull
+
+    def make_HarrisKeypoint3D(self):
+        """
+        Return a pcl.PointCloud object with this object set as the input-cloud
+        """
+        harris = HarrisKeypoint3D(self)
+        # harris = HarrisKeypoint3D()
+        # cdef keypt.HarrisKeypoint3D_t *charris = <keypt.HarrisKeypoint3D_t *>harris.me
+        # charris.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return harris
+
+    def make_NormalEstimation(self):
+        normalEstimation = NormalEstimation()
+        cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me
+        cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return normalEstimation
+
+    def make_VFHEstimation(self):
+        vfhEstimation = VFHEstimation()
+        normalEstimation = self.make_NormalEstimation()
+        cloud_normals = normalEstimation.Compute()
+        # features
+        cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me
+        cVFHEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return vfhEstimation
+
+    def make_RangeImage(self):
+        rangeImages = RangeImages(self)
+        # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me
+        return rangeImages
+
+    def make_EuclideanClusterExtraction(self):
+        euclideanclusterextraction = EuclideanClusterExtraction(self)
+        cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me
+        cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return euclideanclusterextraction
+
+    def make_GeneralizedIterativeClosestPoint(self):
+        generalizedIterativeClosestPoint = GeneralizedIterativeClosestPoint(self)
+        cdef pcl_reg.GeneralizedIterativeClosestPoint_t *cGeneralizedIterativeClosestPoint = <pcl_reg.GeneralizedIterativeClosestPoint_t *>generalizedIterativeClosestPoint.me
+        cGeneralizedIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return generalizedIterativeClosestPoint
+
+    def make_IterativeClosestPointNonLinear(self):
+        iterativeClosestPointNonLinear = IterativeClosestPointNonLinear(self)
+        cdef pcl_reg.IterativeClosestPointNonLinear_t *cIterativeClosestPointNonLinear = <pcl_reg.IterativeClosestPointNonLinear_t *>iterativeClosestPointNonLinear.me
+        cIterativeClosestPointNonLinear.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return iterativeClosestPointNonLinear
+
+    def make_IterativeClosestPoint(self):
+        iterativeClosestPoint = IterativeClosestPoint(self)
+        cdef pcl_reg.IterativeClosestPoint_t *cIterativeClosestPoint = <pcl_reg.IterativeClosestPoint_t *>iterativeClosestPoint.me
+        cIterativeClosestPoint.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return iterativeClosestPoint
+
+    def make_MomentOfInertiaEstimation(self):
+        momentofinertiaestimation = MomentOfInertiaEstimation(self)
+        cdef pclftr.MomentOfInertiaEstimation_t *cMomentOfInertiaEstimation = <pclftr.MomentOfInertiaEstimation_t *>momentofinertiaestimation.me
+        cMomentOfInertiaEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+        return momentofinertiaestimation
+
+    # registration - icp?
+    # def make_IterativeClosestPoint():
+    #     iterativeClosestPoint = IterativeClosestPoint(self)
+    #     cdef pclseg.IterativeClosestPoint *cEuclideanClusterExtraction = <pclseg.IterativeClosestPoint *>euclideanclusterextraction.me
+    #     
+    #     cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)
+    #     # icp.setInputCloud(cloud_in);
+    #     # icp.setInputTarget(cloud_out);
+    #     return euclideanclusterextraction
+
+###
+
diff --git a/pcl/pxi/PointCloud_ReferenceFrame.pxi b/pcl/pxi/PointCloud_ReferenceFrame.pxi
new file mode 100644
index 0000000..7c080ae
--- /dev/null
+++ b/pcl/pxi/PointCloud_ReferenceFrame.pxi
@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*-
+# main
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+cimport pcl_kdtree as pclkdt
+cimport pcl_octree as pcloct
+cimport pcl_sample_consensus as pcl_sc
+# cimport pcl_search as pcl_sch
+cimport pcl_segmentation as pclseg
+cimport pcl_surface as pclsf
+cimport pcl_range_image as pcl_r_img
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef extern from "minipcl.h":
+    void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,
+                              double searchRadius,
+                              cpp.PointCloud_Normal_t) except +
+    void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,
+                              double ax, double ay, double az) except +
+    void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,
+                              cpp.PointIndices_t *, bool) except +
+    ## void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_ReferenceFrame *) except +
+    # void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_t *) except +
+
+
+cdef extern from "ProjectInliers.h":
+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t) except +
+
+# Empirically determine strides, for buffer support.
+# XXX Is there a more elegant way to get these?
+cdef Py_ssize_t _strides[2]
+cdef PointCloud _pc_tmp = PointCloud(np.array([[1, 2, 3],
+                                               [4, 5, 6]], dtype=np.float32))
+
+cdef cpp.PointCloud[cpp.ReferenceFrame] *p = _pc_tmp.thisptr()
+_strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)
+               - <Py_ssize_t><void *>idx.getptr(p, 0))
+_strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)
+               - <Py_ssize_t><void *>&(idx.getptr(p, 0).x))
+_pc_tmp = None
+
+cdef class PointCloud_ReferenceFrame:
+    """Represents a cloud of points in 3-d space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 3), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+    def __cinit__(self, init=None):
+        cdef PointCloud other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.ReferenceFrame]]> self.thisptr_shared, new cpp.PointCloud[cpp.ReferenceFrame]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.ReferenceFrame]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    # Buffer protocol support. Taking a view locks the pointcloud for
+    # resizing, because that can move it around in memory.
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        # TODO parse flags
+        cdef Py_ssize_t npoints = self.thisptr().size()
+        
+        if self._view_count == 0:
+            self._view_count += 1
+            self._shape[0] = npoints
+            self._shape[1] = 3
+
+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)
+        buffer.format = 'f'
+        buffer.internal = NULL
+        buffer.itemsize = sizeof(float)
+        buffer.len = npoints * 3 * sizeof(float)
+        buffer.ndim = 2
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self._shape
+        buffer.strides = _strides
+        buffer.suboffsets = NULL
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    property sensor_origin:
+        def __get__(self):
+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_
+            cdef float *data = origin.data()
+            return np.array([data[0], data[1], data[2], data[3]],
+                            dtype=np.float32)
+
+    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()])
+
+    # cdef inline PointCloud[ReferenceFrame] *thisptr(self) nogil:
+    #     # Shortcut to get raw pointer to underlying PointCloud
+    #     return self.thisptr_shared.get()
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 3
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.ReferenceFrame *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.ReferenceFrame *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.ReferenceFrame* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.ReferenceFrame *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.ReferenceFrame *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def from_file(self, char *f):
+        """
+        Fill this pointcloud from a file (a local path).
+        Only pcd files supported currently.
+        
+        Deprecated; use pcl.load instead.
+        """
+        return self._from_pcd_file(f)
+
+    def _from_pcd_file(self, const char *s):
+        cdef int error = 0
+        with nogil:
+            # NG
+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud[cpp.ReferenceFrame]> deref(self.thisptr()))
+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))
+        return error
+
+    def _from_ply_file(self, const char *s):
+        cdef int ok = 0
+        with nogil:
+            # NG
+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud[cpp.ReferenceFrame]> deref(self.thisptr()))
+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))
+        return ok
+
+    def to_file(self, const char *fname, bool ascii=True):
+        """Save pointcloud to a file in PCD format.
+
+        Deprecated: use pcl.save instead.
+        """
+        return self._to_pcd_file(fname, not ascii)
+
+    def _to_pcd_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePCDFile(s, <cpp.PointCloud[cpp.ReferenceFrame]> deref(self.thisptr()), binary)
+            # OK
+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)
+            # pclio.PointCloud[cpp.ReferenceFrame] *p = self.thisptr()
+            # error = pclio.savePCDFile(s, p, binary)
+        return error
+
+    def _to_ply_file(self, const char *f, bool binary=False):
+        cdef int error = 0
+        cdef string s = string(f)
+        with nogil:
+            # NG
+            # error = pclio.savePLYFile(s, <cpp.PointCloud[cpp.ReferenceFrame]> deref(self.thisptr()), binary)
+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)
+        return error
+
diff --git a/pcl/pxi/PointCloud_SHOT352.pxi b/pcl/pxi/PointCloud_SHOT352.pxi
new file mode 100644
index 0000000..95397f6
--- /dev/null
+++ b/pcl/pxi/PointCloud_SHOT352.pxi
@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+# main
+cimport pcl_defs as cpp
+import numpy as np
+cimport numpy as cnp
+
+cnp.import_array()
+
+# parts
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef class PointCloud_SHOT352():
+    """Represents a cloud of points in 2-f space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 2), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+
+    def __cinit__(self, init=None):
+        cdef PointCloud_SHOT352 other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 2
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZ *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZ *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.PointXYZ* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud()
+        # (<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr())
+        mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
+
diff --git a/pcl/pxi/PointCloud_SensorPoint.pxi b/pcl/pxi/PointCloud_SensorPoint.pxi
new file mode 100644
index 0000000..73e3abb
--- /dev/null
+++ b/pcl/pxi/PointCloud_SensorPoint.pxi
@@ -0,0 +1,580 @@
+# -*- coding: utf-8 -*-

+# main

+cimport pcl_defs as cpp

+import numpy as np
+cimport numpy as cnp
+

+cnp.import_array()

+

+# parts

+cimport pcl_features as pclftr

+cimport pcl_filters as pclfil

+cimport pcl_io as pclio

+cimport pcl_kdtree as pclkdt

+cimport pcl_octree as pcloct

+cimport pcl_sample_consensus as pcl_sc

+# cimport pcl_search as pcl_sch

+cimport pcl_segmentation as pclseg

+cimport pcl_surface as pclsf

+cimport pcl_range_image as pcl_r_img

+

+from libcpp cimport bool

+cimport indexing as idx

+

+from boost_shared_ptr cimport sp_assign

+

+cdef extern from "minipcl.h":

+    void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,

+                              double searchRadius,

+                              cpp.PointCloud_Normal_t) except +

+    void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,

+                              double ax, double ay, double az) except +

+    void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,

+                              cpp.PointIndices_t *, bool) except +

+    ## void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_PointXYZ *) except +

+    # void mpcl_extract_HarrisKeypoint3D(cpp.PointCloudPtr_t, cpp.PointCloud_t *) except +

+

+

+cdef extern from "ProjectInliers.h":

+    void mpcl_ProjectInliers_setModelCoefficients(pclfil.ProjectInliers_t);

+

+# Empirically determine strides, for buffer support.

+# XXX Is there a more elegant way to get these?

+cdef Py_ssize_t _strides[2]

+cdef PointCloud2 _pc_tmp = PointCloud(np.array([[1, 2, 3],

+                                               [4, 5, 6]], dtype=np.float32))

+

+cdef cpp.PointCloud2[cpp.PointXYZ] *p = _pc_tmp.thisptr()

+_strides[0] = (  <Py_ssize_t><void *>idx.getptr(p, 1)

+               - <Py_ssize_t><void *>idx.getptr(p, 0))

+_strides[1] = (  <Py_ssize_t><void *>&(idx.getptr(p, 0).y)

+               - <Py_ssize_t><void *>&(idx.getptr(p, 0).x))

+_pc_tmp = None

+

+cdef class PointCloud2:

+    """Represents a cloud of points in 3-d space.

+

+    A point cloud can be initialized from either a NumPy ndarray of shape

+    (n_points, 3), from a list of triples, or from an integer n to create an

+    "empty" cloud of n points.

+

+    To load a point cloud from disk, use pcl.load.

+    """

+    def __cinit__(self, init=None):

+        cdef PointCloud2 other

+        

+        self._view_count = 0

+        

+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)

+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud2[cpp.PointXYZ]())

+        sp_assign(self.thisptr_shared, new cpp.PointCloud2[cpp.PointXYZ]())

+        

+        if init is None:

+            return

+        elif isinstance(init, (numbers.Integral, np.integer)):

+            self.resize(init)

+        elif isinstance(init, np.ndarray):

+            self.from_array(init)

+        elif isinstance(init, Sequence):

+            self.from_list(init)

+        elif isinstance(init, type(self)):

+            other = init

+            self.thisptr()[0] = other.thisptr()[0]

+        else:

+            raise TypeError("Can't initialize a PointCloud2 from a %s"

+                            % type(init))

+

+    property width:

+        """ property containing the width of the point cloud """

+        def __get__(self): return self.thisptr().width

+    property height:

+        """ property containing the height of the point cloud """

+        def __get__(self): return self.thisptr().height

+    property size:

+        """ property containing the number of points in the point cloud """

+        def __get__(self): return self.thisptr().size()

+    property is_dense:

+        """ property containing whether the cloud is dense or not """

+        def __get__(self): return self.thisptr().is_dense

+

+    def __repr__(self):

+        return "<PointCloud2 of %d points>" % self.size

+

+    # Buffer protocol support. Taking a view locks the PointCloud2 for

+    # resizing, because that can move it around in memory.

+    def __getbuffer__(self, Py_buffer *buffer, int flags):

+        # TODO parse flags

+        cdef Py_ssize_t npoints = self.thisptr().size()

+        

+        if self._view_count == 0:

+            self._view_count += 1

+            self._shape[0] = npoints

+            self._shape[1] = 3

+

+        buffer.buf = <char *>&(idx.getptr_at(self.thisptr(), 0).x)

+        buffer.format = 'f'

+        buffer.internal = NULL

+        buffer.itemsize = sizeof(float)

+        buffer.len = npoints * 3 * sizeof(float)

+        buffer.ndim = 2

+        buffer.obj = self

+        buffer.readonly = 0

+        buffer.shape = self._shape

+        buffer.strides = _strides

+        buffer.suboffsets = NULL

+

+    def __releasebuffer__(self, Py_buffer *buffer):

+        self._view_count -= 1

+

+    # Pickle support. XXX this copies the entire PointCloud2; it would be nice

+    # to have an asarray member that returns a view, or even better, implement

+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).

+    def __reduce__(self):

+        return type(self), (self.to_array(),)

+

+    property sensor_origin:

+        def __get__(self):

+            cdef cpp.Vector4f origin = self.thisptr().sensor_origin_

+            cdef float *data = origin.data()

+            return np.array([data[0], data[1], data[2], data[3]],

+                            dtype=np.float32)

+

+    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()])

+

+    # cdef inline PointCloud2[PointXYZ] *thisptr(self) nogil:

+    #     # Shortcut to get raw pointer to underlying PointCloud2

+    #     return self.thisptr_shared.get()

+

+    @cython.boundscheck(False)

+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):

+        """

+        Fill this object from a 2D numpy array (float32)

+        """

+        assert arr.shape[1] == 3

+        

+        cdef cnp.npy_intp npts = arr.shape[0]

+        self.resize(npts)

+        self.thisptr().width = npts

+        self.thisptr().height = 1

+        

+        cdef cpp.PointXYZ *p

+        for i in range(npts):

+            p = idx.getptr(self.thisptr(), i)

+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]

+

+    @cython.boundscheck(False)

+    def to_array(self):

+        """

+        Return this object as a 2D numpy array (float32)

+        """

+        cdef float x,y,z

+        cdef cnp.npy_intp n = self.thisptr().size()

+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result

+        cdef cpp.PointXYZ *p

+        

+        result = np.empty((n, 3), dtype=np.float32)

+        for i in range(n):

+            p = idx.getptr(self.thisptr(), i)

+            result[i, 0] = p.x

+            result[i, 1] = p.y

+            result[i, 2] = p.z

+        

+        return result

+

+    def from_list(self, _list):

+        """

+        Fill this PointCloud2 from a list of 3-tuples

+        """

+        cdef Py_ssize_t npts = len(_list)

+        self.resize(npts)

+        self.thisptr().width = npts

+        self.thisptr().height = 1

+        cdef cpp.PointXYZ* p

+        # OK

+        # p = idx.getptr(self.thisptr(), 1)

+        # enumerate ? -> i -> type unknown

+        for i, l in enumerate(_list):

+             p = idx.getptr(self.thisptr(), <int> i)

+             p.x, p.y, p.z = l

+

+    def to_list(self):

+        """

+        Return this object as a list of 3-tuples

+        """

+        return self.to_array().tolist()

+

+    def resize(self, cnp.npy_intp x):

+        if self._view_count > 0:

+            raise ValueError("can't resize PointCloud2 while there are"

+                             " arrays/memoryviews referencing it")

+        self.thisptr().resize(x)

+

+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):

+        """

+        Return a point (3-tuple) at the given row/column

+        """

+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)

+        return p.x, p.y, p.z

+

+    def __getitem__(self, cnp.npy_intp nmidx):

+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)

+        return p.x, p.y, p.z

+

+    def from_file(self, char *f):

+        """

+        Fill this PointCloud2 from a file (a local path).

+        Only pcd files supported currently.

+        

+        Deprecated; use pcl.load instead.

+        """

+        return self._from_pcd_file(f)

+

+    def _from_pcd_file(self, const char *s):

+        cdef int error = 0

+        with nogil:

+            # NG

+            # error = pclio.loadPCDFile(string(s), <cpp.PointCloud2[cpp.PointXYZ]> deref(self.thisptr()))

+            error = pclio.loadPCDFile(string(s), deref(self.thisptr()))

+        return error

+

+    def _from_ply_file(self, const char *s):

+        cdef int ok = 0

+        with nogil:

+            # NG

+            # ok = pclio.loadPLYFile(string(s), <cpp.PointCloud2[cpp.PointXYZ]> deref(self.thisptr()))

+            ok = pclio.loadPLYFile(string(s), deref(self.thisptr()))

+        return ok

+

+    def to_file(self, const char *fname, bool ascii=True):

+        """Save PointCloud2 to a file in PCD format.

+

+        Deprecated: use pcl.save instead.

+        """

+        return self._to_pcd_file(fname, not ascii)

+

+    def _to_pcd_file(self, const char *f, bool binary=False):

+        cdef int error = 0

+        cdef string s = string(f)

+        with nogil:

+            # NG

+            # error = pclio.savePCDFile(s, <cpp.PointCloud2[cpp.PointXYZ]> deref(self.thisptr()), binary)

+            # OK

+            error = pclio.savePCDFile(s, deref(self.thisptr()), binary)

+            # pclio.PointCloud2[cpp.PointXYZ] *p = self.thisptr()

+            # error = pclio.savePCDFile(s, p, binary)

+        return error

+

+    def _to_ply_file(self, const char *f, bool binary=False):

+        cdef int error = 0

+        cdef string s = string(f)

+        with nogil:

+            # NG

+            # error = pclio.savePLYFile(s, <cpp.PointCloud2[cpp.PointXYZ]> deref(self.thisptr()), binary)

+            error = pclio.savePLYFile(s, deref(self.thisptr()), binary)

+        return error

+

+    def make_segmenter(self):

+        """

+        Return a pcl.Segmentation object with this object set as the input-cloud

+        """

+        seg = Segmentation()

+        cdef pclseg.SACSegmentation_t *cseg = <pclseg.SACSegmentation_t *>seg.me

+        cseg.setInputCloud(self.thisptr_shared)

+        return seg

+

+    def make_segmenter_normals(self, int ksearch=-1, double searchRadius=-1.0):

+        """

+        Return a pcl.SegmentationNormal object with this object set as the input-cloud

+        """

+        cdef cpp.PointCloud_Normal_t normals

+        mpcl_compute_normals(<cpp.PointCloud2[cpp.PointXYZ]> deref(self.thisptr()), ksearch, searchRadius, normals)

+        # p = self.thisptr()

+        # mpcl_compute_normals(deref(p), ksearch, searchRadius, normals)

+        seg = SegmentationNormal()

+        cdef pclseg.SACSegmentationNormal_t *cseg = <pclseg.SACSegmentationNormal_t *>seg.me

+        cseg.setInputCloud(self.thisptr_shared)

+        cseg.setInputNormals (normals.makeShared());

+        return seg

+

+    def make_statistical_outlier_filter(self):

+        """

+        Return a pcl.StatisticalOutlierRemovalFilter object with this object set as the input-cloud

+        """

+        fil = StatisticalOutlierRemovalFilter()

+        cdef pclfil.StatisticalOutlierRemoval_t *cfil = <pclfil.StatisticalOutlierRemoval_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_voxel_grid_filter(self):

+        """

+        Return a pcl.VoxelGridFilter object with this object set as the input-cloud

+        """

+        fil = VoxelGridFilter()

+        cdef pclfil.VoxelGrid_t *cfil = <pclfil.VoxelGrid_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_passthrough_filter(self):

+        """

+        Return a pcl.PassThroughFilter object with this object set as the input-cloud

+        """

+        fil = PassThroughFilter()

+        cdef pclfil.PassThrough_t *cfil = <pclfil.PassThrough_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_moving_least_squares(self):

+        """

+        Return a pcl.MovingLeastSquares object with this object as input cloud.

+        """

+        mls = MovingLeastSquares()

+        cdef pclsf.MovingLeastSquares_t *cmls = <pclsf.MovingLeastSquares_t *>mls.me

+        cmls.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return mls

+

+    def make_kdtree(self):

+        """

+        Return a pcl.kdTree object with this object set as the input-cloud

+        

+        Deprecated: use the pcl.KdTree constructor on this cloud.

+        """

+        return KdTree(self)

+

+    def make_kdtree_flann(self):

+        """

+        Return a pcl.kdTreeFLANN object with this object set as the input-cloud

+        Deprecated: use the pcl.KdTreeFLANN constructor on this cloud.

+        """

+        return KdTreeFLANN(self)

+

+    def make_octree(self, double resolution):

+        """

+        Return a pcl.octree object with this object set as the input-cloud

+        """

+        octree = OctreePointCloud(resolution)

+        octree.set_input_cloud(self)

+        return octree

+

+    def make_octreeSearch(self, double resolution):

+        """

+        Return a pcl.make_octreeSearch object with this object set as the input-cloud

+        """

+        octreeSearch = OctreePointCloudSearch(resolution)

+        octreeSearch.set_input_cloud(self)

+        return octreeSearch

+

+# pcl 1.6.0 use ok

+# cpl 1.7.2, 1.8.0 use ng(octree_pointcloud_changedetector.h(->octree_pointcloud.h) include headerfile comment octree2buf_base.h)

+#    def make_octreeChangeDetector(self, double resolution):

+#        """

+#        Return a pcl.make_octreeSearch object with this object set as the input-cloud

+#        """

+#        octreeChangeDetector = OctreePointCloudChangeDetector(resolution)

+#        octreeChangeDetector.set_input_cloud(self)

+#        return octreeChangeDetector

+

+

+    def make_crophull(self):

+        """

+        Return a pcl.CropHull object with this object set as the input-cloud

+

+        Deprecated: use the pcl.Vertices constructor on this cloud.

+        """

+        return CropHull(self)

+        

+    def make_cropbox(self):

+        """

+        Return a pcl.CropBox object with this object set as the input-cloud

+

+        Deprecated: use the pcl.Vertices constructor on this cloud.

+        """

+        return CropBox(self)

+

+    def make_IntegralImageNormalEstimation(self):

+        """

+        Return a pcl.IntegralImageNormalEstimation object with this object set as the input-cloud

+

+        Deprecated: use the pcl.Vertices constructor on this cloud.

+        """

+        return IntegralImageNormalEstimation(self)

+

+    def extract(self, pyindices, bool negative=False):

+        """

+        Given a list of indices of points in the PointCloud2, return a 

+        new PointCloud2 containing only those points.

+        """

+        cdef PointCloud2 result

+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()

+        

+        for i in pyindices:

+            ind.indices.push_back(i)

+        

+        result = PointCloud2()

+        # result = ExtractIndices()

+        # (<cpp.PointCloud2[cpp.PointXYZ]> deref(self.thisptr())

+        mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)

+        # XXX are we leaking memory here? del ind causes a double free...

+        

+        return result

+

+    def make_ProjectInliers(self):

+        """

+        Return a pclfil.ProjectInliers object with this object set as the input-cloud

+        """

+        # proj = ProjectInliers()

+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me

+        # cproj.setInputCloud(self.thisptr_shared)

+        # return proj

+        # # cdef pclfil.ProjectInliers_t* projInliers

+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)

+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))

+        # # proj = ProjectInliers()

+        # cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>projInliers

+        # cproj.setInputCloud(self.thisptr_shared)

+        # return proj

+        # # NG

+        # cdef pclfil.ProjectInliers_t* projInliers

+        # # mpcl_ProjectInliers_setModelCoefficients(projInliers)

+        # mpcl_ProjectInliers_setModelCoefficients(deref(projInliers))

+        # projInliers.setInputCloud(self.thisptr_shared)

+        # proj = ProjectInliers()

+        # proj.me = projInliers

+        # return proj

+        proj = ProjectInliers()

+        cdef pclfil.ProjectInliers_t *cproj = <pclfil.ProjectInliers_t *>proj.me

+        # mpcl_ProjectInliers_setModelCoefficients(cproj)

+        mpcl_ProjectInliers_setModelCoefficients(deref(cproj))

+        cproj.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return proj

+

+    def make_RadiusOutlierRemoval(self):

+        """

+        Return a pclfil.RadiusOutlierRemoval object with this object set as the input-cloud

+        """

+        fil = RadiusOutlierRemoval()

+        cdef pclfil.RadiusOutlierRemoval_t *cfil = <pclfil.RadiusOutlierRemoval_t *>fil.me

+        cfil.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return fil

+

+    def make_ConditionAnd(self):

+        """

+        Return a pcl.ConditionAnd object with this object set as the input-cloud

+        """

+        condAnd = ConditionAnd()

+        cdef pclfil.ConditionAnd_t *cCondAnd = <pclfil.ConditionAnd_t *>condAnd.me

+        return condAnd

+

+    def make_ConditionalRemoval(self, ConditionAnd range_conf):

+        """

+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud

+        """

+        condRemoval = ConditionalRemoval(range_conf)

+        cdef pclfil.ConditionalRemoval_t *cCondRemoval = <pclfil.ConditionalRemoval_t *>condRemoval.me

+        cCondRemoval.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return condRemoval

+

+    def make_ConcaveHull(self):

+        """

+        Return a pcl.ConditionalRemoval object with this object set as the input-cloud

+        """

+        concaveHull = ConcaveHull()

+        cdef pclsf.ConcaveHull_t *cConcaveHull = <pclsf.ConcaveHull_t *>concaveHull.me

+        cConcaveHull.setInputCloud(<cpp.shared_ptr[cpp.PointCloud2[cpp.PointXYZ]]> self.thisptr_shared)

+        return concaveHull

+

+

+    def make_HarrisKeypoint3D(self):

+        """

+        Return a pcl.PointCloud2 object with this object set as the input-cloud

+        """

+        cdef PointCloud2 result

+

+        result = PointCloud_PointXYZI()

+        # # harris = HarrisKeypoint3D()

+        # mpcl_extract_HarrisKeypoint3D(self.thisptr_shared, result.thisptr())

+        # # mpcl_extract_HarrisKeypoint3D(self.thisptr_shared, result.thisptr_shared)

+        # # cdef keypt.HarrisKeypoint3DPtr_t *cseg = <pclseg.SACSegmentationNormal_t *>harris.me

+        # # charris.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        # # charris.setNonMaxSupression (true)

+        # # charris.setRadius (1.0)

+        # # charris.setRadiusSearch (searchRadius)

+        # # charris.compare(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> result.thisptr())

+

+        return result

+

+    def make_NormalEstimation(self):

+        normalEstimation = NormalEstimation()

+        cdef pclftr.NormalEstimation_t *cNormalEstimation = <pclftr.NormalEstimation_t *>normalEstimation.me

+        cNormalEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return normalEstimation

+

+    def make_VFHEstimation(self):

+        vfhEstimation = VFHEstimation()

+        normalEstimation = self.make_NormalEstimation()

+        cloud_normals = normalEstimation.Compute()

+        # features

+        cdef pclftr.VFHEstimation_t *cVFHEstimation = <pclftr.VFHEstimation_t *>vfhEstimation.me

+        cVFHEstimation.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return vfhEstimation

+

+    def make_RangeImage(self):

+        rangeImages = RangeImages(self)

+        # cdef pcl_r_img.RangeImage_t *cRangeImage = <pcl_r_img.RangeImage_t *>rangeImages.me

+        return rangeImages

+

+    def make_EuclideanClusterExtraction(self):

+        euclideanclusterextraction = EuclideanClusterExtraction(self)

+        cdef pclseg.EuclideanClusterExtraction_t *cEuclideanClusterExtraction = <pclseg.EuclideanClusterExtraction_t *>euclideanclusterextraction.me

+        cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+        return euclideanclusterextraction

+

+    # registration - icp?

+    # def make_IterativeClosestPoint():

+    #     iterativeClosestPoint = IterativeClosestPoint(self)

+    #     cdef pclseg.IterativeClosestPoint *cEuclideanClusterExtraction = <pclseg.IterativeClosestPoint *>euclideanclusterextraction.me

+    #     

+    #     cEuclideanClusterExtraction.setInputCloud(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared)

+    #     # icp.setInputCloud(cloud_in);

+    #     # icp.setInputTarget(cloud_out);

+    #     return euclideanclusterextraction

+

+###

+

+
+### include ###
+include "Segmentation/Segmentation.pxi"

+include "Segmentation/SegmentationNormal.pxi"

+include "Segmentation/EuclideanClusterExtraction.pxi"

+include "Filters/StatisticalOutlierRemovalFilter.pxi"

+include "Filters/VoxelGridFilter.pxi"

+include "Filters/PassThroughFilter.pxi"

+include "Surface/MovingLeastSquares.pxi"

+# include "KdTree/KdTree.pxi"

+include "KdTree/KdTree_FLANN.pxi"

+# Octree

+include "Octree/OctreePointCloud.pxi"

+include "Octree/OctreePointCloudSearch.pxi"

+include "Vertices.pxi"

+include "Filters/CropHull.pxi"

+include "Filters/CropBox.pxi"

+include "Filters/ProjectInliers.pxi"

+include "Filters/RadiusOutlierRemoval.pxi"

+include "Filters/ConditionAnd.pxi"

+include "Filters/ConditionalRemoval.pxi"

+include "Surface/ConcaveHull.pxi"

+include "Common/RangeImage/RangeImages.pxi"
+
# include "Visualization/PointCloudColorHandlerCustoms.pxi"

+
+# Features

+include "Features/NormalEstimation.pxi"

+include "Features/VFHEstimation.pxi"

+include "Features/IntegralImageNormalEstimation.pxi"

+

+# keyPoint

+# include "KeyPoint/UniformSampling.pxi"

+include "KeyPoint/HarrisKeypoint3D.pxi"

+

diff --git a/pcl/pxi/PointCloud_VFHSignature308.pxi b/pcl/pxi/PointCloud_VFHSignature308.pxi
new file mode 100644
index 0000000..ded73ad
--- /dev/null
+++ b/pcl/pxi/PointCloud_VFHSignature308.pxi
@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+# main
+cimport pcl_defs as cpp
+cimport numpy as cnp
+
+# parts
+cimport pcl_features as pclftr
+cimport pcl_filters as pclfil
+cimport pcl_io as pclio
+
+from libcpp cimport bool
+cimport indexing as idx
+
+from boost_shared_ptr cimport sp_assign
+
+cdef class PointCloud_VFHSignature308():
+    """Represents a cloud of points in 2-f space.
+
+    A point cloud can be initialized from either a NumPy ndarray of shape
+    (n_points, 2), from a list of triples, or from an integer n to create an
+    "empty" cloud of n points.
+
+    To load a point cloud from disk, use pcl.load.
+    """
+
+    def __cinit__(self, init=None):
+        cdef PointCloud_VFHSignature308 other
+        
+        self._view_count = 0
+        
+        # TODO: NG --> import pcl --> pyd Error(python shapedptr/C++ shard ptr collusion?)
+        # sp_assign(<cpp.shared_ptr[cpp.PointCloud[cpp.PointXYZ]]> self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        sp_assign(self.thisptr_shared, new cpp.PointCloud[cpp.PointXYZ]())
+        
+        if init is None:
+            return
+        elif isinstance(init, (numbers.Integral, np.integer)):
+            self.resize(init)
+        elif isinstance(init, np.ndarray):
+            self.from_array(init)
+        elif isinstance(init, Sequence):
+            self.from_list(init)
+        elif isinstance(init, type(self)):
+            other = init
+            self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s"
+                            % type(init))
+
+    property width:
+        """ property containing the width of the point cloud """
+        def __get__(self): return self.thisptr().width
+    property height:
+        """ property containing the height of the point cloud """
+        def __get__(self): return self.thisptr().height
+    property size:
+        """ property containing the number of points in the point cloud """
+        def __get__(self): return self.thisptr().size()
+    property is_dense:
+        """ property containing whether the cloud is dense or not """
+        def __get__(self): return self.thisptr().is_dense
+
+    def __repr__(self):
+        return "<PointCloud of %d points>" % self.size
+
+    def __releasebuffer__(self, Py_buffer *buffer):
+        self._view_count -= 1
+
+    # Pickle support. XXX this copies the entire pointcloud; it would be nice
+    # to have an asarray member that returns a view, or even better, implement
+    # the buffer protocol (https://docs.python.org/c-api/buffer.html).
+    def __reduce__(self):
+        return type(self), (self.to_array(),)
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.float32_t, ndim=2] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        assert arr.shape[1] == 2
+        
+        cdef cnp.npy_intp npts = arr.shape[0]
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        
+        cdef cpp.PointXYZ *p
+        for i in range(npts):
+            p = idx.getptr(self.thisptr(), i)
+            p.x, p.y, p.z = arr[i, 0], arr[i, 1], arr[i, 2]
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float x,y,z
+        cdef cnp.npy_intp n = self.thisptr().size()
+        cdef cnp.ndarray[cnp.float32_t, ndim=2, mode="c"] result
+        cdef cpp.PointXYZ *p
+        
+        result = np.empty((n, 3), dtype=np.float32)
+        for i in range(n):
+            p = idx.getptr(self.thisptr(), i)
+            result[i, 0] = p.x
+            result[i, 1] = p.y
+            result[i, 2] = p.z
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        self.thisptr().width = npts
+        self.thisptr().height = 1
+        cdef cpp.PointXYZ* p
+        # OK
+        # p = idx.getptr(self.thisptr(), 1)
+        # enumerate ? -> i -> type unknown
+        for i, l in enumerate(_list):
+             p = idx.getptr(self.thisptr(), <int> i)
+             p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize PointCloud while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().resize(x)
+
+    def get_point(self, cnp.npy_intp row, cnp.npy_intp col):
+        """
+        Return a point (3-tuple) at the given row/column
+        """
+        cdef cpp.PointXYZ *p = idx.getptr_at2(self.thisptr(), row, col)
+        return p.x, p.y, p.z
+
+    def __getitem__(self, cnp.npy_intp nmidx):
+        cdef cpp.PointXYZ *p = idx.getptr_at(self.thisptr(), nmidx)
+        return p.x, p.y, p.z
+
+    def extract(self, pyindices, bool negative=False):
+        """
+        Given a list of indices of points in the pointcloud, return a 
+        new pointcloud containing only those points.
+        """
+        cdef PointCloud result
+        cdef cpp.PointIndices_t *ind = new cpp.PointIndices_t()
+        
+        for i in pyindices:
+            ind.indices.push_back(i)
+        
+        result = PointCloud()
+        # (<cpp.PointCloud[cpp.PointXYZ]> deref(self.thisptr())
+        mpcl_extract(self.thisptr_shared, result.thisptr(), ind, negative)
+        # XXX are we leaking memory here? del ind causes a double free...
+        
+        return result
+###
+
diff --git a/pcl/pxi/PointXYZtoPointXYZ.pxi b/pcl/pxi/PointXYZtoPointXYZ.pxi
new file mode 100644
index 0000000..81d0b6c
--- /dev/null
+++ b/pcl/pxi/PointXYZtoPointXYZ.pxi
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport numpy as np
+
+cdef cpp.PointXYZ to_point_t(point):
+    cdef cpp.PointXYZ p
+    # check point datasize
+    # TypeError: a float is required
+    # http://stackoverflow.com/questions/15003403/typeerror-a-float-is-required
+    # TypeError: float() argument must be a string or a number, not 'tuple'
+    p.x = np.float(point[0])
+    p.y = np.float(point[1])
+    p.z = np.float(point[2])
+    return p
+
+
+cdef cpp.PointXYZI to_point2_t(point):
+    cdef cpp.PointXYZI p
+    # check point datasize
+    p.x = point[0]
+    p.y = point[1]
+    p.z = point[2]
+    p.intensity = point[3]
+    return p
+
+
+cdef cpp.PointXYZRGB to_point3_t(point):
+    cdef cpp.PointXYZRGB p
+    
+    # check point datasize
+    p.x = point[0]
+    p.y = point[1]
+    p.z = point[2]
+    p.rgb = point[3]
+    return p
+
+
+cdef cpp.PointXYZRGBA to_point4_t(point):
+    cdef cpp.PointXYZRGBA p
+    
+    # check point datasize
+    p.x = point[0]
+    p.y = point[1]
+    p.z = point[2]
+    p.rgba = point[3]
+    return p
diff --git a/pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi b/pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi
new file mode 100644
index 0000000..4697e72
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/RandomSampleConsensus.pxi
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+from libcpp.vector cimport vector
+
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+
+cdef class RandomSampleConsensus:
+    """
+    """
+    cdef pcl_sac.RandomSampleConsensus_t *me
+
+    # SetNG
+    def __cinit__(self, SampleConsensusModel model):
+        self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+        pass
+
+    # SetNG
+    def __cinit__(self, SampleConsensusModelPlane model):
+        self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+        pass
+
+    def __cinit__(self, SampleConsensusModelSphere model):
+        self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+        pass
+
+    # build error
+    # def __cinit__(self, model=None):
+    #     if model is None:
+    #         return
+    #     elif isinstance(model, SampleConsensusModel):
+    #         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+    #     elif isinstance(model, SampleConsensusModelPlane):
+    #         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+    #     elif isinstance(model, SampleConsensusModelSphere):
+    #         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+    #     else:
+    #         raise TypeError("Can't initialize a RandomSampleConsensus from a %s"
+    #                         % type(model))
+    #     pass
+
+    # build error
+    # def __init__(self, model=None):
+    #     if model is None:
+    #         return
+    #     elif isinstance(model, type(SampleConsensusModelPlane)):
+    #         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+    #     elif isinstance(model, type(SampleConsensusModelSphere)):
+    #         self.me = new pcl_sac.RandomSampleConsensus_t(<pcl_sac.SampleConsensusModelPtr_t> model.thisptr_shared)
+    #     else:
+    #         raise TypeError("Can't initialize a RandomSampleConsensus from a %s"
+    #                         % type(model))
+    #     pass
+
+    def __dealloc__(self):
+        del self.me
+
+    def computeModel(self):
+        self.me.computeModel(0)
+
+    # base Class(SampleConsensus)
+    def set_DistanceThreshold(self, double param):
+        self.me.setDistanceThreshold(param)
+
+    # base Class(SampleConsensus)
+    def get_Inliers(self):
+        cdef vector[int] inliers
+        self.me.getInliers(inliers)
+        return inliers
+
+
diff --git a/pcl/pxi/SampleConsensus/SampleConsensusModel.pxi b/pcl/pxi/SampleConsensus/SampleConsensusModel.pxi
new file mode 100644
index 0000000..0af2020
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/SampleConsensusModel.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+from boost_shared_ptr cimport sp_assign
+
+cdef class SampleConsensusModel:
+    """
+    """
+    # cdef pcl_sac.SampleConsensusModel_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        # NG
+        # self.me = new pcl_sac.SampleConsensusModel_t()
+        # self.me = new pcl_sac.SampleConsensusModel_t(pc.thisptr_shared)
+        # shared_ptr
+        # sp_assign(self.thisptr_shared, pc.thisptr_shared)
+        sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModel_t(pc.thisptr_shared))
+        pass
+
+    # def __dealloc__(self):
+    #     del self.me
+
diff --git a/pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi b/pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi
new file mode 100644
index 0000000..055b4ae
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/SampleConsensusModelCylinder.pxi
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+cdef class SampleConsensusModelCylinder:
+    """
+    """
+
+    def __cinit__(self, PointCloud pc not None):
+        # shared_ptr
+        sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelCylinder[cpp.PointXYZ, cpp.Normal](pc.thisptr_shared))
+        pass
+
diff --git a/pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi b/pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi
new file mode 100644
index 0000000..b21e2d9
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/SampleConsensusModelLine.pxi
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+cdef class SampleConsensusModelLine:
+    """
+    """
+
+    def __cinit__(self, PointCloud pc not None):
+        # shared_ptr
+        sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelLine[cpp.PointXYZ](pc.thisptr_shared))
+        pass
+
diff --git a/pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi b/pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi
new file mode 100644
index 0000000..dd98ae9
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/SampleConsensusModelPlane.pxi
@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+cdef class SampleConsensusModelPlane:
+    """
+    """
+    # cdef pcl_sac.SampleConsensusModelPlane_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        # NG
+        # self.me = new pcl_sac.SampleConsensusModelPlane_t()
+        # self.me = new pcl_sac.SampleConsensusModelPlane_t(pc.thisptr_shared)
+        # shared_ptr
+        sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelPlane[cpp.PointXYZ](pc.thisptr_shared))
+        pass
+
+    # def __dealloc__(self):
+    #     del self.me
+
diff --git a/pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi b/pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi
new file mode 100644
index 0000000..889040a
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/SampleConsensusModelRegistration.pxi
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+cdef class SampleConsensusModelRegistration:
+    """
+    """
+
+    def __cinit__(self, PointCloud pc not None):
+        # shared_ptr
+        sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelRegistration[cpp.PointXYZ](pc.thisptr_shared))
+        pass
+
diff --git a/pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi b/pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi
new file mode 100644
index 0000000..9807654
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/SampleConsensusModelSphere.pxi
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+from boost_shared_ptr cimport sp_assign
+
+cdef class SampleConsensusModelSphere:
+    """
+    """
+    # cdef pcl_sac.SampleConsensusModelSphere_t *me
+
+    def __cinit__(self, PointCloud pc not None):
+        # NG
+        # self.me = new pcl_sac.SampleConsensusModelSphere_t()
+        # self.me = new pcl_sac.SampleConsensusModelSphere_t(pc.thisptr_shared)
+        # shared_ptr
+        # NG
+        # sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelSphere_t(pc.thisptr_shared))
+        sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelSphere[cpp.PointXYZ](pc.thisptr_shared))
+        pass
+
+    # def __dealloc__(self):
+    #     del self.me
+
diff --git a/pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi b/pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi
new file mode 100644
index 0000000..5143cc9
--- /dev/null
+++ b/pcl/pxi/SampleConsensus/SampleConsensusModelStick.pxi
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sac
+
+cdef class SampleConsensusModelStick:
+    """
+    """
+
+    def __cinit__(self, PointCloud pc not None):
+        # shared_ptr
+        sp_assign(self.thisptr_shared, new pcl_sac.SampleConsensusModelStick[cpp.PointXYZ](pc.thisptr_shared))
+        pass
+
diff --git a/pcl/pxi/Segmentation/AddList.txt b/pcl/pxi/Segmentation/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/Segmentation/AddList.txt
diff --git a/pcl/pxi/Segmentation/ConditionalEuclideanClustering_172.pxi b/pcl/pxi/Segmentation/ConditionalEuclideanClustering_172.pxi
new file mode 100644
index 0000000..49f2125
--- /dev/null
+++ b/pcl/pxi/Segmentation/ConditionalEuclideanClustering_172.pxi
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+
+cdef class ConditionalEuclideanClustering:
+    """
+    ConditionalEuclideanClustering class for Sample Consensus methods and models
+    """
+    cdef pclseg.ConditionalEuclideanClustering_t *me
+    def __cinit__(self):
+        self.me = new pclseg.ConditionalEuclideanClustering_t()
+
+    def __dealloc__(self):
+        del self.me
+
diff --git a/pcl/pxi/Segmentation/ConditionalEuclideanClustering_180.pxi b/pcl/pxi/Segmentation/ConditionalEuclideanClustering_180.pxi
new file mode 100644
index 0000000..49f2125
--- /dev/null
+++ b/pcl/pxi/Segmentation/ConditionalEuclideanClustering_180.pxi
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+
+cdef class ConditionalEuclideanClustering:
+    """
+    ConditionalEuclideanClustering class for Sample Consensus methods and models
+    """
+    cdef pclseg.ConditionalEuclideanClustering_t *me
+    def __cinit__(self):
+        self.me = new pclseg.ConditionalEuclideanClustering_t()
+
+    def __dealloc__(self):
+        del self.me
+
diff --git a/pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi b/pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi
new file mode 100644
index 0000000..44127fa
--- /dev/null
+++ b/pcl/pxi/Segmentation/EuclideanClusterExtraction.pxi
@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+cimport pcl_segmentation as pclseg
+cimport pcl_defs as cpp
+from libcpp.vector cimport vector
+
+cdef class EuclideanClusterExtraction:
+    """
+    Segmentation class for EuclideanClusterExtraction
+    """
+    cdef pclseg.EuclideanClusterExtraction_t *me
+    def __cinit__(self):
+        self.me = new pclseg.EuclideanClusterExtraction_t()
+    def __dealloc__(self):
+        del self.me
+    
+    def set_ClusterTolerance(self, double b):
+        self.me.setClusterTolerance(b)
+    
+    def set_MinClusterSize(self, int min):
+        self.me.setMinClusterSize(min)
+    
+    def set_MaxClusterSize(self, int max):
+        self.me.setMaxClusterSize(max)
+    
+    def set_SearchMethod(self, _pcl.KdTree kdtree):
+        self.me.setSearchMethod(kdtree.thisptr_shared)
+    
+    # def set_Search_Method(self, _pcl.KdTreeFLANN kdtree):
+    #    # self.me.setSearchMethod(kdtree.thisptr())
+    #    self.me.setSearchMethod(kdtree.thisptr_shared)
+    
+    # def set_
+    #   self.me.setInputCloud (cloud_filtered)
+    def Extract(self):
+        cdef vector[cpp.PointIndices] inds
+        self.me.extract (inds)
+        # NG(not use Python)
+        # return inds
+        # return 2-dimension Array?
+        # return [inds[0].indices[i] for i in range(inds[0].indices.size())]
+        cdef vector[vector[int]] result
+        cdef vector[int] dim
+        
+        # for j, ind in enumerate(inds):
+        # for ind in inds.iterator:
+        #    for i in range(ind):
+        #        dim.push_back(ind.indices[i])
+        #    result.push_back(dim)
+        # return result
+        
+        # use Iterator
+        # http://cython.readthedocs.io/en/latest/src/userguide/wrapping_CPlusPlus.html
+        # http://stackoverflow.com/questions/29200592/how-to-iterate-throught-c-sets-in-cython
+        # itertools?
+        # http://qiita.com/tomotaka_ito/items/35f3eb108f587022fa09
+        # https://docs.python.org/2/library/itertools.html
+        # set numpy?
+        # http://kesin.hatenablog.com/entry/20120314/1331689014
+        cdef vector[cpp.PointIndices].iterator it = inds.begin()
+        while it != inds.end():
+            idx = deref(it)
+            # for i in range(it.indices.size()):
+            for i in range(idx.indices.size()):
+                dim.push_back(idx.indices[i])
+            result.push_back(dim)
+            inc(it)
+            dim.clear()
+        
+        return result
+
diff --git a/pcl/pxi/Segmentation/MinCutSegmentation_172.pxi b/pcl/pxi/Segmentation/MinCutSegmentation_172.pxi
new file mode 100644
index 0000000..44a1cc7
--- /dev/null
+++ b/pcl/pxi/Segmentation/MinCutSegmentation_172.pxi
@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+
+cdef class MinCutSegmentation:
+    """
+    MinCutSegmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+cdef class Segmentation_PointXYZI:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGB:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGBA:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
diff --git a/pcl/pxi/Segmentation/MinCutSegmentation_180.pxi b/pcl/pxi/Segmentation/MinCutSegmentation_180.pxi
new file mode 100644
index 0000000..44a1cc7
--- /dev/null
+++ b/pcl/pxi/Segmentation/MinCutSegmentation_180.pxi
@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+
+cdef class MinCutSegmentation:
+    """
+    MinCutSegmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+cdef class Segmentation_PointXYZI:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGB:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGBA:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pclseg.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
diff --git a/pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_172.pxi b/pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_172.pxi
new file mode 100644
index 0000000..5d2de37
--- /dev/null
+++ b/pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_172.pxi
@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+
+cdef class ProgressiveMorphologicalFilter:
+    """
+    ProgressiveMorphologicalFilter class for Sample Consensus methods and models
+    """
+    cdef pclseg.ProgressiveMorphologicalFilter_t *me
+    def __cinit__(self):
+        self.me = new pclseg.ProgressiveMorphologicalFilter_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_InputCloud(self, PointCloud cloud):
+        self.me.setInputCloud(b)
+
+    def set_MaxWindowSize(self, size):
+        self.me.setMaxWindowSize(m)
+
+    def set_Slope(self, float param):
+        self.me.setSlope (param)
+
+    def set_InitialDistance(self, float d):
+        self.me.setInitialDistance (d)
+
+    def set_MaxDistance(self, float d):
+        self.me.setMaxDistance (d)
+
+    def extract(self):
+        self.me.extract ()
+
+
+
+
diff --git a/pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_180.pxi b/pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_180.pxi
new file mode 100644
index 0000000..5d2de37
--- /dev/null
+++ b/pcl/pxi/Segmentation/ProgressiveMorphologicalFilter_180.pxi
@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+
+cdef class ProgressiveMorphologicalFilter:
+    """
+    ProgressiveMorphologicalFilter class for Sample Consensus methods and models
+    """
+    cdef pclseg.ProgressiveMorphologicalFilter_t *me
+    def __cinit__(self):
+        self.me = new pclseg.ProgressiveMorphologicalFilter_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_InputCloud(self, PointCloud cloud):
+        self.me.setInputCloud(b)
+
+    def set_MaxWindowSize(self, size):
+        self.me.setMaxWindowSize(m)
+
+    def set_Slope(self, float param):
+        self.me.setSlope (param)
+
+    def set_InitialDistance(self, float d):
+        self.me.setInitialDistance (d)
+
+    def set_MaxDistance(self, float d):
+        self.me.setMaxDistance (d)
+
+    def extract(self):
+        self.me.extract ()
+
+
+
+
diff --git a/pcl/pxi/Segmentation/Segmentation.pxi b/pcl/pxi/Segmentation/Segmentation.pxi
new file mode 100644
index 0000000..f2be8d2
--- /dev/null
+++ b/pcl/pxi/Segmentation/Segmentation.pxi
@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation as pclseg
+cimport pcl_sample_consensus as pcl_sc
+cimport pcl_defs as cpp
+
+cdef class Segmentation:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_MaxIterations(self, int count):
+        self.me.setMaxIterations (count)
+
+cdef class Segmentation_PointXYZI:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGB:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGBA:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
diff --git a/pcl/pxi/Segmentation/SegmentationNormal.pxi b/pcl/pxi/Segmentation/SegmentationNormal.pxi
new file mode 100644
index 0000000..27f1feb
--- /dev/null
+++ b/pcl/pxi/Segmentation/SegmentationNormal.pxi
@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation as pclseg
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus as pcl_sc
+
+# cdef extern from "minipcl.h":
+#     void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,
+#                               double searchRadius,
+#                               cpp.PointCloud_Normal_t) except +
+#     void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,
+#                                  double ax, double ay, double az) except +
+#     void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,
+#                       cpp.PointIndices_t *, bool) except +
+
+
+#yeah, I can't be bothered making this inherit from SACSegmentation, I forget the rules
+#for how this works in cython templated extension types anyway
+cdef class SegmentationNormal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentationFromNormals_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentationFromNormals_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZI_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentationFromNormals_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentationFromNormals_PointXYZI_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZRGB_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentationFromNormals_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGB_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZRGBA_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentationFromNormals_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentationFromNormals_PointXYZRGBA_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
diff --git a/pcl/pxi/Segmentation/SegmentationNormal_172.pxi b/pcl/pxi/Segmentation/SegmentationNormal_172.pxi
new file mode 100644
index 0000000..e4c9b06
--- /dev/null
+++ b/pcl/pxi/Segmentation/SegmentationNormal_172.pxi
@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus_172 as pcl_sc
+
+# cdef extern from "minipcl.h":
+#     void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,
+#                               double searchRadius,
+#                               cpp.PointCloud_Normal_t) except +
+#     void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,
+#                                  double ax, double ay, double az) except +
+#     void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,
+#                       cpp.PointIndices_t *, bool) except +
+
+
+#yeah, I can't be bothered making this inherit from SACSegmentation, I forget the rules
+#for how this works in cython templated extension types anyway
+cdef class SegmentationNormal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentationNormal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentationNormal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZI_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentation_PointXYZI_Normal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZI_Normal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZRGB_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGB_Normal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGB_Normal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZRGBA_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGBA_Normal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGBA_Normal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
diff --git a/pcl/pxi/Segmentation/SegmentationNormal_180.pxi b/pcl/pxi/Segmentation/SegmentationNormal_180.pxi
new file mode 100644
index 0000000..e4c9b06
--- /dev/null
+++ b/pcl/pxi/Segmentation/SegmentationNormal_180.pxi
@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_defs as cpp
+cimport pcl_sample_consensus_172 as pcl_sc
+
+# cdef extern from "minipcl.h":
+#     void mpcl_compute_normals(cpp.PointCloud_t, int ksearch,
+#                               double searchRadius,
+#                               cpp.PointCloud_Normal_t) except +
+#     void mpcl_sacnormal_set_axis(pclseg.SACSegmentationNormal_t,
+#                                  double ax, double ay, double az) except +
+#     void mpcl_extract(cpp.PointCloudPtr_t, cpp.PointCloud_t *,
+#                       cpp.PointIndices_t *, bool) except +
+
+
+#yeah, I can't be bothered making this inherit from SACSegmentation, I forget the rules
+#for how this works in cython templated extension types anyway
+cdef class SegmentationNormal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentationNormal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentationNormal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZI_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentation_PointXYZI_Normal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZI_Normal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZRGB_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGB_Normal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGB_Normal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
+
+cdef class Segmentation_PointXYZRGBA_Normal:
+    """
+    Segmentation class for Sample Consensus methods and models that require the
+    use of surface normals for estimation.
+
+    Due to Cython limitations this should derive from pcl.Segmentation, but
+    is currently unable to do so.
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGBA_Normal_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGBA_Normal_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())],\
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients (b)
+    def set_normal_distance_weight(self, float f):
+        self.me.setNormalDistanceWeight (f)
+    def set_max_iterations(self, int i):
+        self.me.setMaxIterations (i)
+    def set_radius_limits(self, float f1, float f2):
+        self.me.setRadiusLimits (f1, f2)
+    def set_eps_angle(self, double ea):
+        self.me.setEpsAngle (ea)
+#     def set_axis(self, double ax, double ay, double az):
+#         mpcl_sacnormal_set_axis(deref(self.me),ax,ay,az)
+    def set_min_max_opening_angle(self, double min_angle, double max_angle):
+        """ Set the minimum and maximum cone opening angles in radians for a cone model.
+        """
+        self.me.setMinMaxOpeningAngle(min_angle, max_angle)
+    def get_min_max_opening_angle(self):
+        min_angle = 0.0
+        max_angle = 0.0
+        self.me.getMinMaxOpeningAngle(min_angle, max_angle)
+        return min_angle, max_angle
+
diff --git a/pcl/pxi/Segmentation/Segmentation_172.pxi b/pcl/pxi/Segmentation/Segmentation_172.pxi
new file mode 100644
index 0000000..be21360
--- /dev/null
+++ b/pcl/pxi/Segmentation/Segmentation_172.pxi
@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_sample_consensus_172 as pcl_sc
+cimport pcl_defs as cpp
+
+cdef class Segmentation:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_MaxIterations(self, int count):
+        self.me.setMaxIterations (count)
+
+cdef class Segmentation_PointXYZI:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGB:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGBA:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
diff --git a/pcl/pxi/Segmentation/Segmentation_180.pxi b/pcl/pxi/Segmentation/Segmentation_180.pxi
new file mode 100644
index 0000000..be21360
--- /dev/null
+++ b/pcl/pxi/Segmentation/Segmentation_180.pxi
@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+cimport pcl_segmentation_172 as pclseg
+cimport pcl_sample_consensus_172 as pcl_sc
+cimport pcl_defs as cpp
+
+cdef class Segmentation:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+    def set_MaxIterations(self, int count):
+        self.me.setMaxIterations (count)
+
+cdef class Segmentation_PointXYZI:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGB:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
+
+cdef class Segmentation_PointXYZRGBA:
+    """
+    Segmentation class for Sample Consensus methods and models
+    """
+    cdef pclseg.SACSegmentation_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclseg.SACSegmentation_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def segment(self):
+        cdef cpp.PointIndices ind
+        cdef cpp.ModelCoefficients coeffs
+        
+        self.me.segment (ind, coeffs)
+        return [ind.indices[i] for i in range(ind.indices.size())], \
+               [coeffs.values[i] for i in range(coeffs.values.size())]
+
+    def set_optimize_coefficients(self, bool b):
+        self.me.setOptimizeCoefficients(b)
+    def set_model_type(self, pcl_sc.SacModel m):
+        self.me.setModelType(m)
+    def set_method_type(self, int m):
+        self.me.setMethodType (m)
+    def set_distance_threshold(self, float d):
+        self.me.setDistanceThreshold (d)
+
diff --git a/pcl/pxi/Surface/AddList.txt b/pcl/pxi/Surface/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/Surface/AddList.txt
diff --git a/pcl/pxi/Surface/ConcaveHull.pxi b/pcl/pxi/Surface/ConcaveHull.pxi
new file mode 100644
index 0000000..724ae68
--- /dev/null
+++ b/pcl/pxi/Surface/ConcaveHull.pxi
@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+cimport pcl_surface as pclsf
+cimport pcl_defs as cpp
+
+cdef class ConcaveHull:
+    """
+    ConcaveHull class for ...
+    """
+    cdef pclsf.ConcaveHull_t *me
+    def __cinit__(self):
+        self.me = new pclsf.ConcaveHull_t()
+    def __dealloc__(self):
+        del self.me
+
+    def reconstruct(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.reconstruct(pc.thisptr()[0])
+        return pc
+
+    def set_Alpha(self, double d):
+        self.me.setAlpha (d)
+
+cdef class ConcaveHull_PointXYZI:
+    """
+    ConcaveHull class for ...
+    """
+    cdef pclsf.ConcaveHull_PointXYZI_t *me
+    def __cinit__(self):
+        self.me = new pclsf.ConcaveHull_PointXYZI_t()
+    def __dealloc__(self):
+        del self.me
+
+    def reconstruct(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+        self.me.reconstruct(pc.thisptr()[0])
+        return pc
+
+    def set_Alpha(self, double d):
+        self.me.setAlpha (d)
+
+
+cdef class ConcaveHull_PointXYZRGB:
+    """
+    ConcaveHull class for ...
+    """
+    cdef pclsf.ConcaveHull_PointXYZRGB_t *me
+    def __cinit__(self):
+        self.me = new pclsf.ConcaveHull_PointXYZRGB_t()
+    def __dealloc__(self):
+        del self.me
+
+    def reconstruct(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.reconstruct(pc.thisptr()[0])
+        return pc
+
+    def set_Alpha(self, double d):
+        self.me.setAlpha (d)
+
+
+cdef class ConcaveHull_PointXYZRGBA:
+    """
+    ConcaveHull class for ...
+    """
+    cdef pclsf.ConcaveHull_PointXYZRGBA_t *me
+    def __cinit__(self):
+        self.me = new pclsf.ConcaveHull_PointXYZRGBA_t()
+    def __dealloc__(self):
+        del self.me
+
+    def reconstruct(self):
+        """
+        Apply the filter according to the previously set parameters and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.reconstruct(pc.thisptr()[0])
+        return pc
+
+    def set_Alpha(self, double d):
+        self.me.setAlpha (d)
+
diff --git a/pcl/pxi/Surface/MovingLeastSquares.pxi b/pcl/pxi/Surface/MovingLeastSquares.pxi
new file mode 100644
index 0000000..b3fbe6a
--- /dev/null
+++ b/pcl/pxi/Surface/MovingLeastSquares.pxi
@@ -0,0 +1,192 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_surface as pclsf
+cimport pcl_kdtree as pclkdt
+
+cdef class MovingLeastSquares:
+    """
+    Smoothing class which is an implementation of the MLS (Moving Least Squares)
+    algorithm for data smoothing and improved normal estimation.
+    """
+    cdef pclsf.MovingLeastSquares_t *me
+    
+    def __cinit__(self):
+        self.me = new pclsf.MovingLeastSquares_t()
+    
+    def __dealloc__(self):
+        del self.me
+    
+    def set_search_radius(self, double radius):
+        """
+        Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. 
+        """
+        self.me.setSearchRadius (radius)
+    
+    def set_polynomial_order(self, bool order):
+        """
+        Set the order of the polynomial to be fit. 
+        """
+        self.me.setPolynomialOrder(order)
+    
+    def set_polynomial_fit(self, bool fit):
+        """
+        Sets whether the surface and normal are approximated using a polynomial,
+        or only via tangent estimation.
+        """
+        self.me.setPolynomialFit(fit)
+    
+    def set_Compute_Normals(self, bool flag):
+        self.me.setComputeNormals(flag)
+    
+    def set_Search_Method(self, _pcl.KdTree kdtree):
+       # self.me.setSearchMethod(kdtree.thisptr()[0])
+       # self.me.setSearchMethod(kdtree.thisptr())
+       self.me.setSearchMethod(kdtree.thisptr_shared)
+    
+    # def set_Search_Method(self, _pcl.KdTreeFLANN kdtree):
+    #    # self.me.setSearchMethod(kdtree.thisptr())
+    #    self.me.setSearchMethod(kdtree.thisptr_shared)
+    
+    def process(self):
+        """
+        Apply the smoothing according to the previously set values and return
+        a new PointCloud
+        """
+        cdef PointCloud pc = PointCloud()
+        self.me.process(pc.thisptr()[0])
+        return pc
+        # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+        # self.me.process(pcNormal.thisptr()[0])
+        # return pcNormal
+
+
+# cdef class MovingLeastSquares_PointXYZI:
+#     """
+#     Smoothing class which is an implementation of the MLS (Moving Least Squares)
+#     algorithm for data smoothing and improved normal estimation.
+#     """
+#     cdef pclsf.MovingLeastSquares_PointXYZI_t *me
+#     
+#     def __cinit__(self):
+#         self.me = new pclsf.MovingLeastSquares_PointXYZI_t()
+#     def __dealloc__(self):
+#         del self.me
+# 
+#     def set_search_radius(self, double radius):
+#         """
+#         Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. 
+#         """
+#         self.me.setSearchRadius (radius)
+# 
+#     def set_polynomial_order(self, bool order):
+#         """
+#         Set the order of the polynomial to be fit. 
+#         """
+#         self.me.setPolynomialOrder(order)
+# 
+#     def set_polynomial_fit(self, bint fit):
+#         """
+#         Sets whether the surface and normal are approximated using a polynomial,
+#         or only via tangent estimation.
+#         """
+#         self.me.setPolynomialFit(fit)
+# 
+#     def process(self):
+#         """
+#         Apply the smoothing according to the previously set values and return
+#         a new pointcloud
+#         """
+#         cdef PointCloud_PointXYZI pc = PointCloud_PointXYZI()
+#         self.me.process(pc.thisptr()[0])
+#         return pc
+
+
+cdef class MovingLeastSquares_PointXYZRGB:
+    """
+    Smoothing class which is an implementation of the MLS (Moving Least Squares)
+    algorithm for data smoothing and improved normal estimation.
+    """
+    cdef pclsf.MovingLeastSquares_PointXYZRGB_t *me
+    
+    def __cinit__(self):
+        self.me = new pclsf.MovingLeastSquares_PointXYZRGB_t()
+    
+    def __dealloc__(self):
+        del self.me
+    
+    def set_search_radius(self, double radius):
+        """
+        Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. 
+        """
+        self.me.setSearchRadius (radius)
+    
+    def set_polynomial_order(self, bool order):
+        """
+        Set the order of the polynomial to be fit. 
+        """
+        self.me.setPolynomialOrder(order)
+    
+    def set_polynomial_fit(self, bint fit):
+        """
+        Sets whether the surface and normal are approximated using a polynomial,
+        or only via tangent estimation.
+        """
+        self.me.setPolynomialFit(fit)
+    
+    def process(self):
+        """
+        Apply the smoothing according to the previously set values and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGB pc = PointCloud_PointXYZRGB()
+        self.me.process(pc.thisptr()[0])
+        return pc
+        # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+        # self.me.process(pcNormal.thisptr()[0])
+        # return pcNormal
+
+cdef class MovingLeastSquares_PointXYZRGBA:
+    """
+    Smoothing class which is an implementation of the MLS (Moving Least Squares)
+    algorithm for data smoothing and improved normal estimation.
+    """
+    cdef pclsf.MovingLeastSquares_PointXYZRGBA_t *me
+    
+    def __cinit__(self):
+        self.me = new pclsf.MovingLeastSquares_PointXYZRGBA_t()
+    
+    def __dealloc__(self):
+        del self.me
+    
+    def set_search_radius(self, double radius):
+        """
+        Set the sphere radius that is to be used for determining the k-nearest neighbors used for fitting. 
+        """
+        self.me.setSearchRadius (radius)
+    
+    def set_polynomial_order(self, bool order):
+        """
+        Set the order of the polynomial to be fit. 
+        """
+        self.me.setPolynomialOrder(order)
+    
+    def set_polynomial_fit(self, bint fit):
+        """
+        Sets whether the surface and normal are approximated using a polynomial,
+        or only via tangent estimation.
+        """
+        self.me.setPolynomialFit(fit)
+    
+    def process(self):
+        """
+        Apply the smoothing according to the previously set values and return
+        a new pointcloud
+        """
+        cdef PointCloud_PointXYZRGBA pc = PointCloud_PointXYZRGBA()
+        self.me.process(pc.thisptr()[0])
+        return pc
+        # cdef PointCloud_PointNormal pcNormal = PointCloud_PointNormal()
+        # self.me.process(pcNormal.thisptr()[0])
+        # return pcNormal
+
diff --git a/pcl/pxi/Tracking/AddList.txt b/pcl/pxi/Tracking/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/Tracking/AddList.txt
diff --git a/pcl/pxi/Vertices.pxi b/pcl/pxi/Vertices.pxi
new file mode 100644
index 0000000..baa7c06
--- /dev/null
+++ b/pcl/pxi/Vertices.pxi
@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+# main
+cimport pcl_defs as cpp
+cimport numpy as cnp
+
+cdef class Vertices:
+    """
+    """
+    # cdef cpp.Vertices *me
+
+    def __cinit__(self, init=None):
+        # cdef cpp.Vertices vertices
+        self._view_count = 0
+        
+        # self.me = new cpp.Vertices()
+        # sp_assign(<cpp.shared_ptr[cpp.Vertices]> self.thisptr_shared, new cpp.Vertices())
+        sp_assign(self.thisptr_shared, new cpp.Vertices())
+        
+        if init is None:
+            return
+        # elif isinstance(init, (numbers.Integral, np.integer)):
+        #      self.resize(init)
+        # elif isinstance(init, np.ndarray):
+        #      self.from_array(init)
+        # elif isinstance(init, Sequence):
+        #      self.from_list(init)
+        # elif isinstance(init, type(self)):
+        #      other = init
+        #      self.thisptr()[0] = other.thisptr()[0]
+        else:
+            raise TypeError("Can't initialize a PointCloud from a %s" % type(init))
+
+    # property vertices:
+    #     """ property containing the vertices of the Vertices """
+    #     def __get__(self): return self.thisptr().vertices
+
+    def __repr__(self):
+        return "<Vertices of %d points>" % self.vertices.size()
+
+    @cython.boundscheck(False)
+    def from_array(self, cnp.ndarray[cnp.int_t, ndim=1] arr not None):
+        """
+        Fill this object from a 2D numpy array (float32)
+        """
+        cdef cnp.npy_intp npts = arr.shape[0]
+        
+        # cdef cpp.Vertices *p
+        for i in range(npts):
+            self.thisptr().vertices.push_back(arr[i])
+
+    @cython.boundscheck(False)
+    def to_array(self):
+        """
+        Return this object as a 2D numpy array (float32)
+        """
+        cdef float index
+        cdef cnp.npy_intp n = self.thisptr().vertices.size()
+        cdef cnp.ndarray[cnp.int, ndim=1, mode="c"] result
+        cdef cpp.Vertices *p
+        
+        result = np.empty((n, 1), dtype=np.float32)
+        for i in range(n):
+            result[i, 0] = self.thisptr().vertices.at(i)
+        
+        return result
+
+    def from_list(self, _list):
+        """
+        Fill this pointcloud from a list of 3-tuples
+        """
+        cdef Py_ssize_t npts = len(_list)
+        self.resize(npts)
+        # self.thisptr().width = npts
+        # self.thisptr().height = 1
+        cdef cpp.Vertices* p
+        # enumerate ? -> i -> type unknown
+        # for i, l in enumerate(_list):
+        #      p = idx.getptr(self.thisptr(), <int> i)
+        #      p.x, p.y, p.z = l
+
+    def to_list(self):
+        """
+        Return this object as a list of 3-tuples
+        """
+        return self.to_array().tolist()
+
+    def resize(self, cnp.npy_intp x):
+        if self._view_count > 0:
+            raise ValueError("can't resize Vertices while there are"
+                             " arrays/memoryviews referencing it")
+        self.thisptr().vertices.resize(x)
+###
diff --git a/pcl/pxi/Visualization/AddList.txt b/pcl/pxi/Visualization/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/Visualization/AddList.txt
diff --git a/pcl/pxi/Visualization/CloudViewing.pxi b/pcl/pxi/Visualization/CloudViewing.pxi
new file mode 100644
index 0000000..dccfb52
--- /dev/null
+++ b/pcl/pxi/Visualization/CloudViewing.pxi
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+cimport pcl_defs as cpp
+cimport numpy as cnp
+
+cimport pcl_visualization_defs as pclvis
+from boost_shared_ptr cimport sp_assign
+
+cdef class CloudViewing:
+    """
+    """
+    # cdef pclvis.CloudViewer *me
+    cdef pclvis.CloudViewerPtr_t thisptr_shared
+
+    def __cinit__(self):
+        # self.me = new pclvis.CloudViewer()
+        # sp_assign(<cpp.shared_ptr[pclvis.CloudViewer]> self.thisptr_shared, new pclvis.CloudViewer('cloud'))
+        sp_assign(self.thisptr_shared, new pclvis.CloudViewer('cloud'))
+
+    cdef inline pclvis.CloudViewer *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying CloudViewer
+        return self.thisptr_shared.get()
+
+    def ShowMonochromeCloud(self, _pcl.PointCloud pc, cloudname=b'cloud'):
+        self.thisptr().showCloud(pc.thisptr_shared, <string> cloudname)
+
+    def ShowGrayCloud(self, _pcl.PointCloud_PointXYZI pc, cloudname='cloud'):
+        self.thisptr().showCloud(pc.thisptr_shared, <string> cloudname)
+
+    def ShowColorCloud(self, _pcl.PointCloud_PointXYZRGB pc, cloudname='cloud'):
+        self.thisptr().showCloud(pc.thisptr_shared, <string> cloudname)
+
+    def ShowColorACloud(self, _pcl.PointCloud_PointXYZRGBA pc, cloudname='cloud'):
+        self.thisptr().showCloud(pc.thisptr_shared, <string> cloudname)
+
+    def WasStopped(self, int millis_to_wait = 1):
+        return self.thisptr().wasStopped(millis_to_wait)
+
+    # def SpinOnce(self, int millis_to_wait = 1):
+    #     self.thisptr().spinOnce (millis_to_wait)
+
+    # def OffScreenRendering(bool flag)
+    #     self.thisptr().offScreenRendering (flag)
diff --git a/pcl/pxi/Visualization/Handler/PointCloudColorHandleringCustom.pxi b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringCustom.pxi
new file mode 100644
index 0000000..b8ea82c
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringCustom.pxi
@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_visualization

+from _pcl cimport PointCloud_PointWithViewpoint

+from _pcl cimport RangeImages

+cimport pcl_defs as cpp

+cimport numpy as cnp
+


+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudColorHandleringCustom:

+    """

+    """

+    # cdef pcl_vis.PointCloudColorHandlerCustom_t *me

+

+    def __cinit__(self):

+        pass

+

+    # void sp_assign[T](shared_ptr[T] &p, T *value)

+    def __cinit__(self, _pcl.PointCloud pc, int r, int g, int b):

+        sp_assign(self.thisptr_shared, new pcl_vis.PointCloudColorHandlerCustom[cpp.PointXYZ](pc.thisptr_shared, r, g, b))

+        pass

+

+    # def __cinit__(self, _pcl.RangeImages rangeImage, int r, int g, int b):

+    #     sp_assign(self.thisptr_shared, new pcl_vis.PointCloudColorHandlerCustom[cpp.PointWithViewpoint](rangeImage.thisptr_shared, r, g, b))

+    #     pass

+

+    def __dealloc__(self):

+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/Handler/PointCloudColorHandleringGenericField.pxi b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringGenericField.pxi
new file mode 100644
index 0000000..ffe9971
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringGenericField.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudColorHandleringGenericField:

+    """

+    """

+    cdef pcl_vis.PointCloudColorHandlerGenericField_t *me

+    

+    def __cinit__(self):

+        print('__cinit__')

+        pass

+    

+    def __dealloc__(self):

+        print('__dealloc__')
+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/Handler/PointCloudColorHandleringHSVField.pxi b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringHSVField.pxi
new file mode 100644
index 0000000..57f71b1
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringHSVField.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudColorHandleringHSVField:

+    """

+    """

+    cdef pcl_vis.PointCloudColorHandlerHSVField_t *me

+    

+    def __cinit__(self):

+        print('__cinit__')

+        pass

+    

+    def __dealloc__(self):

+        print('__dealloc__')
+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/Handler/PointCloudColorHandleringRGBField.pxi b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringRGBField.pxi
new file mode 100644
index 0000000..304c4ba
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringRGBField.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudColorHandleringRGBField:

+    """

+    """

+    cdef pcl_vis.PointCloudColorHandlerRGBField_t *me

+    

+    def __cinit__(self):

+        print('__cinit__')

+        pass

+    

+    def __dealloc__(self):

+        print('__dealloc__')
+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/Handler/PointCloudColorHandleringRandom.pxi b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringRandom.pxi
new file mode 100644
index 0000000..9bd195b
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudColorHandleringRandom.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudColorHandleringRandom:

+    """

+    """

+    cdef pcl_vis.PointCloudColorHandlerRandom_t *me

+    

+    def __cinit__(self):

+        print('__cinit__')

+        pass

+    

+    def __dealloc__(self):

+        print('__dealloc__')
+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringCustom.pxi b/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringCustom.pxi
new file mode 100644
index 0000000..23d9552
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringCustom.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudGeometryHandlerCustom:

+    """

+    """

+    cdef pcl_vis.PointCloudGeometryHandlerCustom_t *me

+    

+    def __cinit__(self):

+        print('__cinit__')

+        pass

+    

+    def __dealloc__(self):

+        print('__dealloc__')
+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringSurfaceNormal.pxi b/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringSurfaceNormal.pxi
new file mode 100644
index 0000000..3df6396
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringSurfaceNormal.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudGeometryHandleringSurfaceNormal:

+    """

+    """

+    cdef pcl_vis.PointCloudGeometryHandlerSurfaceNormal_t *me

+    

+    def __cinit__(self):

+        print('__cinit__')

+        pass

+    

+    def __dealloc__(self):

+        print('__dealloc__')
+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringXYZ.pxi b/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringXYZ.pxi
new file mode 100644
index 0000000..a0b7ee3
--- /dev/null
+++ b/pcl/pxi/Visualization/Handler/PointCloudGeometryHandleringXYZ.pxi
@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+from boost_shared_ptr cimport sp_assign

+

+cdef class PointCloudGeometryHandleringXYZ:

+    """

+    """

+    cdef pcl_vis.PointCloudGeometryHandlerXYZ_t *me

+    

+    def __cinit__(self):

+        print('__cinit__')

+        pass

+    

+    def __dealloc__(self):

+        print('__dealloc__')
+        # del self.me

+        pass
+


+

diff --git a/pcl/pxi/Visualization/PCLHistogramViewing.pxi b/pcl/pxi/Visualization/PCLHistogramViewing.pxi
new file mode 100644
index 0000000..15af51e
--- /dev/null
+++ b/pcl/pxi/Visualization/PCLHistogramViewing.pxi
@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# main
+cimport _pcl
+cimport pcl_defs as cpp
+cimport numpy as cnp
+
+cimport pcl_visualization_defs as pclvis
+from boost_shared_ptr cimport sp_assign
+
+cdef class PCLHistogramViewing:
+    """
+    """
+    cdef pclvis.PCLHistogramVisualizerPtr_t thisptr_shared
+
+    def __cinit__(self):
+        sp_assign(self.thisptr_shared, new pclvis.PCLHistogramVisualizer())
+
+    cdef inline pclvis.PCLHistogramVisualizer *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PCLHistogramVisualizer
+        return self.thisptr_shared.get()
+
+    def SpinOnce(self, int time = 1, bool force_redraw = False):
+        self.thisptr().spinOnce()
+
+    # self.thisptr().addFeatureHistogram[PointT](shared_ptr[cpp.PointCloud[PointT]] &cloud, int hsize, string cloudname, int win_width, int win_height)
+    def AddFeatureHistogram(self, _pcl.PointCloud cloud, int hsize, cloudname, int win_width = 640, int win_height = 200):
+        # self.thisptr().addFeatureHistogram[cpp.PointXYZ](<cpp.PointCloudPtr_t> cloud.thisptr_shared, hsize, cloudname, win_width, win_height);
+        # self.thisptr().addFeatureHistogram[cpp.PointXYZ](<cpp.PointCloudPtr_t> cloud.thisptr_shared, <string> cloudname, 0, "test", win_width, win_height)
+        # NG(build ok use NG)
+        # visualization/impl/histogram_visualizer.hpp
+        # xy[1] = cloud.points[0].histogram[d]
+        # 
+        # self.thisptr().addFeatureHistogram[cpp.PointXYZ](<const cpp.PointCloud[cpp.PointXYZ]&> cloud.thisptr_shared, hsize, cloudname, win_width, win_height)
+        pass
+
+    # def AddFeatureHistogram(self, _pcl.PointCloud_PointXYZRGB cloud, int hsize, cloudname):
+    #     # self.thisptr().addFeatureHistogram[PointT](shared_ptr[cpp.PointCloud[PointT]] &cloud, int hsize, cloudname, int win_width, int win_height)
+    #     self.thisptr().addFeatureHistogram(<cpp.PointCloudPtr_t> cloud.thisptr_shared, hsize, <string> cloudname, 640, 200)
+
+    def Spin (self):
+        self.thisptr().spin()
+
diff --git a/pcl/pxi/Visualization/PCLVisualizering.pxi b/pcl/pxi/Visualization/PCLVisualizering.pxi
new file mode 100644
index 0000000..a9cc89a
--- /dev/null
+++ b/pcl/pxi/Visualization/PCLVisualizering.pxi
@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+cimport _pcl
+cimport pcl_defs as cpp
+cimport numpy as cnp
+
+cimport cython
+cimport pcl_visualization
+
+cimport pcl_visualization_defs as pclvis
+
+from libcpp.string cimport string
+
+from boost_shared_ptr cimport shared_ptr
+from boost_shared_ptr cimport sp_assign
+
+
+cdef class PCLVisualizering:
+    """
+    """
+    cdef pclvis.PCLVisualizerPtr_t thisptr_shared
+    
+    def __cinit__(self):
+        sp_assign(self.thisptr_shared, new pclvis.PCLVisualizer('visual', True))
+
+    cdef inline pclvis.PCLVisualizer *thisptr(self) nogil:
+        # Shortcut to get raw pointer to underlying PCLVisualizer
+        return self.thisptr_shared.get()
+
+    def SetFullScreen(self, bool mode):
+        self.thisptr().setFullScreen(mode)
+
+    def SetWindowBorders(self, bool mode):
+        self.thisptr().setWindowBorders(mode)
+
+    def Spin(self):
+        self.thisptr().spin()
+
+    def SpinOnce(self, int millis_to_wait = 1, bool force_redraw = False):
+        self.thisptr().spinOnce (millis_to_wait, force_redraw)
+
+    def AddCoordinateSystem(self, double scale = 1.0, int viewpoint = 0):
+        self.thisptr().addCoordinateSystem(scale, viewpoint)
+
+    def AddCoordinateSystem(self, double scale, float x, float y, float z, int viewpoint = 0):
+        self.thisptr().addCoordinateSystem(scale, x, y, z, viewpoint)
+
+    # void addCoordinateSystem (double scale, const eigen3.Affine3f& t, int viewport)
+
+    # return bool
+    def removeCoordinateSystem (self, int viewport):
+        return self.thisptr().removeCoordinateSystem (viewport)
+
+    # return bool
+    def RemovePointCloud(self, string id, int viewport):
+        return self.thisptr().removePointCloud (id, viewport)
+
+    def RemovePolygonMesh(self, string id, int viewport):
+        return self.thisptr().removePolygonMesh (id, viewport)
+
+    def RemoveShape(self, string id, int viewport):
+        return self.thisptr().removeShape (id, viewport)
+
+    def RemoveText3D(self, string id, int viewport):
+        return self.thisptr().removeText3D (id, viewport)
+
+    def RemoveAllPointClouds(self, int viewport):
+        return self.thisptr().removeAllPointClouds (viewport)
+
+    def RemoveAllShapes(self, int viewport):
+        return self.thisptr().removeAllShapes (viewport)
+
+    def SetBackgroundColor (self, int r, int g, int b):
+        self.thisptr().setBackgroundColor(r, g, b, 0)
+
+    # return bool
+    def AddText (self, string text, int xpos, int ypos, id, int viewport):
+        return self.thisptr().addText (text, xpos, ypos, <string> id, viewport)
+
+    # return bool
+    def AddText (self, string text, int xpos, int ypos, double r, double g, double b, id, int viewport):
+        return self.thisptr().addText (text, xpos, ypos, r, g, b, <string> id, viewport)
+
+    # return bool
+    def AddText (self, string text, int xpos, int ypos, int fontsize, double r, double g, double b, id, int viewport):
+        return self.thisptr().addText (text, xpos, ypos, fontsize, r, g, b, <string> id, viewport)
+
+    # return bool
+    # def UpdateText (self, string text, int xpos, int ypos, const string &id):
+    def UpdateText (self, string text, int xpos, int ypos, id):
+        return self.thisptr().updateText (text, xpos, ypos, <string> id)
+
+    # return bool
+    # def UpdateText (self, string text, int xpos, int ypos, double r, double g, double b, const string &id):
+    def UpdateText (self, string text, int xpos, int ypos, double r, double g, double b, id):
+        return self.thisptr().updateText (text, xpos, ypos,  r,  g,  b, <string> id)
+
+    # return bool
+    # def UpdateText (self, string text, int xpos, int ypos, int fontsize, double r, double g, double b, const string &id):
+    def UpdateText (self, string text, int xpos, int ypos, int fontsize, double r, double g, double b, id):
+        return self.thisptr().updateText (text, xpos, ypos, fontsize, r, g, b, <string> id)
+
+    # bool updateShapePose (const string &id, const eigen3.Affine3f& pose)
+    
+    # return bool
+    # def AddText3D[PointT](const string &text, const PointT &position, double textScale, double r, double g, double b, const string &id, int viewport)
+    #     return self.thisptr().AddText3D[PointT](const string &text, const PointT &position, double textScale, double r, double g, double b, const string &id, int viewport)
+
+    # bool addPointCloudNormals [PointNT](cpp.PointCloud[PointNT] cloud, int level, double scale, string id, int viewport)
+    # bool addPointCloudNormals [PointT, PointNT] (const shared_ptr[cpp.PointCloud[PointT]] &cloud, const shared_ptr[cpp.PointCloud[PointNT]] &normals, int level, double scale, const string &id, int viewport)
+
+    # bool updatePointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, string &id)
+    # bool updatePointCloud[PointT](const shared_ptr[cpp.PointCloud[PointT]] &cloud, const PointCloudGeometryHandler[PointT] &geometry_handler, string &id)
+
+    # def updatePointCloud(self, _pcl.PointCloud cloud, string id = 'cloud'):
+    #     flag = self.thisptr().updatePointCloud[cpp.PointXYZ](<cpp.PointCloudPtr_t> cloud.thisptr_shared, id)
+    #     return flag
+
+    # def AddPointCloud (self, _pcl.PointCloud cloud, string id = 'cloud', int viewport = 0):
+    # call (ex. id=b'range image')
+    def AddPointCloud (self, _pcl.PointCloud cloud, id = b'cloud', int viewport = 0):
+        self.thisptr().addPointCloud(cloud.thisptr_shared, <string> id, viewport)
+        pass
+
+    # <const shared_ptr[PointCloudColorHandler[PointT]]> 
+    # def AddPointCloud_ColorHandler(self, _pcl.PointCloud cloud, pcl_visualization.PointCloudColorHandleringCustom color_handler, string id = 'cloud', int viewport = 0):
+    def AddPointCloud_ColorHandler(self, _pcl.PointCloud cloud, pcl_visualization.PointCloudColorHandleringCustom color_handler, id = b'cloud', viewport = 0):
+        # NG : Base Class
+        # self.thisptr().addPointCloud[cpp.PointXYZ](cloud.thisptr_shared, <const pclvis.PointCloudColorHandler[cpp.PointXYZ]> deref(color_handler.thisptr_shared.get()), id, viewport)
+        # OK? : Inheritance Class(PointCloudColorHandler)
+        # self.thisptr().addPointCloud[cpp.PointXYZ](cloud.thisptr_shared, <const pclvis.PointCloudColorHandlerCustom[cpp.PointXYZ]> deref(color_handler.thisptr_shared.get()), id, viewport)
+        self.thisptr().addPointCloud[cpp.PointXYZ](cloud.thisptr_shared, <const pclvis.PointCloudColorHandlerCustom[cpp.PointXYZ]> deref(color_handler.thisptr_shared.get()), <string> id, viewport)
+        pass
+
+    def AddPointCloud_ColorHandler(self, _pcl.RangeImages cloud, pcl_visualization.PointCloudColorHandleringCustom color_handler, id = b'cloud', int viewport = 0):
+        # self.thisptr().addPointCloud[cpp.PointWithRange](cloud.thisptr_shared, <const pclvis.PointCloudColorHandlerCustom[cpp.PointXYZ]> deref(color_handler.thisptr_shared.get()), id, viewport)
+        pass
+
+    # <const shared_ptr[PointCloudGeometryHandler[PointT]]> 
+    # def AddPointCloud_GeometryHandler(self, _pcl.PointCloud cloud, pcl_visualization.PointCloudGeometryHandleringCustom geometry_handler, id = b'cloud', int viewport = 0):
+    #     # overloaded
+    #     self.thisptr().addPointCloud[cpp.PointXYZ](cloud.thisptr_shared, <const pclvis.PointCloudGeometryHandlerCustom[cpp.PointXYZ]> deref(geometry_handler.thisptr_shared.get()), <string> id, viewport)
+    #     # pass
+
+    def AddPointCloudNormals(self, _pcl.PointCloud cloud, _pcl.PointCloud_Normal normal, int level = 100, double scale = 0.02, id = b'cloud', int viewport = 0):
+        self.thisptr().addPointCloudNormals[cpp.PointXYZ, cpp.Normal](<cpp.PointCloudPtr_t> cloud.thisptr_shared, <cpp.PointCloud_Normal_Ptr_t> normal.thisptr_shared, level, scale, <string> id, viewport)
+
+    def SetPointCloudRenderingProperties(self, int propType, int propValue, propName = b'cloud'):
+        self.thisptr().setPointCloudRenderingProperties (propType, propValue, <string> propName, 0)
+
+    def InitCameraParameters(self):
+        self.thisptr().initCameraParameters()
+
+    # return bool
+    def WasStopped(self):
+        return self.thisptr().wasStopped()
+
+    def ResetStoppedFlag(self):
+        self.thisptr().resetStoppedFlag()
+
+    def Close(self):
+        self.thisptr().close ()
+
+    # def AddCube(self, double min_x, double max_x, double min_y, double max_y, double min_z, double max_z, double r, double g, double b, string name):
+    def AddCube(self, double min_x, double max_x, double min_y, double max_y, double min_z, double max_z, double r, double g, double b, name):
+        self.thisptr().addCube(min_x,  max_x,  min_y,  max_y,  min_z,  max_z, r, g, b, name, 0)
+
+    # def AddLine(self, _pcl.PointCloud center, _pcl.PointCloud axis, double x, double y, double z, id = b'minor eigen vector')
+    #     # pcl::PointXYZ
+    #     self.thisptr().addLine(center, z_axis, 0.0, 0.0, 1.0, id)
+
+    def AddCone(self):
+        # self.thisptr().addCone()
+        pass
+
+    def AddCircle(self):
+        # self.thisptr().addCone()
+        pass
+
+    def AddPlane(self):
+        # self.thisptr().addPlane()
+        pass
+
+    def AddLine(self):
+        # self.thisptr().addLine()
+        pass
+
+    def AddSphere(self):
+        # self.thisptr().addSphere()
+        pass
+
+    def AddCylinder(self):
+        # self.thisptr().addCylinder()
+        pass
+
+    def AddCircle(self):
+        # self.thisptr().addCone()
+        pass
diff --git a/pcl/pxi/Visualization/RangeImageVisualization.pxi b/pcl/pxi/Visualization/RangeImageVisualization.pxi
new file mode 100644
index 0000000..31d41da
--- /dev/null
+++ b/pcl/pxi/Visualization/RangeImageVisualization.pxi
@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-

+cimport _pcl

+cimport pcl_defs as cpp

+cimport numpy as cnp

+

+cimport pcl_visualization_defs as pcl_vis

+cimport pcl_range_image as pcl_rngimg

+

+from boost_shared_ptr cimport sp_assign

+
+cdef class RangeImageVisualization:

+    """

+    RangeImageVisualization

+    """

+    cdef pcl_vis.RangeImageVisualizer *me

+    def __cinit__(self):

+        self.me = new pcl_vis.RangeImageVisualizer()

+        pass

+    

+    def __cinit__(self, string name):

+        self.me = new pcl_vis.RangeImageVisualizer(name)

+        pass

+    

+    def __dealloc__(self):

+        # print('__dealloc__')

+        del self.me

+        pass
+
    

+    # -std::numeric_limits<float>::infinity ()

+    #  std::numeric_limits<float>::infinity ()
+    def ShowRangeImage (self, _pcl.RangeImages range_image, float min_value = -99999.0, float max_value = 99999.0, bool grayscale = False):

+         # self.me.showRangeImage(range_image.thisptr(), min_value, max_value, grayscale)

+         cdef pcl_rngimg.RangeImage_t user

+         user = <pcl_rngimg.RangeImage_t> range_image.thisptr()[0]

+         self.me.showRangeImage(user, min_value, max_value, grayscale)

+    

+    # def MarkPoint(self, int ind_width, int point, int width):

+    #   self.me.markPoint(ind_width, point, width)

+    

+    def SpinOnce (self, int time = 1, bool force_redraw = True):

+        self.me.spinOnce(time, force_redraw)

+    

+

diff --git a/pcl/pxi/pxiInclude.pxi b/pcl/pxi/pxiInclude.pxi
new file mode 100644
index 0000000..b6b9a50
--- /dev/null
+++ b/pcl/pxi/pxiInclude.pxi
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-

+
+### include ###

+# common?

+include "PointXYZtoPointXYZ.pxi"

+# Segmentation

+include "Segmentation/Segmentation.pxi"

+include "Segmentation/SegmentationNormal.pxi"

+include "Segmentation/EuclideanClusterExtraction.pxi"

+# Filters

+include "Filters/StatisticalOutlierRemovalFilter.pxi"

+include "Filters/VoxelGridFilter.pxi"

+include "Filters/PassThroughFilter.pxi"

+include "Filters/ApproximateVoxelGrid.pxi"

+include "Surface/MovingLeastSquares.pxi"

+# include "KdTree/KdTree.pxi"

+include "KdTree/KdTree_FLANN.pxi"

+# Octree

+include "Octree/OctreePointCloud.pxi"

+include "Octree/OctreePointCloud2Buf.pxi"

+include "Octree/OctreePointCloudSearch.pxi"

+include "Octree/OctreePointCloudChangeDetector.pxi"

+include "Vertices.pxi"

+include "Filters/CropHull.pxi"

+include "Filters/CropBox.pxi"

+include "Filters/ProjectInliers.pxi"

+include "Filters/RadiusOutlierRemoval.pxi"

+include "Filters/ConditionAnd.pxi"

+include "Filters/ConditionalRemoval.pxi"

+include "Surface/ConcaveHull.pxi"

+include "Common/RangeImage/RangeImages.pxi"
+
# Registration

+include "registration/GeneralizedIterativeClosestPoint.pxi"

+include "registration/IterativeClosestPoint.pxi"

+include "registration/IterativeClosestPointNonLinear.pxi"

+# SampleConsensus

+include "SampleConsensus/RandomSampleConsensus.pxi"

+include "SampleConsensus/SampleConsensusModelPlane.pxi"

+include "SampleConsensus/SampleConsensusModelSphere.pxi"

+include "SampleConsensus/SampleConsensusModelCylinder.pxi"

+include "SampleConsensus/SampleConsensusModelLine.pxi"

+include "SampleConsensus/SampleConsensusModelRegistration.pxi"

+include "SampleConsensus/SampleConsensusModelStick.pxi"

+# pcl 1.7.2?

+# include "registration/NormalDistributionsTransform.pxi"

+

+# include "Visualization/PointCloudColorHandlerCustoms.pxi"

+
+# Features

+include "Features/NormalEstimation.pxi"

+include "Features/VFHEstimation.pxi"

+include "Features/IntegralImageNormalEstimation.pxi"

+

+# keyPoint

+include "KeyPoint/HarrisKeypoint3D.pxi"

+include "KeyPoint/UniformSampling.pxi"

+

diff --git a/pcl/pxi/pxiInclude_172.pxi b/pcl/pxi/pxiInclude_172.pxi
new file mode 100644
index 0000000..19580db
--- /dev/null
+++ b/pcl/pxi/pxiInclude_172.pxi
@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-

+

+### include ###

+# common?

+include "PointXYZtoPointXYZ.pxi"

+# Segmentation

+include "Segmentation/Segmentation.pxi"

+include "Segmentation/SegmentationNormal.pxi"

+include "Segmentation/EuclideanClusterExtraction.pxi"

+# Filters

+include "Filters/StatisticalOutlierRemovalFilter.pxi"

+include "Filters/VoxelGridFilter_172.pxi"

+include "Filters/PassThroughFilter_172.pxi"

+include "Filters/ApproximateVoxelGrid.pxi"

+include "Surface/MovingLeastSquares.pxi"

+# include "KdTree/KdTree.pxi"

+include "KdTree/KdTree_FLANN.pxi"

+# Octree

+include "Octree/OctreePointCloud_172.pxi"

+include "Octree/OctreePointCloud2Buf_172.pxi"

+include "Octree/OctreePointCloudSearch_172.pxi"

+include "Octree/OctreePointCloudChangeDetector_172.pxi"

+

+include "Vertices.pxi"

+include "Filters/CropHull_172.pxi"

+include "Filters/CropBox_172.pxi"

+include "Filters/ProjectInliers.pxi"

+include "Filters/RadiusOutlierRemoval_172.pxi"

+include "Filters/ConditionAnd.pxi"

+include "Filters/ConditionalRemoval.pxi"

+include "Surface/ConcaveHull.pxi"

+include "Common/RangeImage/RangeImages_172.pxi"

+

+# Registration

+include "registration/GeneralizedIterativeClosestPoint_172.pxi"

+include "registration/IterativeClosestPoint_172.pxi"

+include "registration/IterativeClosestPointNonLinear_172.pxi"

+# SampleConsensus

+include "SampleConsensus/RandomSampleConsensus.pxi"

+include "SampleConsensus/SampleConsensusModelPlane.pxi"

+include "SampleConsensus/SampleConsensusModelSphere.pxi"

+include "SampleConsensus/SampleConsensusModelCylinder.pxi"

+include "SampleConsensus/SampleConsensusModelLine.pxi"

+include "SampleConsensus/SampleConsensusModelRegistration.pxi"

+include "SampleConsensus/SampleConsensusModelStick.pxi"

+# pcl 1.7.2?

+# include "registration/NormalDistributionsTransform.pxi"

+

+# include "Visualization/PointCloudColorHandlerCustoms.pxi"

+

+# Features

+include "Features/NormalEstimation_172.pxi"

+include "Features/VFHEstimation_172.pxi"

+include "Features/IntegralImageNormalEstimation_172.pxi"

+# package ng

+# include "Features/MomentOfInertiaEstimation_172.pxi"

+

+# keyPoint

+include "KeyPoint/HarrisKeypoint3D_172.pxi"

+# execute NG?

+# include "KeyPoint/UniformSampling_172.pxi"

+

+# Registration

+include "registration/NormalDistributionsTransform_172.pxi"

+###

+

+

+

diff --git a/pcl/pxi/pxiInclude_180.pxi b/pcl/pxi/pxiInclude_180.pxi
new file mode 100644
index 0000000..e44b58e
--- /dev/null
+++ b/pcl/pxi/pxiInclude_180.pxi
@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-

+

+### include ###

+# common?

+include "PointXYZtoPointXYZ.pxi"

+# Segmentation

+include "Segmentation/Segmentation.pxi"

+include "Segmentation/SegmentationNormal.pxi"

+include "Segmentation/EuclideanClusterExtraction.pxi"

+# Filters

+include "Filters/StatisticalOutlierRemovalFilter.pxi"

+include "Filters/VoxelGridFilter_180.pxi"

+include "Filters/PassThroughFilter_180.pxi"

+include "Filters/ApproximateVoxelGrid.pxi"

+include "Surface/MovingLeastSquares.pxi"

+# include "KdTree/KdTree.pxi"

+include "KdTree/KdTree_FLANN.pxi"

+# Octree

+include "Octree/OctreePointCloud_180.pxi"

+include "Octree/OctreePointCloud2Buf_180.pxi"

+include "Octree/OctreePointCloudSearch_180.pxi"

+include "Octree/OctreePointCloudChangeDetector_180.pxi"

+

+include "Vertices.pxi"

+include "Filters/CropHull_180.pxi"

+include "Filters/CropBox_180.pxi"

+include "Filters/ProjectInliers.pxi"

+include "Filters/RadiusOutlierRemoval_180.pxi"

+include "Filters/ConditionAnd.pxi"

+include "Filters/ConditionalRemoval.pxi"

+include "Surface/ConcaveHull.pxi"

+include "Common/RangeImage/RangeImages_180.pxi"

+# Registration

+include "registration/GeneralizedIterativeClosestPoint_180.pxi"

+include "registration/IterativeClosestPoint_180.pxi"

+include "registration/IterativeClosestPointNonLinear_180.pxi"

+# SampleConsensus

+include "SampleConsensus/RandomSampleConsensus.pxi"

+include "SampleConsensus/SampleConsensusModelPlane.pxi"

+include "SampleConsensus/SampleConsensusModelSphere.pxi"

+include "SampleConsensus/SampleConsensusModelCylinder.pxi"

+include "SampleConsensus/SampleConsensusModelLine.pxi"

+include "SampleConsensus/SampleConsensusModelRegistration.pxi"

+include "SampleConsensus/SampleConsensusModelStick.pxi"

+# pcl 1.7.2?

+# include "registration/NormalDistributionsTransform.pxi"

+

+# include "Visualization/PointCloudColorHandlerCustoms.pxi"

+

+# Features

+include "Features/NormalEstimation_180.pxi"

+include "Features/VFHEstimation_180.pxi"

+include "Features/IntegralImageNormalEstimation_180.pxi"

+include "Features/MomentOfInertiaEstimation_180.pxi"

+

+# keyPoint

+include "KeyPoint/HarrisKeypoint3D_180.pxi"

+# execute NG?

+# include "KeyPoint/UniformSampling_180.pxi"

+

+# Registration

+include "registration/NormalDistributionsTransform_180.pxi"

+###

+

+

+

diff --git a/pcl/pxi/registration/AddList.txt b/pcl/pxi/registration/AddList.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/pcl/pxi/registration/AddList.txt
diff --git a/pcl/pxi/registration/GeneralizedIterativeClosestPoint.pxi b/pcl/pxi/registration/GeneralizedIterativeClosestPoint.pxi
new file mode 100644
index 0000000..09c4291
--- /dev/null
+++ b/pcl/pxi/registration/GeneralizedIterativeClosestPoint.pxi
@@ -0,0 +1,91 @@
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_160 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class GeneralizedIterativeClosestPoint:
+    """
+    Registration class for GeneralizedIterativeClosestPoint
+    """
+    cdef pcl_reg.GeneralizedIterativeClosestPoint_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        # 1.6.0 NG(No descrription)
+        # reg.setInputSource(source.thisptr_shared)
+        # PCLBase
+        # cdef cpp.PCLBase[cpp.PointXYZ] pclbase
+        # NG(Convert)
+        # pclbase = reg
+        # pclbase = <cpp.PCLBase> reg
+        # pclbase = <cpp.PCLBase[cpp.PointXYZ]> reg
+        # pclbase.setInputCloud(source.thisptr_shared)
+        # pclbase.setInputCloud(<cpp.PointCloudPtr_t> source.thisptr_shared)
+        # set PointCloud?
+        # get InputCloud?
+        # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def gicp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using generalized iterative closest point (GICP).
+        
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.GeneralizedIterativeClosestPoint[cpp.PointXYZ, cpp.PointXYZ] gicp
+        gicp.setInputCloud(source.thisptr_shared)
+        return self.run(gicp, source, target, max_iter)
+
diff --git a/pcl/pxi/registration/GeneralizedIterativeClosestPoint_172.pxi b/pcl/pxi/registration/GeneralizedIterativeClosestPoint_172.pxi
new file mode 100644
index 0000000..d4e717e
--- /dev/null
+++ b/pcl/pxi/registration/GeneralizedIterativeClosestPoint_172.pxi
@@ -0,0 +1,91 @@
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_172 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class GeneralizedIterativeClosestPoint:
+    """
+    Registration class for GeneralizedIterativeClosestPoint
+    """
+    cdef pcl_reg.GeneralizedIterativeClosestPoint_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        # 1.6.0 NG(No descrription)
+        # reg.setInputSource(source.thisptr_shared)
+        # PCLBase
+        # cdef cpp.PCLBase[cpp.PointXYZ] pclbase
+        # NG(Convert)
+        # pclbase = reg
+        # pclbase = <cpp.PCLBase> reg
+        # pclbase = <cpp.PCLBase[cpp.PointXYZ]> reg
+        # pclbase.setInputCloud(source.thisptr_shared)
+        # pclbase.setInputCloud(<cpp.PointCloudPtr_t> source.thisptr_shared)
+        # set PointCloud?
+        # get InputCloud?
+        # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def gicp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using generalized iterative closest point (GICP).
+        
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.GeneralizedIterativeClosestPoint_t gicp
+        gicp.setInputCloud(source.thisptr_shared)
+        return self.run(gicp, source, target, max_iter)
+
diff --git a/pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi b/pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi
new file mode 100644
index 0000000..809f737
--- /dev/null
+++ b/pcl/pxi/registration/GeneralizedIterativeClosestPoint_180.pxi
@@ -0,0 +1,91 @@
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_180 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class GeneralizedIterativeClosestPoint:
+    """
+    Registration class for GeneralizedIterativeClosestPoint
+    """
+    cdef pcl_reg.GeneralizedIterativeClosestPoint_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.GeneralizedIterativeClosestPoint_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        # 1.6.0 NG(No descrription)
+        # reg.setInputSource(source.thisptr_shared)
+        # PCLBase
+        # cdef cpp.PCLBase[cpp.PointXYZ] pclbase
+        # NG(Convert)
+        # pclbase = reg
+        # pclbase = <cpp.PCLBase> reg
+        # pclbase = <cpp.PCLBase[cpp.PointXYZ]> reg
+        # pclbase.setInputCloud(source.thisptr_shared)
+        # pclbase.setInputCloud(<cpp.PointCloudPtr_t> source.thisptr_shared)
+        # set PointCloud?
+        # get InputCloud?
+        # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def gicp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using generalized iterative closest point (GICP).
+        
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.GeneralizedIterativeClosestPoint_t gicp
+        gicp.setInputCloud(source.thisptr_shared)
+        return self.run(gicp, source, target, max_iter)
+
diff --git a/pcl/pxi/registration/IterativeClosestPoint.pxi b/pcl/pxi/registration/IterativeClosestPoint.pxi
new file mode 100644
index 0000000..9a349f4
--- /dev/null
+++ b/pcl/pxi/registration/IterativeClosestPoint.pxi
@@ -0,0 +1,105 @@
+
+from libcpp cimport bool
+
+cimport numpy as np
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_160 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class IterativeClosestPoint:
+    """
+    Registration class for IterativeClosestPoint
+    """
+    cdef pcl_reg.IterativeClosestPoint_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.IterativeClosestPoint_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # def set_InputTarget(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg):
+    def set_InputTarget(self, _pcl.PointCloud cloud):
+        self.me.setInputTarget (cloud.thisptr_shared)
+        pass
+
+    # def get_Resolution(self):
+    #     return self.me.getResolution()
+
+    # def get_StepSize(self):
+    #     return self.me.getStepSize()
+
+    # def set_StepSize(self, double step_size):
+    #     self.me.setStepSize(step_size)
+
+    # def get_OulierRatio(self):
+    #     return self.me.getOulierRatio()
+
+    # def set_OulierRatio(self, double outlier_ratio):
+    #     self.me.setOulierRatio(outlier_ratio)
+
+    # def get_TransformationProbability(self):
+    #     return self.me.getTransformationProbability()
+
+    # def get_FinalNumIteration(self):
+    #     return self.me.getFinalNumIteration()
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def icp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using iterative closest point (ICP).
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.IterativeClosestPoint_t icp
+        icp.setInputCloud(source.thisptr_shared)
+        return self.run(icp, source, target, max_iter)
diff --git a/pcl/pxi/registration/IterativeClosestPointNonLinear.pxi b/pcl/pxi/registration/IterativeClosestPointNonLinear.pxi
new file mode 100644
index 0000000..acc7c61
--- /dev/null
+++ b/pcl/pxi/registration/IterativeClosestPointNonLinear.pxi
@@ -0,0 +1,92 @@
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_160 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class IterativeClosestPointNonLinear:
+    """
+    Registration class for IterativeClosestPointNonLinear
+    """
+    cdef pcl_reg.IterativeClosestPointNonLinear_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.IterativeClosestPointNonLinear_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        # 1.6.0 NG(No descrription)
+        # reg.setInputSource(source.thisptr_shared)
+        # PCLBase
+        # cdef cpp.PCLBase[cpp.PointXYZ] pclbase
+        # NG(Convert)
+        # pclbase = reg
+        # pclbase = <cpp.PCLBase> reg
+        # pclbase = <cpp.PCLBase[cpp.PointXYZ]> reg
+        # pclbase.setInputCloud(source.thisptr_shared)
+        # pclbase.setInputCloud(<cpp.PointCloudPtr_t> source.thisptr_shared)
+        # set PointCloud?
+        # get InputCloud?
+        # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def icp_nl(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using generalized non-linear ICP (ICP-NL).
+        
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.IterativeClosestPointNonLinear_t icp_nl
+        icp_nl.setInputCloud(source.thisptr_shared)
+        return self.run(icp_nl, source, target, max_iter)
+
diff --git a/pcl/pxi/registration/IterativeClosestPointNonLinear_172.pxi b/pcl/pxi/registration/IterativeClosestPointNonLinear_172.pxi
new file mode 100644
index 0000000..ec51055
--- /dev/null
+++ b/pcl/pxi/registration/IterativeClosestPointNonLinear_172.pxi
@@ -0,0 +1,92 @@
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_172 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class IterativeClosestPointNonLinear:
+    """
+    Registration class for IterativeClosestPointNonLinear
+    """
+    cdef pcl_reg.IterativeClosestPointNonLinear_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.IterativeClosestPointNonLinear_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        # 1.6.0 NG(No descrription)
+        # reg.setInputSource(source.thisptr_shared)
+        # PCLBase
+        # cdef cpp.PCLBase[cpp.PointXYZ] pclbase
+        # NG(Convert)
+        # pclbase = reg
+        # pclbase = <cpp.PCLBase> reg
+        # pclbase = <cpp.PCLBase[cpp.PointXYZ]> reg
+        # pclbase.setInputCloud(source.thisptr_shared)
+        # pclbase.setInputCloud(<cpp.PointCloudPtr_t> source.thisptr_shared)
+        # set PointCloud?
+        # get InputCloud?
+        # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def icp_nl(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using generalized non-linear ICP (ICP-NL).
+        
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.IterativeClosestPointNonLinear_t icp_nl
+        icp_nl.setInputCloud(source.thisptr_shared)
+        return self.run(icp_nl, source, target, max_iter)
+
diff --git a/pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi b/pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi
new file mode 100644
index 0000000..c3db5e9
--- /dev/null
+++ b/pcl/pxi/registration/IterativeClosestPointNonLinear_180.pxi
@@ -0,0 +1,92 @@
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_180 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class IterativeClosestPointNonLinear:
+    """
+    Registration class for IterativeClosestPointNonLinear
+    """
+    cdef pcl_reg.IterativeClosestPointNonLinear_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.IterativeClosestPointNonLinear_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        # 1.6.0 NG(No descrription)
+        # reg.setInputSource(source.thisptr_shared)
+        # PCLBase
+        # cdef cpp.PCLBase[cpp.PointXYZ] pclbase
+        # NG(Convert)
+        # pclbase = reg
+        # pclbase = <cpp.PCLBase> reg
+        # pclbase = <cpp.PCLBase[cpp.PointXYZ]> reg
+        # pclbase.setInputCloud(source.thisptr_shared)
+        # pclbase.setInputCloud(<cpp.PointCloudPtr_t> source.thisptr_shared)
+        # set PointCloud?
+        # get InputCloud?
+        # reg.setInputCloud(<cpp.PointCloudPtr_t> pclbase.getInputCloud())
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def icp_nl(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using generalized non-linear ICP (ICP-NL).
+        
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.IterativeClosestPointNonLinear_t icp_nl
+        icp_nl.setInputCloud(source.thisptr_shared)
+        return self.run(icp_nl, source, target, max_iter)
+
diff --git a/pcl/pxi/registration/IterativeClosestPoint_172.pxi b/pcl/pxi/registration/IterativeClosestPoint_172.pxi
new file mode 100644
index 0000000..ed85768
--- /dev/null
+++ b/pcl/pxi/registration/IterativeClosestPoint_172.pxi
@@ -0,0 +1,105 @@
+
+from libcpp cimport bool
+
+cimport numpy as np
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_172 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class IterativeClosestPoint:
+    """
+    Registration class for IterativeClosestPoint
+    """
+    cdef pcl_reg.IterativeClosestPoint_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.IterativeClosestPoint_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # def set_InputTarget(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg):
+    def set_InputTarget(self, _pcl.PointCloud cloud):
+        self.me.setInputTarget (cloud.thisptr_shared)
+        pass
+
+    # def get_Resolution(self):
+    #     return self.me.getResolution()
+
+    # def get_StepSize(self):
+    #     return self.me.getStepSize()
+
+    # def set_StepSize(self, double step_size):
+    #     self.me.setStepSize(step_size)
+
+    # def get_OulierRatio(self):
+    #     return self.me.getOulierRatio()
+
+    # def set_OulierRatio(self, double outlier_ratio):
+    #     self.me.setOulierRatio(outlier_ratio)
+
+    # def get_TransformationProbability(self):
+    #     return self.me.getTransformationProbability()
+
+    # def get_FinalNumIteration(self):
+    #     return self.me.getFinalNumIteration()
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def icp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using iterative closest point (ICP).
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.IterativeClosestPoint_t icp
+        icp.setInputCloud(source.thisptr_shared)
+        return self.run(icp, source, target, max_iter)
diff --git a/pcl/pxi/registration/IterativeClosestPoint_180.pxi b/pcl/pxi/registration/IterativeClosestPoint_180.pxi
new file mode 100644
index 0000000..cef4981
--- /dev/null
+++ b/pcl/pxi/registration/IterativeClosestPoint_180.pxi
@@ -0,0 +1,105 @@
+
+from libcpp cimport bool
+
+cimport numpy as np
+import numpy as np
+
+cimport _pcl
+cimport pcl_defs as cpp
+cimport pcl_registration_180 as pcl_reg
+from boost_shared_ptr cimport shared_ptr
+
+from eigen cimport Matrix4f
+
+np.import_array()
+
+cdef class IterativeClosestPoint:
+    """
+    Registration class for IterativeClosestPoint
+    """
+    cdef pcl_reg.IterativeClosestPoint_t *me
+
+    def __cinit__(self):
+        self.me = new pcl_reg.IterativeClosestPoint_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # def set_InputTarget(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ] &reg):
+    def set_InputTarget(self, _pcl.PointCloud cloud):
+        self.me.setInputTarget (cloud.thisptr_shared)
+        pass
+
+    # def get_Resolution(self):
+    #     return self.me.getResolution()
+
+    # def get_StepSize(self):
+    #     return self.me.getStepSize()
+
+    # def set_StepSize(self, double step_size):
+    #     self.me.setStepSize(step_size)
+
+    # def get_OulierRatio(self):
+    #     return self.me.getOulierRatio()
+
+    # def set_OulierRatio(self, double outlier_ratio):
+    #     self.me.setOulierRatio(outlier_ratio)
+
+    # def get_TransformationProbability(self):
+    #     return self.me.getTransformationProbability()
+
+    # def get_FinalNumIteration(self):
+    #     return self.me.getFinalNumIteration()
+
+    cdef object run(self, pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ, float] &reg, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        reg.setInputTarget(target.thisptr_shared)
+        
+        if max_iter is not None:
+            reg.setMaximumIterations(max_iter)
+        
+        cdef _pcl.PointCloud result = _pcl.PointCloud()
+        
+        with nogil:
+            reg.align(result.thisptr()[0])
+        
+        # Get transformation matrix and convert from Eigen to NumPy format.
+        # cdef pcl_reg.Registration[cpp.PointXYZ, cpp.PointXYZ].Matrix4f mat
+        cdef Matrix4f mat
+        mat = reg.getFinalTransformation()
+        cdef np.ndarray[dtype=np.float32_t, ndim=2, mode='fortran'] transf
+        cdef np.float32_t *transf_data
+        
+        transf = np.empty((4, 4), dtype=np.float32, order='fortran')
+        transf_data = <np.float32_t *>np.PyArray_DATA(transf)
+        
+        for i in range(16):
+            transf_data[i] = mat.data()[i]
+        
+        return reg.hasConverged(), transf, result, reg.getFitnessScore()
+
+    def icp(self, _pcl.PointCloud source, _pcl.PointCloud target, max_iter=None):
+        """
+        Align source to target using iterative closest point (ICP).
+        Parameters
+        ----------
+        source : PointCloud
+            Source point cloud.
+        target : PointCloud
+            Target point cloud.
+        max_iter : integer, optional
+            Maximum number of iterations. If not given, uses the default number
+            hardwired into PCL.
+        Returns
+        -------
+        converged : bool
+            Whether the ICP algorithm converged in at most max_iter steps.
+        transf : np.ndarray, shape = [4, 4]
+            Transformation matrix.
+        estimate : PointCloud
+            Transformed version of source.
+        fitness : float
+            Sum of squares error in the estimated transformation.
+        """
+        cdef pcl_reg.IterativeClosestPoint_t icp
+        icp.setInputCloud(source.thisptr_shared)
+        return self.run(icp, source, target, max_iter)
diff --git a/pcl/pxi/registration/NormalDistributionsTransform_172.pxi b/pcl/pxi/registration/NormalDistributionsTransform_172.pxi
new file mode 100644
index 0000000..8571a44
--- /dev/null
+++ b/pcl/pxi/registration/NormalDistributionsTransform_172.pxi
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# pcl version 1.7.2
+cimport pcl_defs as cpp
+cimport pcl_registration_172 as pclreg
+
+cdef class NormalDistributionsTransform:
+    """
+    Registration class for NormalDistributionsTransform
+    """
+    cdef pclreg.NormalDistributionsTransform_t *me
+
+    def __cinit__(self):
+        self.me = new pclreg.NormalDistributionsTransform_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # def set_InputTarget(self, pclreg.RegistrationPtr_t cloud):
+    def set_InputTarget(self):
+        # self.me.setInputTarget (cloud.this_ptr())
+        pass
+
+    def set_Resolution(self, float resolution):
+        self.me.setResolution(resolution)
+        pass
+
+    def get_Resolution(self):
+        return self.me.getResolution()
+
+    def get_StepSize(self):
+        return self.me.getStepSize()
+
+    def set_StepSize(self, double step_size):
+        self.me.setStepSize(step_size)
+
+    def get_OulierRatio(self):
+        return self.me.getOulierRatio()
+
+    def set_OulierRatio(self, double outlier_ratio):
+        self.me.setOulierRatio(outlier_ratio)
+    
+    def get_TransformationProbability(self):
+        return self.me.getTransformationProbability()
+    
+    def get_FinalNumIteration(self):
+        return self.me.getFinalNumIteration()
+
diff --git a/pcl/pxi/registration/NormalDistributionsTransform_180.pxi b/pcl/pxi/registration/NormalDistributionsTransform_180.pxi
new file mode 100644
index 0000000..a437596
--- /dev/null
+++ b/pcl/pxi/registration/NormalDistributionsTransform_180.pxi
@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# pcl version 1.8.0
+cimport pcl_defs as cpp
+cimport pcl_registration_180 as pclreg
+
+cdef class NormalDistributionsTransform:
+    """
+    Registration class for NormalDistributionsTransform
+    """
+    cdef pclreg.NormalDistributionsTransform_t *me
+
+    def __cinit__(self):
+        self.me = new pclreg.NormalDistributionsTransform_t()
+
+    def __dealloc__(self):
+        del self.me
+
+    # def set_InputTarget(self, pclreg.RegistrationPtr_t cloud):
+    def set_InputTarget(self):
+        # self.me.setInputTarget (cloud.this_ptr())
+        pass
+
+    def set_Resolution(self, float resolution):
+        self.me.setResolution(resolution)
+        pass
+
+    def get_Resolution(self):
+        return self.me.getResolution()
+
+    def get_StepSize(self):
+        return self.me.getStepSize()
+
+    def set_StepSize(self, double step_size):
+        self.me.setStepSize(step_size)
+
+    def get_OulierRatio(self):
+        return self.me.getOulierRatio()
+
+    def set_OulierRatio(self, double outlier_ratio):
+        self.me.setOulierRatio(outlier_ratio)
+    
+    def get_TransformationProbability(self):
+        return self.me.getTransformationProbability()
+    
+    def get_FinalNumIteration(self):
+        return self.me.getFinalNumIteration()
+
diff --git a/pcl/vector.pxd b/pcl/vector.pxd
index 050c28c..30c2f41 100644
--- a/pcl/vector.pxd
+++ b/pcl/vector.pxd
@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 cdef extern from "<vector>" namespace "std":
     cdef cppclass vector[T, A]:
         cppclass iterator: